UEFN TOOLBELT

355 Professional Tools for UEFN Python Integration.

Built by Ocean Bennett — 2026

---

Historic Discovery — March 22, 2026

On this date, Ocean Bennett became the first person to programmatically catalogue the complete Fortnite Creative device palette using UEFN Python's Asset Registry — 4,698 Creative device Blueprints across 35 categories, extracted from 24,926 total Blueprint assets in the sandboxed UEFN environment.

Prior to this, no public tool, script, or documentation existed that mapped the full set of placeable Creative devices accessible from Python. Epic's own documentation covers individual devices. This is the first machine-readable index of the entire palette.

The scan also uncovered a critical silent failure pattern in UEFN 40.00's Asset Registry API: deprecated AssetData properties (object_path, asset_class) silently throw inside a try/except block, causing every asset to be skipped with no error message — a bug that would defeat any developer who didn't know to split the exception handling.

The full technical breakdown, the category table, and the discovery story are in docs/AI_AUTONOMY.md.

---

Automate the tedious, script the impossible, and bridge the gap between Python and Verse. UEFN Toolbelt is a master utility designed to leverage the 2026 UEFN Python 3.11 Update, allowing creators to manipulate actors, manage assets, and generate boilerplate Verse code through a high-level, developer-friendly interface — all from a single persistent menu entry in the UEFN editor bar. 355 registered tools across 55 categories, complete AI-agent readiness (100% structured dict returns), and a unified theme system so every window in the platform looks and feels identical.

---

The Demo — New Project Setup in Under a Minute

Proven live. Scaffold + Verse game manager + 493-actor arena + reusable room stamps. No manual steps except one Build click.

# Command 1 — professional folder structure + Verse game manager deployed
tb.run("project_setup", project_name="MyGame")
# → 56 folders created in Content Browser
# → MyGameManager.verse generated and deployed to project

# Command 2 — symmetrical Red vs Blue arena spawns in the viewport
tb.run("arena_generate", size="medium")
# → 493 actors placed (6 Red spawns, 6 Blue spawns)

# Command 3 — save a loot room you built as a reusable stamp
tb.run("stamp_save", name="loot_room")
# → saved 12 actors to Saved/UEFN_Toolbelt/stamps/loot_room.json

# Navigate camera to a new location, then stamp it in
tb.run("stamp_place", name="loot_room", yaw_offset=90)
# → 12 FortStaticMeshActors placed at camera, rotated 90°

# One click — Verse menu → Build Verse Code

# Command 4 — error loop closes automatically
tb.run("verse_patch_errors")
# → build_status: SUCCESS

What used to take 30+ minutes of manual setup runs in seconds. Scaffold, code, layout, stamp your best rooms, build — ready to publish.

---

🤖 Claude Can Build Your Game — Autonomously

This is the headline feature. Not "AI helps you code" — AI reads your live level, writes the Verse, and deploys it. Zero copy-paste. Zero manual wiring.

Here is the complete autonomy loop running live on a real project with 521 actors:

Step 1a — Claude reads the entire level:

tb.run("world_state_export")
# → Captured 521 actors. Saved to docs/world_state.json

