Local LLM + Unreal Engine 5.8 MCP: A Free AI Builds a Complete Game

Last time, Claude built a world inside Unreal Engine 5.8 through the new native MCP - and the top comment under that video was, by far: “Okay, but can you do this with a local, free, open-source AI?” Fair question. Claude is brilliant, right up until you look at the bill.

So this time: no cloud, no API key, no subscription. Qwen3.6-27B - 27 billion parameters, about seventeen gigabytes sitting on one consumer GPU - wired straight into the live Unreal Editor through the same native MCP. Seventeen prompts, and every single one is a fresh chat: the model remembers nothing between steps. Thinking mode is off. And every task in the Cline history ends with the same number in the corner: $0.00.

The real question was never “can it open the editor.” It was whether a local model can survive a real project: author the Blueprints, build a 28-widget HUD, wire an input system, and hunt down its own bug in the engine’s guts - or fall apart on the first tool call. As far as we can tell, nobody had published a successful local-LLM build through UE’s native MCP before this one; the only public attempt we found ended in failure on launch day. Here is the exact setup, what it built, and the honest verdict.

1. The model: Qwen3.6-27B, and the hardware it actually needs

The pick is Qwen3.6-27B - a dense open-weights model that currently sits near the top of the agentic-coding benchmarks among open models, with tool-calling improvements baked into this generation. The exact build used here is the unsloth GGUF repo with the UD-Q4_K_XL quant (UD = Unsloth Dynamic) - roughly 17 GB of weights.

2. Serve it locally with llama.cpp (the flags are the whole game)

Install llama.cpp with one command - on Windows that is winget install llama.cpp - and launch the server. The -hf flag pulls the exact quant straight from Hugging Face on first run, so there is no separate download step:

winget install llama.cpp   # macOS/Linux: curl -LsSf https://llama.app/install.sh | sh

llama serve -hf unsloth/Qwen3.6-27B-GGUF:UD-Q4_K_XL -a Qwen3.6-27B \
  --host 127.0.0.1 --port 1235 \
  -ngl 99 -fa on -c 40960 \
  --cache-type-k q8_0 --cache-type-v q8_0 \
  --jinja --reasoning off \
  --temp 0.7 --top-p 0.80 --top-k 20 --min-p 0.0 \
  --presence-penalty 1.5 --repeat-penalty 1.0

What each block is doing, because every one of them earned its place:

3. Point Cline at your own server

Cline is the agent harness - a free, open-source VS Code extension. llama-server exposes an OpenAI-compatible endpoint, so Cline talks to your GPU exactly as if it were a cloud API:

4. Bridge it into Unreal Engine 5.8

The Unreal side is the same native MCP server we covered in the previous chapter - enable the plugin, turn on Auto Start Server, and the editor listens on http://127.0.0.1:8000/mcp. (The MCP plugin is still marked Experimental, and it shows sometimes - more on that below.) The only new piece is telling Cline about it, in cline_mcp_settings.json:

{
  "mcpServers": {
    "unreal-mcp": {
      "type": "streamableHttp",
      "url": "http://127.0.0.1:8000/mcp"
    }
  }
}

First task, in a fresh chat: “check mcp connection to unreal engine.” The very first execute_python_code call failed with an AttributeError - a bad Python API call. And this was the first genuinely encouraging moment: the model read the traceback, concluded on its own that the connection was fine and only its code was wrong, and retried with corrected code. Eight milliseconds later: “MCP connection to Unreal Engine: SUCCESSFUL.”

5. The stress test: a complete game in 17 prompts

The project is BurgerTower - a one-button arcade stacker. A piece of food swings over a growing tower; tap to drop it. Clean landing scores a bonus and a splash of meat juice; a leaning tower topples and ends the run. Every floor climbs the camera higher - city, clouds, stratosphere, space. The project ships art only: eight food meshes, a panorama texture, an empty studio map. Every Blueprint, graph, widget, input asset, material, and effect is the model’s to author, live in the editor, through Python.

And one rule that makes this a real benchmark rather than a demo: every prompt is a brand-new Cline task with a clean context. The model remembers nothing between steps - the prompts themselves carry the continuity, like commissions handed to a contractor who wakes up with amnesia every morning. Seventeen commissions total.

Prompts 1-6: the whole skeleton, without pressing Play once

