Deathrun in UEFN: The Obstacle Gauntlet

Deathrun is the precision-platforming gauntlet: a linear course of jumps, traps, and timing puzzles where one mistake sends you back to the last checkpoint. It's rage-bait and dopamine in equal measure, and it's one of the most-played categories in all of Creative. This Game Modes entry breaks the format down and builds a compile-verified Verse device that tracks checkpoints and times each runner to the finish.

1. What it is

<!-- section-art:1-what-it-is -->

Deathrun Gauntlet

A Deathrun is a single-path obstacle course built from hazards: spinning blades, disappearing platforms, launchpad gaps, timed lava. Players progress jump by jump, dying constantly, respawning at the most recent checkpoint they touched. The goal is simply to reach the end — and, for the competitive crowd, to do it fast.

It's the closest Fortnite gets to a Mario level: pure execution, no combat, the map itself is the opponent.

2. Type of game

3. The loop

Run, die, respawn at the checkpoint, try again — until you clear the obstacle and the next checkpoint becomes your new floor.

Each cleared checkpoint is a tiny, real victory; the loop is "fail fast, retry instantly," which is exactly what makes it so addictive.

4. Why it's fun

• Pure, fair execution. No RNG, no enemies you can't see — every death is your mistake, so every clear is your win.
• Instant retry. Respawn is immediate at the checkpoint, so frustration never gets time to set in.
• Visible progress. Each checkpoint is a save point you can't lose — the bar only ever moves forward.
• Speedrun depth. Casual players just want to finish; the hardcore optimize routes and chase leaderboard times.
• Solo but social. Everyone runs the same course at once, so you race friends and trash-talk in real time.

5. Who made the great ones

Deathrun has defining auteurs:

• Cizzorz — the genre's most famous name. Cizzorz Deathrun 4.0 (code 2778-3253-4171) is infamously brutal — precise jumps, timed traps, puzzle obstacles — and basically defined the "creator deathrun" format.
• M-MAYOOO — The Best Default Deathrun! (code 3968-4916-5353), a go-to for the clean, classic default-skin obstacle feel.
• High-volume builders like fankimonkey (200-level casual runs) and mr.gg (200+ levels across biomes with secrets) show the "more levels, more variety" school of design.

6. Examples / variants

• Default deathrun — classic blocky obstacles, the purest test of jump/edit timing.
• Themed / story — biomes, set-pieces, secrets, even pets — the mr.gg approach.
• Brutal / troll — fake paths and unfair-looking jumps that are actually precise (the Cizzorz school).
• Co-op deathrun — obstacles that need two players (one holds a button, the other crosses).

7. How to make it in UEFN / Verse

<!-- section-art:7-how-to-make-it-in-uefn-verse -->

Checkpoint Tracker

The devices you'll place

• Race Checkpoint Device (race_checkpoint_device) — each checkpoint along the course; it fires CheckpointCompletedEvent when a runner reaches it and sets their respawn.
• Race Manager Device (race_manager_device) — owns the race itself; fires RaceCompletedEvent when a runner finishes, with LapCompletedEvent/FirstLapCompletedEvent for split tracking.
• Player Spawn Pad at the start; hazards (spikes, mutators, launch pads) built from props/devices in between.

The Verse mechanic that ties it together

The checkpoints and respawns are device-driven. Verse owns the progress + timing: count how many checkpoints a runner has cleared and announce their finish. The series pattern holds — subscribe to the event, react — across both the checkpoint and the manager.

# race_checkpoint_device fires when a runner reaches it:
#   CheckpointCompletedEvent : agent
# race_manager_device fires when a runner finishes the course:
#   RaceCompletedEvent : agent
Checkpoint.CheckpointCompletedEvent.Subscribe(OnCheckpoint)
RaceManager.RaceCompletedEvent.Subscribe(OnFinish)

To track per-runner progress, key a map by the agent — the same [agent]int pattern you'll reuse everywhere:

var Progress : [agent]int = map{}
Current := Progress[Runner] or 0   # checkpoints this runner has cleared

The full, compile-verified progress tracker

Drop this deathrun_tracker_device into your project, wire the @editable Race Manager and the array of @editable checkpoints, and it counts each runner's progress and announces every finish. Standalone creative_device.

How it works, line by line

1. @editable Checkpoints : []race_checkpoint_device is an array — drag every checkpoint in, in order, from the Details panel.
2. OnBegin loops the array and subscribes once per checkpoint to CheckpointCompletedEvent. One handler covers them all because progress is keyed by the runner.
3. Progress : [agent]int keys each runner's checkpoint count by their agent — clean per-player state.
4. Progress[Runner] or 0 reads the running count (default 0 for a fresh runner); the set ... = ... is wrapped in if (...) {} because map-set is failable.
5. RaceManager.RaceCompletedEvent fires on finish — that's where you'd record the time and award the win.

Gotchas

• Checkpoints set respawns — let them. Don't reimplement respawn in Verse; the Race Checkpoint device already does it. Verse just counts.
• Order the array deliberately. The []race_checkpoint_device order is your authoring order; keep it matched to the course so "#3 of 12" reads correctly.
• Map-set is failable. if (set Progress[Runner] = NewCount) {} — the empty block satisfies the failure context. This trips up everyone once.
• Tune difficulty with a ramp. Early checkpoints easy, late ones brutal. A wall too early kills retention; players quit at the first unfair jump.
• For times, stamp on finish. Read a clock at start and at RaceCompletedEvent for a real speedrun timer — the Race Manager's events are your split points.

Recap

• Deathrun is a linear precision-platforming gauntlet: clear obstacles, touch checkpoints, reach the end.
• The fun is fair, instant-retry execution with always-forward progress and speedrun depth on top.
• In UEFN the Race Checkpoint and Race Manager devices own respawns and the race; they fire CheckpointCompletedEvent and RaceCompletedEvent.
• The Verse pattern is the series staple: subscribe to each checkpoint, count progress in an [agent]int map, announce the finish.
• Difficulty ramp and a fair first jump decide whether players stay.