An introduction to Verse: Epic’s new scripting language for Unreal Editor for Fortnite, and how it differs from Blueprints and C++.
This project is a collection of game mechanics implemented in Verse within UEFN (Unreal Editor for Fortnite), following Epic’s official documentation and learning resources. It stands apart from every other project in this series: no Blueprints, no C++, and a completely different execution model. UEFN is Unreal’s platform for building custom Fortnite Creative experiences, and Verse is the purpose-built scripting language that drives them — worth understanding both because of its novel design and because it represents the direction Epic is investing in for the future of scripting in Unreal.
You can watch the mechanics in action here: YouTube
What is UEFN?
UEFN is a version of the Unreal Editor adapted for building experiences within Fortnite Creative. It provides access to a subset of Unreal’s world-building tools — terrain, lighting, assets from Fortnite’s asset library — combined with the ability to deploy the experience directly to Fortnite, where it runs at scale for Fortnite’s player base. The platform handles multiplayer, matchmaking, and infrastructure automatically. The developer focuses on the experience itself.
The constraint is that UEFN operates within Fortnite’s sandbox — you’re building inside an existing game, not building a standalone game. The physics, character movement, and core gameplay systems are Fortnite’s, not custom. What’s configurable is the level design, the scripted behaviors, and the game mode rules.
What is Verse?
Verse is a new programming language designed by Epic specifically for UEFN. It is not a scripting layer on top of C++ or a visual system like Blueprints — it is a distinct language with its own type system, runtime semantics, and execution model. Understanding what makes Verse novel requires comparing it to the two systems most UE5 developers already know.
Compared to Blueprints: Verse is text-based code, not a visual node graph. It has explicit types, explicit control flow, and the full expressive power of a programming language — loops, conditions, functions, classes. Blueprint graphs are easier to read for non-programmers and excellent for rapid prototyping; Verse is more powerful for complex logic and version-controllable as plain text.
Compared to C++: Verse is significantly safer. It has no raw pointers, no manual memory management, and no undefined behavior from memory corruption. It also has a fundamentally different concurrency model — one of its most distinctive features.
Verse Concurrency: Async and Await Without Threads
The most architecturally significant aspect of Verse is its concurrency model. In C++, concurrent operations require threads, which require synchronization primitives (mutexes, atomics) to avoid race conditions. In Blueprints, sequences of async operations require chains of event nodes that are hard to read and maintain. Verse introduces structured concurrency that is both simpler to write and safer by design.
In Verse, functions that take time — waiting for a timer, waiting for a player to interact with something, waiting for an event — are marked as <suspends>. A <suspends> function can be awaited with a simple await expression, pausing the current execution until the operation completes without blocking the entire game thread. Multiple concurrent operations can be composed with race (run all, return when the first completes) and sync (run all, return when all complete), making complex timed behaviors readable as sequential code.
This is what makes the timed mechanics in this project straightforward to implement in Verse — a platform that disappears after a delay, waits, and reappears is just a loop with awaited delays, not a state machine with timers and callbacks.
The Mechanics
The six mechanics implemented cover a range of Verse and UEFN device capabilities:
Countdown timer: a Verse script that decrements a counter each second and updates a display device. In Verse, this is a loop with Sleep(1.0) — the <suspends> sleep — inside it, making the intent of “do this every second” read directly as code rather than requiring a Blueprint timer callback structure.
Periodic platform: a platform that toggles between visible/enabled and hidden/disabled on a fixed interval. Again, a loop with a sleep — the simplicity of this in Verse demonstrates how well the concurrency model maps to timed game logic.
Touch-and-disappear platform: a platform that deactivates when the player touches it and reactivates after a random delay. The random delay — GetRandomFloat(minSeconds, maxSeconds) passed to Sleep() — makes each reactivation unpredictable, which is harder to achieve cleanly with Blueprint timers.
Moving objective marker: a marker that relocates to a new position periodically, requiring the player to navigate to a changing target. This uses UEFN’s objective device combined with Verse scripting to update the target location.
Sequential platform sequence: multiple platforms managed by a single Verse device, activating and deactivating in sequence. A single script coordinates N platforms with indexed delays, demonstrating that one Verse device can own and orchestrate multiple world actors — a cleaner alternative to one Blueprint per platform.
Light combination puzzle: the most architecturally complex mechanic. The player must find the correct combination of lights (on/off) to spawn an item. The Verse device holds the correct solution state, listens for player interaction with each light toggle, and compares the current light state against the solution after each change. When the combination matches, the item spawns. This is a custom device created entirely in Verse — a reusable component that encapsulates the puzzle logic and can be placed in any level.
Verse’s Type System: Optionals and Failure
One aspect of Verse that stands out to C++ developers is its treatment of failure. In C++, a function that might fail typically returns a boolean or throws an exception — both of which require the caller to handle failure explicitly but don’t enforce it at the type level. In Verse, operations that might not produce a value return an optional type (?Type), and accessing an optional value requires an explicit check that the compiler enforces. You cannot accidentally treat an absent value as present — the type system prevents it.
This is similar to TOptional<T> in Unreal C++, but in Verse it’s pervasive and enforced by default rather than opt-in. Functions that can fail are marked with <fails>, and calling them requires handling the failure case. This produces code that is more verbose but significantly more correct — a common source of crashes in C++ (null dereference, out-of-bounds access) is simply not expressible in Verse.
Reflection
Verse is a genuinely interesting language to study even for developers who don’t plan to build Fortnite experiences. Its concurrency model — structured, composable, without threads — is an elegant solution to a problem that makes async game logic difficult in every other environment. Its type system enforces correctness in ways that Blueprint and C++ don’t by default. And its design reflects Epic’s thinking about what a modern game scripting language should look like.
For a developer coming from C++, Verse feels restrictive at first — there are things you can do in C++ that Verse won’t allow. But the restrictions are deliberate: they eliminate entire categories of bugs at the language level rather than relying on developer discipline. Whether Verse expands beyond UEFN into the broader Unreal ecosystem is an open question, but understanding it now is worthwhile regardless.
Nicolás Bertoa 
Leave a comment