UEFN TOOLBELT
362 Professional Tools for UEFN Python Integration.
Built by Ocean Bennett — 2026
Potencia tu agente
Instalación del publicador. No es un endpoint de PlugMCP.
Host a copy with our keys and logs.
Aún no hay una versión empaquetada en el registro. Sigue el README del repositorio.
¿URL remota o un comando en tu máquina? En qué se diferencian las dos instalaciones
Ejecutar en PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
AbrirDel publicador
UEFN Toolbelt: 362 Python automation tools across 55 categories, with a PySide6 dashboard and an experimental, authenticated same-user loopback bridge for local AI control. Complements Epic's official UEFN MCP; Toolbelt is not exposed through Epic's MCP server.

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
AssetDataproperties (object_path,asset_class) silently throw inside atry/exceptblock, 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 the PySide6 dashboard
(tb.launch_qt()). 362 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.
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.
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 BenchOnBegin that starts the timer, spawns async watchers, and subscribes to all button/timer eventsWatchCaptureArea() — async loop: team captures zone → spawn reward items → trigger creature waveWatchCreatureWaves() — async loop: enable creature manager → 30s cooldown → repeatOnButtonPressed / OnButton2Pressed — unlock doors, activate conditional gatesEndRound() — stops timer, disables creature manager, despawns guards, stops audioPlace 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.
Toolbelt is built to be driven by a coding agent — Claude Code, Codex, or Cursor. To give your agent perfect information about your project's unique Verse devices and custom props:
tb.launch_qt().docs/ folder. Your AI now knows every hidden property in your specific level.tb.run("plugin_export_manifest") to write Saved/UEFN_Toolbelt/tool_manifest.json — a machine-readable index of all 362 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.If Toolbelt stops loading on startup, this is almost certainly why.
Enabling Project Settings → Beta Access → UEFN MCP Toolsets prevents your
project's Content/Python/init_unreal.py from running, so Toolbelt never starts.
Nothing errors and nothing is logged. The tool count is 1 instead of 362 and
every tb.run(...) answers Unknown tool, which looks like a Toolbelt bug and
is not one.
Cause. Epic's Toolsets plugins force-enable Python during editor init, about
100 frames before UEFN mounts your project plugin. Your init_unreal.py is not
scanned because the plugin containing it has not loaded yet. Verified by diffing
editor logs across boots with the flag on and off — see docs/UEFN_QUIRKS.md #36.
Workaround. Either turn the flag off, or run this once per editor session:
import UEFN_Toolbelt as tb; tb.register()
That recovers all 362 tools and the dashboard (tb.launch_qt()). It does not
make a top-bar menu appear: menu entries register on 42.00 and still never
render. Epic's MCP continues to work either way; only Toolbelt's auto-start is
affected.
tb.smoke_test() detects this and names it, so you are never left guessing.
Status. Not fixable from Toolbelt: PythonScriptPluginSettings is not exposed
to Python on this build, and UEFN projects have no Config/ directory for an
explicit startup-script entry. It needs an Epic-side fix.
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.
.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
The smoke test checks registration only: a minimum registry count (179) and six named tools; it executes no tool and validates no schema. The integration test verifies that they work — in a live UEFN editor, against real actors.
toolbelt_integration_test is a fixture-driven test harness that runs inside UEFN:
EditorActorSubsystem190 checks across 362 tools — 190/190 passing live on UEFN 42.00 — 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.
Of those 190, 163 verify a real outcome — a property changed, a file written, an actor count, a tag read back — and 27 are execution-only: they prove the tool ran without raising, nothing more. Both numbers are reported by the suite on every run, because a headline "190/190" that silently includes checks which cannot fail overstates what the suite knows. That is not hypothetical: a fully green run once hid a wrong-rotation-axis bug (Quirk #41) for exactly that reason.
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. The current live run takes about 70 seconds.
# 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 undo history will be long.
Run the smoke test after every change. Run the integration test before submitting a PR.
Community context: Built in response to the March 2026 UEFN Python wave. Inspired by early community tools like standalone material editors, spline prop placers, and Verse device editors — then taken further into a unified, permanently docked creator toolkit.
UEFN Toolbelt isn't just a library — it's a meta-framework. While the standard UEFN Python API provides the what, Toolbelt provides the how. It follows a Blueprint-to-Script philosophy: taking complex manual editor tasks (mass material assignment, procedural arena generation, bulk Verse device editing) and reducing them to single-line Python commands callable from the dashboard or the Python console.
The toolbelt is designed for three creator personas:
The UEFN Toolbelt exists because manual work doesn't scale, but scripts do. We solve 90% of the repetitive tasks reported by the UEFN community:
dict — AI agents operate on results, not logs. The MCP bridge, tool_manifest.json, and describe_tool command let any LLM discover and call every tool autonomously. This is the first UEFN toolkit designed to be equally usable by humans and AI agents.Every single one of the 362 tools returns a clean, structured dict. No None returns. No bare primitives. No output that requires parsing log lines. This was completed as Phase 21 and applies to every tool added since.
# Asset scan
{"status": "ok", "count": 4, "textures": [
{"name": "T_Rock", "path": "/Device_API_Mapping/Textures/T_Rock",
"compression": "TC_DEFAULT", "srgb": "true", "size_x": "2048", "size_y": "2048"}
]}
# Audit
{"status": "ok", "total": 12, "clean": 10, "issues": 2, "issue_list": [
{"name": "SK_Hero", "path": "/Device_API_Mapping/Characters/SK_Hero",
"issues": ["No physics asset assigned"]}
]}
# Write op (dry_run)
{"status": "ok", "dry_run": true, "changed": 8, "skipped": 3, "changes": [
{"name": "T_Wall", "from": "TC_DEFAULT", "to": "TC_NORMALMAP"}
]}
# Error — always catchable
{"status": "error", "message": "Could not load asset at '/Game/Missing'."}
Claude Code → MCP server → run_tool → registry.execute() → _serialize(result) → JSON response → Claude reads it
Claude never has to parse a log line. Every domain follows the same shape:
tb.run("plugin_export_manifest") writes Saved/UEFN_Toolbelt/tool_manifest.json — a machine-readable index of all 362 tools with full parameter signatures (name, type, required, default) and a concrete example call string for every tool. Claude reads this once and knows exactly what params to pass to any tool without guessing.
This is the core philosophy. We solve the "Iteration Tax" — the time lost between an idea and its implementation in the editor.
$$T_{\text{save}} = (T_{\text{manual}} \times N) - (T_{\text{script}} + T_{\text{execution}})$$
UEFN Editor
│
│ init_unreal.py ← auto-executed by UEFN on every startup
│ (generic submodule loader — NOT part of the Toolbelt package)
│ If you already have one, add the package-discovery pattern
│ from the provided template instead of overwriting yours.
▼
UEFN TOOLBELT ─── UEFN_Toolbelt/__init__.py (register, launch, run, registry accessor)
│
├── core.py Shared utilities: undo_transaction, get_selected_actors,
│ with_progress, color_from_hex, spawn_static_mesh_actor, …
│
├── registry.py ToolRegistry singleton — @register_tool decorator,
│ execute-by-name, category listing, tag search,
│ to_manifest() for full parameter-introspected export
│
└── tools/
├── material_master.py 17 presets, gradient, harmony, team split, save/load
├── arena_generator.py Symmetrical Red/Blue arenas (S/M/L)
├── spline_prop_placer.py Props along splines — count or distance mode
├── bulk_operations.py Align, distribute, randomize, snap, mirror, stack
├── verse_device_editor.py List, filter, bulk-edit, export Verse devices
├── smart_importer.py FBX batch import + auto-material + Content Browser organizer
├── verse_snippet_generator.py Context-aware Verse boilerplate from level selection
├── text_painter.py Colored 3D text actors with saved style presets
├── asset_renamer.py Epic naming convention enforcer with dry-run + audit
├── project_scaffold.py Professional folder structure generator (4 templates)
├── verse_schema.py Verse Digest IQ & Universal Schema Search (143th Tool)
├── system_build.py Automated UEFN Build Scraper & Error Monitor
├── system_perf.py Background CPU Optimizer & Monitor
├── measurement_tools.py Distance Calculator & Travel Time Estimator (Phase 15)
└── localization_tools.py Multi-language Text Export/Import (Phase 15)
All heavy logic lives in Python. The optional UMG dashboard calls into it via
Execute Python Command Blueprint nodes — zero coupling, infinitely extensible.
[YourUEFNProject]/
├── Content/
│ ├── Python/
│ │ ├── init_unreal.py ← COPY HERE if you don't have one yet
│ │ │ (generic loader — not Toolbelt-specific)
│ │ │ ⚠️ If you already have this file, do NOT
│ │ │ overwrite it. Add the package-discovery
│ │ │ loop from the template into your existing file.
│ │ └── UEFN_Toolbelt/ ← COPY HERE — the full package
│ │ ├── __init__.py
│ │ ├── core.py
│ │ ├── registry.py
│ │ └── tools/
│ │ ├── __init__.py
│ │ ├── material_master.py
│ │ ├── arena_generator.py
│ │ ├── spline_prop_placer.py
│ │ ├── bulk_operations.py
│ │ ├── verse_device_editor.py
│ │ ├── asset_importer.py # NEW: URL & Clipboard image importing
│ │ ├── verse_snippet_generator.py
│ │ ├── text_painter.py
│ │ ├── asset_renamer.py
│ │ ├── procedural_geometry.py # NEW: Wire & Volumetric generators
│ │ ├── text_voxelizer.py # NEW: 3D Text geometry generation
│ │ ├── smart_organizer.py # Proprietary Heuristics Engine
│ │ ├── system_perf.py # Background CPU Optimizer
│ │ ├── verse_schema.py # NEW: Verse Digest IQ (Phase 14)
│ │ ├── system_build.py # NEW: Automated Build Monitor (Phase 14)
│ │ ├── measurement_tools.py # NEW: Distance & Travel Time (Phase 15)
│ │ └── localization_tools.py # NEW: Text Export & Translation (Phase 15)
│ └── UEFN_Toolbelt/
│ ├── Blueprints/
│ │ └── WBP_ToolbeltDashboard ← optional EUW — create in UEFN
│ └── Materials/
│ └── M_ToolbeltBase ← required for Material Master
├── deploy.bat ← double-click to deploy to any UEFN project
└── README.md
Critical path: Files must live under
Content/Python/exactly. Any other location (e.g.Content/Scripts/) is not scanned by UEFN's Python interpreter.
Every tool self-registers with a one-line decorator. The registry is a singleton shared across the entire session.
from UEFN_Toolbelt.registry import register_tool
@register_tool(
name="my_tool",
category="Procedural",
description="Does something amazing",
tags=["procedural", "spawn"],
)
def run(**kwargs) -> dict:
...
return {"status": "ok", "count": placed}
Calling tb.run("my_tool") from anywhere — REPL, Blueprint node, another tool — routes
through the registry with full error containment. A crashing tool never kills your session.
Every tool returns a structured dict with at minimum a "status" key. This is the
MCP Return Contract: AI agents calling tools via the bridge read the return dict directly
from the JSON response. Zero log parsing required.
17 built-in presets stored as pure data dictionaries. All material work happens through
MaterialEditingLibrary — no Blueprint graph required.
tb.run("material_apply_preset", preset="chrome") # apply to selection
tb.run("material_gradient_painter", # world-space gradient
color_a="#0044FF", color_b="#FF2200", axis="X")
tb.run("material_team_color_split") # auto Red / Blue by X position
tb.run("material_save_preset", preset_name="MyLook") # save to JSON
Custom presets persist across sessions in Saved/UEFN_Toolbelt/custom_presets.json.
Instant symmetrical competitive arenas. What used to take 45 minutes of manual prop placement now runs in under 5 seconds.
tb.run("arena_generate", size="large", apply_team_colors=True)
Internally places floor tiles, perimeter walls, a center platform, and team spawn pads —
all in a single ScopedEditorTransaction. One Ctrl+Z removes the entire arena.
The biggest pain point in UEFN is syncing editor state with Verse code. The snippet generator reads your actual level selection and produces strongly-typed output:
# Select 6 devices in the viewport, then:
tb.run("verse_gen_device_declarations")
Output (written to Saved/UEFN_Toolbelt/snippets/ and copied to clipboard):
# Actor: 'TriggerDevice_01' @ (1200, 400, 0)
@editable triggerdevice_01 : trigger_device = trigger_device{}
# Actor: 'SpawnPad_Red_01' @ (3200, 0, 0)
@editable spawnpad_red_01 : player_spawner_device = player_spawner_device{}
Every destructive operation is wrapped in core.undo_transaction():
# From core.py — used by every tool:
with undo_transaction("Material Master: Apply chrome"):
for actor in actors:
_apply_preset_to_actor(actor, preset_data, "chrome")
If something goes wrong mid-operation the transaction closes cleanly. No corrupted undo stack, no phantom changes.
The first tool you run on any new UEFN project. Four opinionated templates — pick the one that matches your workflow:
# See what it would create before touching anything
tb.run("scaffold_preview", template="uefn_standard", project_name="MyIsland")
# One command builds 50+ folders in the right hierarchy
tb.run("scaffold_generate", template="uefn_standard", project_name="MyIsland")
Templates are stored as plain JSON in Saved/UEFN_Toolbelt/scaffold_templates.json
— email or Git the file to every teammate so everyone gets the same structure instantly.
Custom templates are one call:
tb.run("scaffold_save_template",
template_name="StudioDefault",
folders=["Maps/Main", "Materials/Master", "Materials/Instances",
"Meshes/Props", "Verse/Modules", "Audio/SFX"])
Drop a folder of FBXs and get back a fully organized Content Browser:
tb.run("import_fbx_folder",
folder_path="C:/MyAssets/Props/",
apply_material=True,
place_in_level=False)
Assets land in /Game/Imported/[date]/Meshes/ with auto-generated material instances.
An import log is appended to Saved/UEFN_Toolbelt/import_log.json after every run.
The Toolbelt now features a native "Off-Engine IQ" that understands your Verse code without needing a live actor in the level.
.digest.verse files to build a mapping of all Verse classes, properties, and events.core.safety_gate) that all "Write" operations must pass through. It prevents accidental modification of Epic/Fortnite core assets.category="System")Advanced project diagnostics and protection layers.
To prevent the editor from hanging during mass operations, Toolbelt uses
unreal.ScopedSlowTask — a native UE progress dialog with cancel support.
For an operation across $A$ actors with $M$ material slots each:
$$\text{Complexity} = O(A + (A \times M))$$
# From core.py — wrap any iterable:
with with_progress(actors, "Applying materials") as bar_iter:
for actor in bar_iter:
_apply_preset_to_actor(actor, preset, "Chrome")
# ScopedSlowTask advances one step per actor
# User can cancel mid-way — no partial corrupt state
The progress bar displays a cancel button. Cancellation is handled gracefully; already- processed actors retain their changes (inside the transaction, so all-or-nothing undo still works at the outer level).
362 tools · 55 categories — all return
{"status": "ok"/"error", ...}structured dicts. Run any tool withtb.run("tool_name", param=value). AI agents: usetb.run("plugin_export_manifest")to get the full machine-readable manifest.
Quick navigation: Actor Organization · Alignment · API Explorer · Asset Management · Asset Tagger · Assets · Audio · Bulk Ops · Entities · Environmental · Generative · Level Snapshot · Lighting · Localization · Materials · MCP Bridge · Measurement · Optimization · Pipeline · Post-Process · Procedural · Project · Project Admin · Prop Patterns · Proximity Tools · Reference Auditor · Screenshot · Selection · Sequencer · Simulation · Stamps · System · Tests · Text & Signs · Utilities · Verse Helpers · Zone Tools
All tags use the TB: namespace prefix to avoid collisions.
tb.run("snapshot_save", name="before_scatter")
# ... make changes ...
tb.run("snapshot_compare_live", name="before_scatter")
tb.run("snapshot_restore", name="before_scatter")
17 built-in presets: chrome · gold · neon · hologram · lava · ice · concrete · wood_oak · metal_rust · glass · team_red · team_blue · team_green · team_yellow · glow_pulse · scanlines · iridescent
Start the listener in UEFN, then an authenticated same-user MCP client can run
the registered catalogue by name and operate the editor through queued
main-thread dispatch. Listener start/stop/restart remain local-only controls.
Arbitrary remote Python is unavailable and cannot be enabled with the former
UEFN_TOOLBELT_MCP_ALLOW_EXECUTE_PYTHON variable. Deliberate scripting remains
available through the local UEFN Python console.
tb.run("mcp_start")
# Output Log: [MCP] ✓ Listener running on http://127.0.0.1:8765
Built-in templates: uefn_standard · competitive_map · solo_dev · verse_heavy
All pattern tools take asset_path + layout params and spawn at camera position.
Always dry_run=True before any destructive operation.
Output: Saved/UEFN_Toolbelt/screenshots/{name}_{YYYYMMDD_HHMMSS}_{W}x{H}.png
Save a group of placed actors as a reusable named stamp and re-place it anywhere. Not the same as prefab_migrate_open — stamps are for level layout reuse, not asset migration.
tb.run("stamp_save", name="guard_post")
tb.run("stamp_place", name="guard_post", yaw_offset=90.0)
# Instant symmetric layout — 4 compass points
for angle, x, y in [(0,5000,0),(90,0,5000),(180,-5000,0),(287,0,-5000)]:
tb.run("stamp_place", name="guard_post", location=[x,y,0], yaw_offset=angle)
Publish blocker: these six spawning tools create
TextRenderActor, which UEFN 42.00 rejects during remote validation:text_place,text_label_selection,text_paint_grid,text_color_cycle,sign_spawn_bulk, andlabel_attach. They are editor-visualization helpers. Before Launch Session or publishing, runtb.run("sign_clear", all_text_actors=True, dry_run=False)and confirmtb.run("publish_audit")reports zerotext_render_actors.
Zone actors can be any box-shaped actor. Convention: select the zone actor first, then other actors.
tb.run("zone_spawn", width=4000, depth=4000, height=800, label="ArenaCenter")
tb.run("zone_resize_to_selection", padding=200)
tb.run("zone_select_contents")
tb.run("zone_move_contents", offset_x=5000)
tb.run("zone_fill_scatter", asset_path="/Engine/BasicShapes/Cube", count=50, min_spacing=300)
# Run all 6 layers: Python env → UEFN API → Toolbelt core → MCP → Dashboard → Verse Book
tb.run("toolbelt_smoke_test")
# Results saved to Saved/UEFN_Toolbelt/smoke_test_results.txt
Tested on UEFN 42.00 (UE 6.0), Windows 11, Python 3.11.8 — August 2026.
Open your UEFN project. Go to Edit → Project Settings, search python, and tick:
Note: UEFN only shows one Python checkbox — unlike full Unreal Engine which shows three. That's normal. Once you see "Enter a Python statement" appear in the Output Log, Python is active.
Restart UEFN when prompted.
Open a regular Windows terminal — not inside UEFN — and run:
"C:\Program Files\Epic Games\Fortnite\Engine\Binaries\ThirdParty\Python3\Win64\python.exe" -m pip install PySide6
Why outside UEFN? UEFN's embedded Python can't run pip itself. You must use the same
python.exethat UEFN uses, just run it directly from a terminal.
If the path above doesn't exist, find it at:
C:\Program Files\Epic Games\Fortnite\Engine\Binaries\ThirdParty\Python3\Win64\python.exe
You only need to do this once. PySide6 stays installed across projects.
First time — run the installer:
python install.py
It will find your Fortnite Projects folder automatically, let you pick a project, copy the Toolbelt in, and handle init_unreal.py safely — whether you already have one or not.
Or point it directly at a project:
python install.py --project "C:\Users\YOURNAME\Documents\Fortnite Projects\YOURPROJECT"
Updating after a
git pull: Re-runpython install.py— it overwrites only the Toolbelt package, never your project's own files.
If you're actively developing the Toolbelt itself — use deploy.bat instead:
deploy.bat is the dev workflow tool. Double-click it or run it from a terminal. In addition to copying files it will:
verse-book/ reference without its Python lexer helpersdeploy.bat
Before Launch Session, Push Changes, or publishing: UEFN 42.00 rejects every
.pyunder the project for the standardVKCreateUGCrole..urcignoredoes not affect this upload check. Runprepare_launch.bat, wait for the upload to finish, then runrestore_after_launch.bat. The prepare helper stashes every project.pyoutside the project and verifies zero remain; restore refuses to overwrite any file created while the stash was active.
Hot-reload after any code change (no UEFN restart needed):
import sys; [sys.modules.pop(k) for k in list(sys.modules) if "UEFN_Toolbelt" in k]; import UEFN_Toolbelt as tb; tb.register_all_tools(); tb.launch_qt()
Manual install (if neither script works):
Your UEFN project lives at C:\Users\YOURNAME\Documents\Fortnite Projects\YOURPROJECT\.
xcopy /E /I /Y "PATH_TO_REPO\Content\Python\UEFN_Toolbelt" "C:\Users\YOURNAME\Documents\Fortnite Projects\YOURPROJECT\Content\Python\UEFN_Toolbelt"
Then copy init_unreal.py into Content\Python\ — or if you already have one, paste only the package-discovery for loop from it into your existing file (under # ── 2. Discover and load all packages). It won't conflict with anything already there.
Close and reopen your project. Watch the Output Log. You should see:
[TOOLBELT] ✓ All tools registered.
[TOOLBELT] Menu entries submitted, but MainFrame.MainTabMenu is not registered on this build
- UEFN sandboxes ToolMenus for third-party Python (40.20 onward, still true on
42.00), so no Toolbelt menu will appear in the top bar. Use the dashboard instead:
tb.launch_qt()
On UEFN 42.00 no Toolbelt menu appears in the top bar. menu.py registers its entries
and every call succeeds, but Epic sandboxes ToolMenus for third-party Python so nothing
renders. Toolbelt checks is_menu_registered and says which happened instead of claiming
success. Open the dashboard with tb.launch_qt().
In the Output Log, switch the input dropdown from Cmd to Python and run:
import UEFN_Toolbelt as tb; tb.run("toolbelt_smoke_test")
UEFN Python console tip: The console only accepts one line at a time — no multi-line pastes. Chain multiple statements on the same line using semicolons (
;). A space before and after the semicolon works fine:import UEFN_Toolbelt as tb; tb.run("toolbelt_smoke_test")
Expected output in the log:
✓ All systems healthy — Toolbelt is ready.
If you haven't installed PySide6 or cloned the verse-book yet, you may see a few non-critical failures. Complete Steps 2 and 7 in the Getting Started guide above to resolve them.
After completing Step 2 (PySide6 installed), run:
import UEFN_Toolbelt as tb; tb.launch_qt()
A dark-themed floating window opens with a left sidebar nav and 362 tools across 55 categories (including an About page).

Two search modes:
If the dashboard doesn't open after installing PySide6: The module may be cached from before PySide6 was installed. Paste this single line to clear and reload:
import sys; [sys.modules.pop(k) for k in list(sys.modules) if "UEFN_Toolbelt" in k]; import UEFN_Toolbelt as tb; tb.launch_qt()
In your repo folder, run:
git clone https://github.com/verselang/book.git verse-book
This gives Claude access to the full live Verse language spec for spec-accurate code generation. After cloning, the smoke test reports 89/89 with PySide6 installed.
This lets Claude Code directly control UEFN — spawn actors, run any tool, generate Verse code — without you typing anything in the console.
1. Install the MCP Python package (regular terminal, not UEFN):
pip install mcp
2. Create your own .mcp.json: a fresh clone has none. The file is
gitignored, so your local paths and configuration are never committed.
copy .mcp.json.template .mcp.json
Open .mcp.json and set the absolute path to mcp_server.py in your clone:
{
"mcpServers": {
"uefn-toolbelt": {
"command": "python",
"args": ["C:/Users/YOURNAME/Projects/UEFN-TOOLBELT/mcp_server.py"]
}
}
}
mcp_server.py takes the listener's port from the session handoff, so the
template sets no port. Add UEFN_MCP_PORT to an env block only to override
that, and only with the port the listener actually bound: the session secret is
sent to whatever is listening on the port you name.
3. Restart Claude Code so it picks up the new server config.
4. Start the listener inside UEFN — paste this in the Python console:
import UEFN_Toolbelt as tb; tb.run("mcp_start")
You should see in the Output Log:
[MCP] ✓ Listener running on http://127.0.0.1:8765
5. Try it from Claude Code:
run the toolbelt smoke test
If the client connects, it calls run_toolbelt_tool("toolbelt_smoke_test") through the bridge.
Untested path: No accepted record has run
mcp_server.pythrough any MCP host, stdio, or FastMCP since the WO-001 authentication and WO-004 transport changes.client.pydirect calls are the path with recorded live evidence, on one UEFN 42.20 boot. See the evidence gaps.
Note: The listener must be started in UEFN each session. You can also click Dashboard → MCP → Start Listener instead of pasting the command.
What Claude can do once connected:
The Verse tab in the dashboard has a built-in Snippet Library browser. Every time you generate a Verse snippet, it's saved to:
Saved/UEFN_Toolbelt/snippets/
├── game_systems/ ← game manager, elimination handler, scoring tracker
├── device_wiring/ ← @editable declarations, prop spawner
├── spline_tools/ ← patrol AI, zone boundary, vector3 arrays
└── custom/ ← your custom / Claude-generated snippets
In the dashboard:
.verse file in UEFNSnippets also auto-copy to the Windows clipboard when generated, so you can paste immediately without even opening the library.
If you have modified the Toolbelt source code, run this in the UEFN console to refresh everything without a restart:
import sys; [sys.modules.pop(k) for k in list(sys.modules) if "UEFN_Toolbelt" in k]; import UEFN_Toolbelt as tb; tb.register_all_tools(); tb.launch_qt()
[!IMPORTANT] Always include
tb.register_all_tools()after a pop, otherwise the tool registry will be empty!
UEFN console tip: Chain multiple statements on one line with semicolons (
;). The console does not accept multi-line pastes, but a single line can contain as many;-separated statements as you need.
Dashboard & Health Check:
import UEFN_Toolbelt as tb; tb.launch_qt()
import UEFN_Toolbelt as tb; tb.run("toolbelt_smoke_test")
Force reload (after git pull or update):
import sys; [sys.modules.pop(k) for k in list(sys.modules) if "UEFN_Toolbelt" in k]; import UEFN_Toolbelt as tb; tb.launch_qt()
Materials & Bulk Ops:
import UEFN_Toolbelt as tb; tb.run("material_apply_preset", preset="gold")
import UEFN_Toolbelt as tb; tb.run("bulk_align", axis="Z")
import UEFN_Toolbelt as tb; tb.run("arena_generate", size="large", apply_team_colors=True)
Plugin Management:
import UEFN_Toolbelt as tb; tb.run("plugin_validate_all")
import UEFN_Toolbelt as tb; tb.run("plugin_list_custom")
API Explorer & Capability Crawling:
import UEFN_Toolbelt as tb; tb.run("api_crawl_level_classes")
import UEFN_Toolbelt as tb; tb.run("api_crawl_selection")
import UEFN_Toolbelt as tb; tb.run("api_export_full")
Search & Discovery:
import UEFN_Toolbelt as tb; tb.registry.search("material")
import UEFN_Toolbelt as tb; print(len(tb.registry.list_tools()))
Handy Combos:
import UEFN_Toolbelt as tb; tb.run("toolbelt_smoke_test"); tb.run("plugin_validate_all")
import UEFN_Toolbelt as tb; tb.run("snapshot_save", name="before"); tb.run("bulk_randomize", rot_range=360)
Create Content/UEFN_Toolbelt/Materials/M_ToolbeltBase in the material editor with
these five exposed parameters:
Everything else works out of the box.
3 steps. No boilerplate. No registration config.
Step 1 — Create Content/Python/UEFN_Toolbelt/tools/my_tool.py:
"""UEFN TOOLBELT — My Tool"""
import unreal
from ..core import undo_transaction, require_selection, log_info
from ..registry import register_tool
@register_tool(
name="my_tool",
category="Utilities",
description="Does something amazing",
tags=["utility", "amazing"],
)
def run(**kwargs) -> dict:
actors = require_selection()
if actors is None:
return {"status": "error", "count": 0}
with undo_transaction("My Tool"):
for actor in actors:
log_info(f"Processing {actor.get_actor_label()}")
# your logic here
return {"status": "ok", "count": len(actors)}
Return contract: Every tool must return a
dictwith a"status"key. This is what makes tools readable by AI agents via the MCP bridge — they readresult["status"]and domain keys like"count"or"path"directly from the JSON response. Never returnNone.
Step 2 — Add one line to tools/__init__.py:
from . import my_tool
Step 3 — Add a menu entry in init_unreal.py's _build_toolbelt_menu() (optional):
_add_entry(tb_sub, "Utilities", "MyTool",
"My Tool", "Does something amazing",
"import UEFN_Toolbelt as tb; tb.run('my_tool')")
Your tool is now registered, searchable, undo-safe, and reachable from the dashboard
and tb.run("my_tool").
UEFN Toolbelt ships a live Plugin Hub tab in the dashboard. Click Refresh Hub to pull the latest community registry directly from GitHub — no restart required.
The registry is hosted at:
https://raw.githubusercontent.com/undergroundrap/UEFN-TOOLBELT/main/registry.json
Add an entry to registry.json at the repo root and open a PR:
{
"id": "my_cool_tool",
"name": "My Cool Tool",
"version": "1.0.0",
"author": "Your Name",
"author_url": "https://github.com/yourhandle",
"type": "community",
"description": "One sentence on what it does.",
"category": "Gameplay",
"tags": ["verse", "gameplay"],
"url": "https://github.com/yourhandle/yourrepo/blob/main/my_cool_tool.py",
"download_url": "https://raw.githubusercontent.com/yourhandle/yourrepo/main/my_cool_tool.py",
"min_toolbelt_version": "1.5.3",
"size_kb": 10
}
download_urlmust be a raw GitHub URL. The dashboard downloads it directly intoSaved/UEFN_Toolbelt/Custom_Plugins/— no zip, no installer, single.pyfile.
UEFN Toolbelt is a security-first extensible platform. Third-party developers can create custom tools that automatically load into the Dashboard and AI bridge — but the Toolbelt enforces strict sandboxing to protect your editor and project files.
Drop a .py file into [Your Project]/Saved/UEFN_Toolbelt/Custom_Plugins/. The Toolbelt will:
# Example: one-file custom plugin
from UEFN_Toolbelt.registry import register_tool
from UEFN_Toolbelt import core
@register_tool(name="my_tool", category="Community", description="Does something cool")
def run(**kwargs) -> dict:
core.log_info("My custom tool ran!")
return {"status": "ok"} # always return a dict
Every plugin passes through four security gates before it can execute inside your editor:
Every time the Toolbelt boots, it writes a tamper-evident audit trail to:
Saved/UEFN_Toolbelt/plugin_audit.json
Each entry records the plugin name, its SHA-256 hash, file size, load status, and timestamp. If a plugin file changes between sessions, the hash changes — making unauthorized modifications instantly detectable.
Read the full developer guide here: docs/plugin_dev_guide.md
UEFN Toolbelt: 362 Python automation tools across 55 categories, with a PySide6 dashboard and an experimental, authenticated same-user loopback bridge for local AI control. Complements Epic's official
Resumen general
UEFN Toolbelt: 362 Python automation tools across 55 categories, with a PySide6 dashboard and an experimental, authenticated same-user loopback bridge for local AI control. Complements Epic's official UEFN MCP; Toolbelt is not exposed through Epic's MCP server.
Herramientas
Aún no hay lista de herramientas. Los servidores remotos la reciben tras la primera comprobación de estado.
Preguntas frecuentes
Copia en esta página la configuración stdio para Cursor, Claude Desktop, Claude Code o VS Code. Usa la instalación del publicador, no un proxy de PlugMCP.
Este registro no indica ninguna variable de entorno obligatoria.
UEFN TOOLBELT se ejecuta localmente por stdio.
Última comprobación: 2026-10-28. UEFN Toolbelt: 362 Python automation tools across 55 categories, with a PySide6 dashboard and an experimental, authenticated same-user loopback bridge for local AI control. Complements Epic's official UEFN MCP; Toolbelt is not exposed through Epic's MCP server.