Skip to content
Back to search

VibeUE

Unreal Engine Vibe Coding tool

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/kevinpbuckley/VibeUE with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/kevinpbuckley/VibeUE'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/kevinpbuckley--vibeue/badge.svg)](/listings/kevinpbuckley--vibeue)

HTML

<a href="/listings/kevinpbuckley--vibeue"><img src="/api/listings/kevinpbuckley--vibeue/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

**Requirements:** Unreal Engine **5.8+** · Git

Step 1 — Set up Unreal's native MCP (do this FIRST)

VibeUE is an **expansion** of Unreal's built-in MCP support, so enable that first. Full details in Epic's guide: **[Unreal MCP in the Unreal Editor](https://dev.epicgames.com/documentation/unreal-engine/unreal-mcp-in-unreal-editor)**.

1. **Edit → Plugins** → enable **Unreal MCP** (this auto-enables **Toolset Registry**) and **Editor Tools** (the engine's own AI toolsets, so agents get both). These are Experimental. Restart when prompted. 2. **Edit → Editor Preferences → General → Model Context Protocol** → enable **Auto Start Server** (or run the console command `ModelContextProtocol.StartServer`). Default endpoint `http://127.0.0.1:8000/mcp` (port/path configurable). Enabling **Tool Search** keeps an agent's context small — it sees `list_toolsets` / `describe_toolset` / `call_tool` and loads tools on demand.

Step 2 — Install VibeUE

cd /path/to/YourProject/Plugins
git clone https://github.com/kevinpbuckley/VibeUE.git

Build with the project script:

Plugins/VibeUE/BuildAndLaunchGame.ps1                  # builds + launches the editor
Plugins/VibeUE/BuildAndLaunchGame.ps1 -StrictRebuild   # full recompile (warnings-as-errors)
Plugins/VibeUE/BuildAndLaunchGame.ps1 -Map /Game/Maps/MyMap   # open a specific map (issue #554)

On Linux or macOS, use the platform-detecting shell script:

Plugins/VibeUE/BuildAndLaunchGame.sh --engine /path/to/UE5
Plugins/VibeUE/BuildAndLaunchGame.sh --engine /path/to/UE5 --strict-rebuild
Plugins/VibeUE/BuildAndLaunchGame.sh --engine /path/to/UE5 --map /Game/Maps/MyMap

Then **Edit → Plugins** → enable **VibeUE** and restart. Its services, tools, and skills now register onto the same endpoint, alongside the engine's own.

Step 3 — Connect your agent

Two console commands from the editor (open the console with `` ` ``):

**1. Write the MCP server config** (`.mcp.json` at the project root):

ModelContextProtocol.GenerateClientConfig ClaudeCode

(supports `ClaudeCode`, `Cursor`, `VSCode`, `Gemini`, `Codex`, or `All`.)

**2. Write VibeUE's agent guide** so the assistant uses the efficient patterns:

VibeUE.GenerateAgentConfig ClaudeCode

This writes the guide to the correct file for your agent — `CLAUDE.md` (Claude Code), `GEMINI.md` (Gemini), `AGENTS.md` (Codex / Hermes / Cursor), or `.github/copilot-instructions.md` (Copilot) — or pass `All` to write CLAUDE.md + GEMINI.md + AGENTS.md at once. It resolves the plugin location automatically, so it works whether VibeUE was installed from **FAB** or **Git**. The guide goes in a managed block, so re-run any time to refresh without disturbing your own notes. Pass `import` to link the guide with a one-line `@import` instead of copying it (Claude Code / Gemini only — other agents don't resolve imports, so they always get a copy).

> The MCP server is loopback-only with no authentication — same-machine use only (per Epic's docs).

The guide teaches: discover before you call (`discover_python_class`), batch with `execute_python_code`, load skills via `ListSkills`/`GetSkills`, and when to reach for `deep_research` / `terrain_data`.

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 241 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <div align="center">
  2. # VibeUE — AI-Powered Unreal Engine Development
  3. ### 🧩 MCP Expansion + AI Editor Toolset for Unreal Engine 5.8+
  4. https://www.vibeue.com/
  5. [![Unreal Engine](https://img.shields.io/badge/Unreal%20Engine-5.8%2B-orange)](https://www.unrealengine.com)
  6. [![MCP](https://img.shields.io/badge/MCP-Model%20Context%20Protocol-blue)](https://modelcontextprotocol.io)
  7. [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
  8. [![Discord](https://img.shields.io/badge/Discord-Join-5865F2?logo=discord&logoColor=white)](https://discord.gg/hZs73ST59a)
  9. [![Donate](https://img.shields.io/badge/Donate-vibeue.com-ff5e5b?logo=githubsponsors&logoColor=white)](https://www.vibeue.com/donate)
  10. </div>
  11. **VibeUE is the MCP Expansion + AI Editor Toolset for Unreal Engine 5.8+.** Unreal 5.8 added a
  12. built-in MCP server and AI toolsets; VibeUE is an **MCP Expansion** that plugs straight into them and
  13. adds a deep **AI Editor Toolset** — a library of editor capabilities — Blueprints, materials, landscape, foliage, animation, Niagara, UMG, audio, StateTree,
  14. Behavior Trees & Blackboards, gameplay tags, input, UVs, **performance/profiling**, and more — registered into the engine's own
  15. `ToolsetRegistry` and `ModelContextProtocol` server, plus rich domain **skills** served through
  16. Unreal's native `AgentSkill` system. Any MCP-capable agent (Claude Code, Cursor, Copilot, …) drives
  17. your editor through Unreal's standard MCP endpoint.
  18. > ⚠️ **VibeUE requires Unreal's native MCP to be set up first** — enable the **Unreal MCP** plugin
  19. > (which auto-enables **Toolset Registry**) and the **Editor Tools** plugin, then start the MCP server.
  20. > Follow Epic's guide: **[Unreal MCP in the Unreal Editor](https://dev.epicgames.com/documentation/unreal-engine/unreal-mcp-in-unreal-editor)**.
  21. > VibeUE then expands that endpoint — **no separate server and no in-editor chat.** A free API key
  22. > (set in **Editor Preferences → Plugins → VibeUE**) unlocks the real-world **terrain** tools; everything
  23. > else works without one.
  24. ---
  25. ## ✨ What VibeUE adds
  26. Unreal 5.8 ships its own AI toolsets (Blueprints, materials, actors, assets, meshes, data tables, …).
  27. VibeUE **complements** them — it focuses on the domains and depth the engine doesn't cover:
  28. - **Terrain & world** — Landscape sculpting/heightmaps/splines, landscape auto-materials + RVT,
  29. Foliage, procedural FPS **Map Blockout**, and **real-world terrain** (heightmaps + water from GPS).
  30. - **Audio** — MetaSound and SoundCue graph authoring.
  31. - **Animation assets** — AnimSequence keyframe editing, AnimMontage authoring, AnimBP state machines,
  32. Skeleton bone/socket/retarget/blend-profile editing.
  33. - **FX depth** — Niagara emitter color/curve authoring and **Custom-HLSL scratch-pad** modules.
  34. - **UI** — UMG widgets with MVVM bindings, animation authoring, and preview/PIE validation.
  35. - **Higher-order Blueprint authoring** — timelines, event dispatchers, delegates, custom-event pins,
  36. comment boxes, and a batch `build_graph` builder.
  37. - **AI behavior authoring** — Behavior Tree node/decorator/service editing by structural path with
  38. blackboard key binding, JSON tree round-trips, and validate/repair; full Blackboard asset + key
  39. CRUD. Writes go through the editor EdGraph with PIE- and open-editor-aware refusal guards.
  40. - **Editor safety** — `TransactionService` wraps the editor's transaction buffer (undo / redo /
  41. checkpoints) so an agent can group and roll back its own edits — the engine's toolsets expose none.
  42. - **Verified workflows** — `WorkflowService` adds an authoritative engine/build manifest, durable
  43. task journals with affected-asset provenance, asynchronous PIE scenarios (compile → input →
  44. assertion → capture → guaranteed teardown), and dry-run-first resumable bulk maintenance.
  45. - **⚡ Performance & profiling** — VibeUE's standout: see the dedicated section below.
  46. - **Python-first access** — run any `unreal.*` Python in the editor and introspect the whole API.
  47. - **Web research** — search / fetch / geocode for in-context research and terrain workflows.
  48. It deliberately **does not duplicate** the engine's general tools (basic asset/actor/blueprint/material
  49. CRUD, screenshots, logs, PIE) — agents use Unreal's native toolsets for those.
  50. ---
  51. ## ⚡ Performance & Profiling (flagship)
  52. **Unreal's native AI toolsets have *zero* performance tooling** — they can start PIE/Simulate but can't
  53. measure anything. VibeUE's `PerformanceService` fills that gap so an agent can actually *diagnose and
  54. fix* frame rate:
  55. - **`frame_timing()`** — Game/Render/GPU/RHI thread split + a **CPU-vs-GPU-bound verdict** and a
  56. concrete next-step hint. *Run this first* — optimising the GPU does nothing on a CPU-bound frame.
  57. - **Unreal Insights capture** — `start_trace` / `stop_trace` / `get_trace_status`, with `bookmark`
  58. and `region_start` / `region_end` markers.
  59. - **`analyse()`** — reads the trace **and** log back and returns a perf summary (frame stats, worst
  60. frames, hitches, notable log lines).
  61. - **Trace-attached `start_standalone`** — profile a representative standalone build, not just the
  62. editor viewport.
  63. ```python
  64. import unreal
  65. print(unreal.PerformanceService.frame_timing()) # CPU vs GPU bound — diagnose FIRST
  66. unreal.PerformanceService.start_trace("cap", "") # Insights trace
  67. # … reproduce the workload (ideally under PIE / standalone) …
  68. unreal.PerformanceService.stop_trace()
  69. print(unreal.PerformanceService.analyse("both", ""))
  70. ```
  71. Pair with the `profiling` and `frame-rate` skills for the full CPU/GPU drill-down.
  72. ---
  73. ## 🏗️ Architecture
  74. VibeUE plugs into three native UE 5.8+ systems:
  75. 1. **Toolsets** (`ToolsetRegistry`) — VibeUE's services register as `UToolsetDefinition`s, so their
  76. methods become AICallable tools on the MCP endpoint. They're also `BlueprintCallable`, so the same
  77. methods are callable from Python as `unreal.<Name>Service.<method>()`.
  78. 2. **MCP server** (`ModelContextProtocol`) — a small set of VibeUE utility tools are registered
  79. directly on the endpoint: `execute_python_code`, `discover_python_module`/`_class`/`_function`,
  80. `list_python_subsystems`, `deep_research`, `terrain_data`.
  81. 3. **Skills** (`AgentSkillToolset`) — ~36 markdown skill packs register as native `UAgentSkill`s,
  82. discoverable via `ListSkills` and loaded lazily via `GetSkills`, alongside the engine's own skills.
  83. **Efficient usage (for agents):** `execute_python_code` is the workhorse — it batches a whole
  84. multi-step task into one round-trip and reaches every VibeUE service plus the full `unreal.*` API. Use
  85. `call_tool` only for skills and the few engine toolsets with no Python path (screenshots, etc.). See
  86. [`Content/samples/AGENTS.md.sample`](Content/samples/AGENTS.md.sample) for the full agent guide.
  87. ---
  88. ## 🚀 Installation & setup
  89. **Requirements:** Unreal Engine **5.8+** · Git
  90. ### Step 1 — Set up Unreal's native MCP (do this FIRST)
  91. VibeUE is an **expansion** of Unreal's built-in MCP support, so enable that first. Full details in
  92. Epic's guide: **[Unreal MCP in the Unreal Editor](https://dev.epicgames.com/documentation/unreal-engine/unreal-mcp-in-unreal-editor)**.
  93. 1. **Edit → Plugins** → enable **Unreal MCP** (this auto-enables **Toolset Registry**) and **Editor
  94. Tools** (the engine's own AI toolsets, so agents get both). These are Experimental. Restart when prompted.
  95. 2. **Edit → Editor Preferences → General → Model Context Protocol** → enable **Auto Start Server**
  96. (or run the console command `ModelContextProtocol.StartServer`). Default endpoint
  97. `http://127.0.0.1:8000/mcp` (port/path configurable). Enabling **Tool Search** keeps an agent's
  98. context small — it sees `list_toolsets` / `describe_toolset` / `call_tool` and loads tools on demand.
  99. ### Step 2 — Install VibeUE
  100. ```bash
  101. cd /path/to/YourProject/Plugins
  102. git clone https://github.com/kevinpbuckley/VibeUE.git
  103. ```
  104. Build with the project script:
  105. ```
  106. Plugins/VibeUE/BuildAndLaunchGame.ps1 # builds + launches the editor
  107. Plugins/VibeUE/BuildAndLaunchGame.ps1 -StrictRebuild # full recompile (warnings-as-errors)
  108. Plugins/VibeUE/BuildAndLaunchGame.ps1 -Map /Game/Maps/MyMap # open a specific map (issue #554)
  109. ```
  110. On Linux or macOS, use the platform-detecting shell script:
  111. ```bash
  112. Plugins/VibeUE/BuildAndLaunchGame.sh --engine /path/to/UE5
  113. Plugins/VibeUE/BuildAndLaunchGame.sh --engine /path/to/UE5 --strict-rebuild
  114. Plugins/VibeUE/BuildAndLaunchGame.sh --engine /path/to/UE5 --map /Game/Maps/MyMap
  115. ```
  116. Then **Edit → Plugins** → enable **VibeUE** and restart. Its services, tools, and skills now register
  117. onto the same endpoint, alongside the engine's own.
  118. ### Step 3 — Connect your agent
  119. Two console commands from the editor (open the console with `` ` ``):
  120. **1. Write the MCP server config** (`.mcp.json` at the project root):
  121. ```
  122. ModelContextProtocol.GenerateClientConfig ClaudeCode
  123. ```
  124. (supports `ClaudeCode`, `Cursor`, `VSCode`, `Gemini`, `Codex`, or `All`.)
  125. **2. Write VibeUE's agent guide** so the assistant uses the efficient patterns:
  126. ```
  127. VibeUE.GenerateAgentConfig ClaudeCode
  128. ```
  129. This writes the guide to the correct file for your agent — `CLAUDE.md` (Claude Code), `GEMINI.md`
  130. (Gemini), `AGENTS.md` (Codex / Hermes / Cursor), or `.github/copilot-instructions.md` (Copilot) — or pass
  131. `All` to write CLAUDE.md + GEMINI.md + AGENTS.md at once. It resolves the plugin location
  132. automatically, so it works whether VibeUE was installed from **FAB** or **Git**. The guide goes in a
  133. managed block, so re-run any time to refresh without disturbing your own notes. Pass `import` to link
  134. the guide with a one-line `@import` instead of copying it (Claude Code / Gemini only — other agents
  135. don't resolve imports, so they always get a copy).
  136. > The MCP server is loopback-only with no authentication — same-machine use only (per Epic's docs).
  137. The guide teaches: discover before you call (`discover_python_class`), batch with `execute_python_code`,
  138. load skills via `ListSkills`/`GetSkills`, and when to reach for `deep_research` / `terrain_data`.
  139. ---
  140. ## 🎯 Skills
  141. Skills are lazy-loaded domain knowledge (workflows, gotchas, property formats) served by Unreal's
  142. native `AgentSkillToolset`:
  143. ```
  144. # discover (summaries only — cheap)
  145. call_tool(tool_name="ListSkills", toolset_name="ToolsetRegistry.AgentSkillToolset")
  146. # load the packs you need (full markdown, lazy)
  147. call_tool(tool_name="GetSkills", toolset_name="ToolsetRegistry.AgentSkillToolset",
  148. arguments={"skillPaths": ["/VibeUE/Python/init_unreal_PY.VibeUE_blueprints"]})
  149. ```
  150. `ListSkills` is the **live source of truth** for what's available (it reads each pack's `SKILL.md`).
  151. Skills tell you *what* to do and *why*; use `discover_python_class('unreal.<Name>Service', method_filter='…')`
  152. for exact signatures before writing code.
  153. ---
  154. ## 🔧 Plugin dependencies
  155. **Native engine prerequisites (enable in Step 1 — Epic's MCP stack):**
  156. | Plugin | Purpose |
  157. |--------|---------|
  158. | **Unreal MCP** (`ModelContextProtocol`) | The native MCP server endpoint |
  159. | **Toolset Registry** (`ToolsetRegistry`) | Native AI toolset + `AgentSkill` registration (auto-enabled by Unreal MCP) |
  160. | **Editor Tools** (`EditorToolset`) | The engine's own AI toolsets — VibeUE complements these |
  161. **Enabled automatically by VibeUE:** `PythonScriptPlugin` (the `unreal.*` API),
  162. `EditorScriptingUtilities`, and the domain plugins its services need — `Niagara`, `MetaSound`,
  163. `EnhancedInput`, `ModelViewViewModel`, `StateTree`, `MeshModelingToolset`,
  164. `GameplayTagsEditor`. (VibeUE also depends on
  165. `ToolsetRegistry` + `ModelContextProtocol`, so enabling VibeUE pulls them in — but you still enable
  166. **Editor Tools** and start the server per Step 1.)
  167. ---
  168. ## 🛠️ Build & launch script
  169. `BuildAndLaunchGame.ps1` (project root or `Plugins/VibeUE/`) stops the running editor, builds, and
  170. relaunches:
  171. - `-StrictRebuild` — full plugin recompile under warnings-as-errors
  172. - `-Clean` — wipe intermediate/binaries first
  173. - `-SkipBuild` — relaunch only
  174. ---
  175. ## 📚 The live API
  176. VibeUE intentionally keeps **no static method catalog** in this README — the surface evolves with the
  177. engine. The authoritative, always-current references are:
  178. - **`ListSkills`** → which domains exist and when to use them.
  179. - **`discover_python_class('unreal.<Name>Service')`** → exact method signatures.
  180. - **`describe_toolset('VibeUE.<Name>Service')`** → the toolset's tools + JSON schemas (token-heavy;
  181. prefer skills + discovery).
  182. ---
  183. ## License
  184. MIT — see [LICENSE](LICENSE). Project home: https://www.vibeue.com/

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.