Step 1b — Claude reads every device available in Fortnite (not just what's placed):

tb.run("device_catalog_scan")
# → Scanned 24,926 Blueprint assets across all Fortnite packages
# → 4,698 Creative devices identified across 35 categories
# → (Timer ×8, Capture ×7, Score ×28, Spawner ×94, Camera ×446, NPC ×173, ...)
# → docs/device_catalog.json — Claude's complete device palette, git-tracked

Step 2 — Claude identifies all Creative devices and generates a wired game skeleton:

Claude reads world_state.json, finds every device in the level (FortCreativeTimerDevice, capture_area_device, guard_spawner_device, button_device, 14 teleporters, etc.), and writes a complete creative_device class — @editable declarations, OnBegin event wiring, round flow, creature waves, capture logic, and clean shutdown — all referencing the actual device labels from your level.

Step 3 — Claude deploys it directly to the project:

tb.run("verse_write_file", filename="device_api_game_manager.verse", content=verse_code)
# → Written: Device_API_Mapping\Verse\device_api_game_manager.verse (6187 bytes)

Step 4 — Build Verse. First try.

VerseBuild: SUCCESS -- Build complete.

No type errors. No manual editing. A fully wired, compilable Verse game manager — generated from live level state in under 60 seconds.

What the generated skeleton contains:

• @editable refs for every device discovered: Timer, Timed Objective, Round Settings, Capture Area, 2× Item Spawners, Creature Spawner, Creature Manager, Creature Placer, 2× Buttons, 2× Conditional Buttons, Lock Device, 5 keyed Teleporters, Audio Mixer, Weapon Mod Bench
• OnBegin that starts the timer, spawns async watchers, and subscribes to all button/timer events
• WatchCaptureArea() — async loop: team captures zone → spawn reward items → trigger creature wave
• WatchCreatureWaves() — async loop: enable creature manager → 30s cooldown → repeat
• OnButtonPressed / OnButton2Pressed — unlock doors, activate conditional gates
• EndRound() — stops timer, disables creature manager, despawns guards, stops audio

Place the device in your level, drag your real actors into the @editable slots, and play.

See docs/PIPELINE.md for the complete 6-phase industrial pipeline — every tool, every phase, Claude's full execution script, and the recursive build+fix loop. See docs/AI_AUTONOMY.md for the live run technical breakdown.

---

🤖 AI-Accelerated Development (One-Click Sync + Tool Manifest)

Toolbelt is built to be used with AI (Claude/Gemini). To give your AI perfect information about your project's unique Verse devices and custom props:

1. Open Dashboard: Run tb.launch_qt() or use the Toolbelt menu.
2. One-Click Sync: Click the "Sync Level Schema to AI" button in Quick Actions.
3. Instant Content: The 1.6MB schema is automatically copied to your docs/ folder. Your AI now knows every hidden property in your specific level.
4. Export Tool Manifest: Run tb.run("plugin_export_manifest") to write Saved/UEFN_Toolbelt/tool_manifest.json — a machine-readable index of all 358 tools with their parameter signatures, types, defaults, and categories. An AI agent can load this file and immediately know what every tool does and how to call it, without reading source code.

---

Table of Contents

• Claude Can Build Your Game — Autonomously
• Concept
• The Workflow Loop — Efficiency Mechanic
• Tech Stack
• Architecture Overview
• Directory Structure
• Key Systems — How They Work
• Math & Performance Scaling
• Tool Reference
• Getting Started
• Adding a New Tool
• Custom Plugins & Security
• API Capability Crawler
• Fortnite Device API Mapping
• MCP — Connect Any AI to UEFN
• Spec-Accurate Verse Code Generation
• CLAUDE.md — Instant AI Context
• Why This Is the Best UEFN Python Tool
• Documentation
• Quick-Reference Command Table
• Patch Notes
• Contributing
• Tool Requests
• License

---

Security

Why this matters: The UEFN Python community has already seen proof-of-concept malicious scripts that flood the editor with spam windows when run from untrusted sources. Python editor scripts run with full access to your project — treat them like executable code.

This repo's safety guarantees

| Practice | How it's enforced here | |---|---| | Audited code | Every line in this repo is open-source and reviewable | | No network calls | Zero outbound HTTP/socket connections anywhere in the codebase | | No file writes outside project | All output goes to Saved/UEFN_Toolbelt/ inside your project | | No eval/exec on external input | No dynamic code execution from files, URLs, or user strings | | Undo-safe | Every destructive operation is wrapped in ScopedEditorTransaction |

How to verify before running any .py file (from this repo or anyone's)

# Before exec()-ing any script, read it first:
with open("path/to/script.py") as f:
    print(f.read())

# Red flags to look for:
# - import requests / import http / import socket
# - exec() / eval() on anything fetched from outside
# - os.system() / subprocess with network targets
# - anything writing outside your project folder

Running untrusted community scripts safely

1. Always read the script before running it
2. Run unknown scripts in a throwaway project first
3. Keep UEFN's Python access set to Editor Scripting only (the default)

---

⚠️ Automated Integration Testing

The smoke test verifies that all tools register correctly. The integration test verifies that they work — in a live UEFN editor, against real actors.

What the integration test actually does

toolbelt_integration_test is a fixture-driven test harness that runs inside UEFN:

1. Spawns temporary cube/sphere actors programmatically
2. Selects them via EditorActorSubsystem
3. Runs each tool against that live selection
4. Verifies the result — property changed, actor spawned, file written, count correct
5. Cleans up every actor it touched via a single undo transaction

163 tests across 358 tools — covering materials, bulk ops, patterns, scatter, splines, snapshots, asset management, Verse tools, screenshots, LODs, arena, measurement, localization, zones, stamps, actor org, proximity placement, advanced alignment, signs, post-process, audio, level health, config, lighting, and world state.

This is the closest thing to a full CI suite possible inside the UEFN Python sandbox. If this passes, you have high confidence that the core tool logic is sound — not just that it imported.

How to run it

# Use a clean template level — never run in a production project
import UEFN_Toolbelt as tb; tb.register_all_tools(); tb.run("toolbelt_integration_test")

Results are written to:

Saved/UEFN_Toolbelt/integration_test_results.txt

If the editor crashes mid-run (rare), the file will contain partial results up to the last completed test — useful for pinpointing which section caused the crash.

[!WARNING] DO NOT run the full integration test in a live production project. It spawns, modifies, and deletes actors. Use a blank Empty Level or throwaway test project. Every test section cleans up after itself, but the und