The first six prompts build every part separately and verify by compilation only: the falling-piece actor with its physics profile and mesh pool (the mesh must BE the root component - physics simulates the root, and a mesh hanging under an empty root tears off the moment physics wakes); its event graph, where a triple-filtered Hit event turns a physics touch into exactly one “I landed” signal; a Niagara burst duplicated from an engine template; the camera pawn with 19 state variables; and the HUD.

The HUD deserves its own sentence: 28 widgets - score card, a gold BEST pill, PERFECT!/COMBO callouts, an altitude gauge with CITY/CLOUDS/STRATOSPHERE/SPACE marks, and a full death screen with a RETRY button - laid out, anchored, colored, and styled entirely in code, in two tool calls, without a single click in the UMG designer. The second call was one continuous code block the local model streamed for about two and a half minutes. It compiled clean.

Prompts 7-13: wiring it together, first Play, first game over

Episode two connects the parts in dependency order: the landing receiver on the pawn first, then the Tick heartbeat (swing sine, smooth camera climb, per-frame HUD updates, a physics-driven fail check), Enhanced Input assets, the BeginPlay bootstrap, and the game mode - including the subtle trap that after setting the default pawn the game mode must be recompiled, or Play keeps spawning the engine’s stock pawn. The model recompiled and read the value back to verify. First Play of the entire series comes only after prompt 11: pawn spawns, HUD comes up at zero, a piece swings over the base bun.

Prompt 12 is the drop button - judge the perfect at the moment of the press, wake the piece’s physics, ratchet the camera, spawn the next piece - and the biggest code block of the series: about three minutes of streaming, then three and a half minutes of the engine compiling the graph. Mid-task, the MCP endpoint dropped the session; Cline resent the exact same call by itself and the build continued. Delivery failures like this happened three times across the project, and the agent self-healed every one on camera. Then: Play, first drop, a “PERFECT! x4” streak, a leaning tower, a topple at 5,316 meters, GAME OVER, RETRY - the entire game loop works. Prompt 13 is the classic feel pass: widen the swing, speed it up, open the FOV from 70 to 80.

Prompts 14-15: a shader built from a formula, then the release pass

Prompt 14 is the flex: build the backdrop material in code - about 18 material nodes via MaterialEditingLibrary - mapping a tall panorama texture in screen space, with the visible window sliding upward in sync with the camera climb. Pure shader math, dictated as a formula in the prompt, transcribed into node wiring by the model. This task also produced the only real snag of the series: a response was lost in transit, the retry collided with the asset the first call had already created, and Unreal threw overwrite dialogs. The model did not loop - it concluded the material existed and moved on to part two. Prompt 15 is the release pass: connect the one exec wire that had been deliberately left unwired since prompt 7 (the perfect-hit burst, parked behind its gate), recolor the effect meat-juice brown, and run a roll call - eight assets, all compiling clean.

Prompt 16: the real bug - and the moment that answers the title

After the release pass, the perfect splash still rendered white in game - even though the tool reports were green and the color values were verifiably in the asset. Prompt 16 hands the model the mystery: figure out why the color never reached the screen. The diagnosis it produced is the single smartest moment of the project: Niagara compiles systems in the background, and the game had been playing the old compiled copy of the effect all along. Its fix: re-set the color on all three emitters, save, and force a rebuild by opening the system in the editor. Next Play: two perfects, dark-brown splashes with sparks. That is not pattern-matching a tutorial - that is reasoning about the engine’s asset pipeline.

Prompt 17 is dessert: import a new panorama - a giant chomping head over a burger city - and repoint the material’s sampler at it. One import, one repoint; the pan math lives in scalar parameters that never touch the texture, so the backdrop swapped live in the viewport, mid-session.

6. The honest verdict

And yes, the numerology checks out: 17 prompts, a ~17 GB model, and a final tower 17.7 kilometers tall - past the edge of space, inside a giant’s open mouth, with a proper game over screen. Every step of it billed at $0.00.

What you actually get

That is the whole pipeline: one llama.cpp command, one Cline settings page, one MCP entry - and a local model driving the same editor the cloud agents drive. The generation tools that feed projects like this keep changing; when new ones land, they go straight into the Arena so you can compare them blind before committing. For the earlier chapters of this story, see Unreal Engine 5.8 Native MCP + Claude and Claude Code + Unreal Engine 5.

Watch the full build

The whole setup and all 17 prompts, start to finish, on YouTube.