Content
# Claude UE Plugin — Claude Code Plugin for Unreal Engine
AI-powered Unreal Engine development from inside Claude Code. 217 MCP tools, 14 live resources, 12 guided prompts, a computer-use skill, and an optional native C++ editor plugin for Blueprint graph intelligence.
---
## Quick Install (Claude Code Plugin)
In Claude Code, run these two commands:
```
/plugin marketplace add cwilcox0916/claude-ue-plugin
/plugin install ue-mcp@claude-ue-tools
```
Done. The plugin auto-builds and persists across sessions. Now follow the Unreal Engine setup below.
---
## Unreal Engine Setup (Step by Step)
### Prerequisites
You need these installed before starting:
- **Unreal Engine 5.4 - 5.7** (from the Epic Games Launcher)
- **Visual Studio 2022** with the **"Game development with C++"** workload (required even for Blueprint projects if you want the native plugin)
- **Node.js 18+** (the MCP server runs on Node)
> **Important about Visual Studio:** When installing VS 2022 (or modifying an existing install), open the Visual Studio Installer, click Modify, and check the **"Game development with C++"** workload. This installs the C++ compiler and Windows SDK that Unreal needs.
### Step 1: Create or Open Your UE Project
**If creating a new project:**
1. Open the Epic Games Launcher
2. Click **Launch** next to UE 5.7 (or your version)
3. In the Project Browser, pick a template (Third Person, First Person, etc.)
4. **IMPORTANT: Choose "C++" instead of "Blueprint"** in the project settings at the bottom
- This creates a `Source/` folder in your project, which is required for the native plugin to compile
- If you choose Blueprint-only, the native C++ plugin cannot compile (you'll still get the 217 MCP tools, just not the graph-level features)
5. Name your project, pick a location, click **Create**
**If you already have a Blueprint-only project and want the native plugin:**
You need to convert it to a C++ project. The easiest way:
1. In the UE Editor, go to **Tools > New C++ Class**
2. Pick **None** (empty class) or **Actor**
3. Name it anything (e.g., `MyGameModule`)
4. Click **Create Class**
5. UE will create a `Source/` folder, generate VS project files, and may open Visual Studio
6. Close and reopen the project — it's now a C++ project
### Step 2: Enable the Remote Control API Plugin
This built-in UE plugin lets Claude Code read/write properties and call functions in the editor.
1. In the UE Editor, go to **Edit > Plugins**
2. In the search bar at the top, type **"Remote Control API"**
3. Find it in the list and **check the Enabled box**
4. UE will ask you to **restart the editor** — click **Restart Now**
### Step 3: Start the Python Executor
This is a lightweight Python server that runs inside UE and lets Claude Code execute Python scripts with full `unreal` module access.
**Option A: Run it manually (quickest to test)**
1. In the UE Editor, go to **Window > Output Log** to open the Output Log panel
2. At the very bottom of the Output Log, there's a text input bar
3. On the **left side** of that input bar, there's a **tiny dropdown** — click it and switch from **"Cmd"** to **"Python"**
4. Click in the text input field and paste this exact command:
```
exec(open(r"C:/path/to/claude-ue-plugin/python/ue_mcp_executor.py").read())
```
Replace `C:/path/to/claude-ue-plugin` with the actual path where the plugin repo is on your computer. Use **forward slashes** `/`, not backslashes.
5. Press **Enter**
6. You should see `[UE-MCP] Executor server started on 127.0.0.1:8765` in the Output Log
**Option B: Auto-start every time UE opens (recommended after testing)**
1. Copy `python/ue_mcp_executor.py` from this repo
2. Paste it into your UE project folder at: `<YourProject>/Content/Python/init_unreal.py`
- Create the `Content/Python/` folder if it doesn't exist
- The file must be named exactly `init_unreal.py`
3. Restart UE — the executor starts automatically on every project open
### Step 4: Install the Native C++ Plugin (Optional but Recommended)
This gives Claude structured access to Blueprint graphs (reading nodes/pins/connections, adding nodes, wiring pins) without needing screenshots. It also adds a status panel inside UE.
**Skip this step if** you chose "Blueprint" when creating your project and haven't converted to C++ yet.
1. Find the `unreal-plugin/ClaudeMCP/` folder in this repo
2. Copy the entire `ClaudeMCP` folder
3. Paste it into your UE project's `Plugins/` folder:
```
YourProject/
Plugins/
ClaudeMCP/ <-- paste here
ClaudeMCP.uplugin
Source/
Content/
```
Create the `Plugins/` folder if it doesn't exist.
> **Common mistake:** Don't put it at `Plugins/unreal-plugin/ClaudeMCP/`. It must be directly at `Plugins/ClaudeMCP/`.
4. **Close the UE Editor** if it's open
5. **Reopen your project** — UE will detect the new plugin and compile it
- If UE asks "Would you like to rebuild?" click **Yes**
- This may take 1-3 minutes the first time
- If it fails, see Troubleshooting below
6. Once the editor opens, verify the plugin loaded:
- Go to **Edit > Plugins**
- Search for **"Claude"**
- You should see **"Claude MCP Bridge"** enabled
- You can also open the status panel: **Window > Claude MCP**
### Step 5: Verify Everything Works
In Claude Code, type:
```
/ue:setup
```
Claude will check all three connections and tell you what's working:
- **Remote Control API** (port 30010) — reads/writes UE properties
- **Python Executor** (port 8765) — runs Python scripts inside UE
- **Native Plugin** (port 13090) — graph-level Blueprint access
If something isn't connected, `/ue:setup` will walk you through fixing it.
For a quick check anytime:
```
/ue:status
```
---
## Troubleshooting
### "Plugin ClaudeMCP failed to load" or "Could not be compiled"
**Cause:** Your project is Blueprint-only (no `Source/` folder), so UE can't compile C++ code.
**Fix:** Convert to a C++ project:
1. In UE: **Tools > New C++ Class > None > Create Class**
2. Close and reopen the project
3. UE will now compile the plugin
**Or:** If you don't want C++ at all, just delete the `Plugins/ClaudeMCP/` folder. You'll still get all 217 MCP tools — just not the graph-level features (Blueprint node wiring, structured graph export). Those will fall back to computer-use.
### Native plugin compiles but Blueprint graph tools don't work
**Check:** Run `/ue:status` in Claude Code. The native plugin line should say "Connected" on port 13090. If it says "Not connected":
1. Open **Window > Claude MCP** in UE to see the status panel
2. Check the Output Log for errors related to ClaudeMCP or port 13090
### Python executor won't start
**Check:** Make sure the Python Editor Script Plugin is enabled (it's on by default):
1. **Edit > Plugins** > search **"Python"**
2. **"Python Editor Script Plugin"** should be checked
**Check:** Make sure you switched the Output Log dropdown to **"Python"** (not "Cmd"):
- The dropdown is at the bottom-left of the Output Log panel — it's small and easy to miss
### Remote Control API not reachable
**Check:** The plugin must be enabled AND the editor must be restarted after enabling:
1. **Edit > Plugins** > search **"Remote Control"**
2. Both **"Remote Control API"** should be enabled
3. Restart the editor after enabling
### UE asks to rebuild every time I open the project
**Cause:** The build artifacts are stale or VS build tools aren't configured correctly.
**Fix:**
1. Delete `Binaries/` and `Intermediate/` folders from both the project root AND `Plugins/ClaudeMCP/`
2. Right-click the `.uproject` file > **"Generate Visual Studio project files"**
3. Open the `.sln` in Visual Studio 2022
4. Set configuration to **Development Editor | Win64** (dropdowns at the top)
5. Build with **Ctrl+Shift+B**
6. Once it succeeds, open the project in UE normally
---
## What the Plugin Can Do
### Slash Commands
| Command | What It Does |
|---------|-------------|
| `/ue:setup` | Guided first-time setup — checks connections, fixes what it can, tells you what's left |
| `/ue:doctor` | Diagnose and repair a broken connection |
| `/ue:status` | Quick connection check + project summary |
| `/ue:scan` | Full project inventory (assets, levels, settings, plugins) |
| `/ue:fab` | Browse your Fab library and suggest assets for the project |
### 217 Tools Across 35 Categories
**Core:** Actors (10), Assets (8), Selection (7), Levels (7), Viewport (5), PIE (4), Connection (6)
**Blueprints:** Blueprint structure (12), Graph intelligence (11), Native graph ops (6)
**Content:** Materials (8), Lighting (6), Audio (5), Niagara (5), Landscape (5), PCG (3), Splines (8), Widgets (5)
**Animation:** Sequences (8), Control Rig/IK (6), Movie Render Queue (5)
**AI & Gameplay:** AI authoring (8), GAS (4), Enhanced Input (4), Data Tables (8)
**Production:** Build (4), C++ Workflows (7), Mesh Editing (8), Source Control (6), Asset Manager (5)
**Quality:** Observability (10), Networking (3), Multiplayer (5), World Partition (6), Automation Testing (5)
### 14 Live Resources
Claude reads these automatically for editor context — no tool calls needed:
`unreal://connection/status` | `unreal://project/summary` | `unreal://editor/state` | `unreal://editor/selection` | `unreal://world/current` | `unreal://build/status` | `unreal://logs/recent` | `unreal://diagnostics/health` | `unreal://diagnostics/setup` | `unreal://assets/summary` | `unreal://project/plugins` | `unreal://project/settings` | `unreal://world/levels` | `unreal://blueprint/current`
---
## For Teams
Add this to your UE project's `.claude/settings.json` so teammates are automatically prompted to install:
```json
{
"extraKnownMarketplaces": {
"claude-ue-tools": {
"source": {
"source": "github",
"repo": "cwilcox0916/claude-ue-plugin"
}
}
},
"enabledPlugins": {
"ue-mcp@claude-ue-tools": true
}
}
```
---
## Alternative: Standalone MCP (No Plugin System)
If you don't want to use the Claude Code plugin system:
```json
// Add to ~/.claude/.mcp.json
{
"mcpServers": {
"unreal-engine": {
"command": "node",
"args": ["/path/to/claude-ue-plugin/dist/index.js"]
}
}
}
```
Then manually copy the skill:
```bash
xcopy /E /I skill "%USERPROFILE%\.claude\skills\unreal-engine-dev"
```
---
## Current Limitations (Honest)
| What | Status |
|------|--------|
| **Blueprint graph ops without native plugin** | Limited. Graph tools require the C++ plugin. Without it, they fall back to Python (structure only) or computer-use (visual). |
| **Dynamic capability refresh** | Not implemented. Tool/resource lists are static. |
| **MCP elicitation** | Not implemented. |
| **Push-based editor events** | Polling only (not push). |
| **StateTree authoring** | Not implemented. Only Behavior Trees. |
| **Gauntlet / Unreal Insights** | Not implemented. |
The native C++ plugin is written against documented UE 5.x APIs. First-time compilation may need minor adjustments for your specific engine version.
## Requirements
- **Node.js** 18+
- **Unreal Engine** 5.4 - 5.7
- **Visual Studio 2022** with "Game development with C++" workload (for native plugin)
- **UE Plugins:** Remote Control API (enable manually), Python Editor Script (on by default)
## License
MIT
