Installation

Your First Tool

Once installed, open any Blueprint editor and look for the CodeScape chat panel docked on the right side. Type a natural language command:

CodeScape will analyze your request, select the appropriate tools (CreateBlueprint, AddVariable, CompileDSL), and generate a complete Blueprint with variables, functions, and event dispatchers, all with proper node layout.

Session Modes

• Floating panel: Access from the CodeScape toolbar button in any editor window
• Docked panel: Automatically embedded in Blueprint, Material, Widget, AnimBP, and BehaviorTree editors
• MCP client: Use Claude Desktop, Cursor, or any MCP-compatible tool to access CodeScape remotely

6 rules that work

1. Break complex tasks into numbered passes

One big request becomes a wall of text. The AI either skips steps or stops mid-way. Split the work into PASS 1, PASS 2, PASS 3 with one sub-goal per pass and an "Announce each pass before its tool calls" closing line.

2. Always express dimensions in centimeters via size:

Unreal world units are centimeters. CodeScape's spawn_actors tool exposes a size parameter that takes target dimensions directly in cm and computes the scale internally. Use it.

3. Name the tools when the intent is clear

Generic asks ("create a level") let the AI improvise. Naming the tool guides it toward the right call without you needing to specify every parameter.

4. State scale, style, and budget

An "ancient temple" can be 5x5 m or 50x50 m. Always specify the rough size in cm, the style (modern, medieval, sci-fi), and an actor budget if you care about performance.

5. End multi-step prompts with an explicit organize step

Your Outliner becomes a mess otherwise. Tell CodeScape to put everything into a named folder.

6. When you want it walkable, say "walkable" and demand gaps

Without explicit instruction, the AI may overlay a door cube on a solid wall (which is not walkable). State the requirement.

Common pitfalls and how to avoid them

PCG presets do not spawn content by themselves

create_pcg_preset creates an asset (a template) in the Content Browser. To get the actual procedural content visible in the level, you must follow with spawn_pcg_in_level.

For one-shot scenes, prefer generate_structure type "town" which spawns directly without the two-step PCG dance.

generate_structure uses block counts, not centimeters

This is the #1 cause of editor freezes. The tool's size object expects integer block counts. The default block_size is 100 cm, so width: 8 means an 800 cm wide structure.

CodeScape now refuses any int dimension above 30 with a clear error, but you should still write the right values.

ExponentialHeightFog is its own tool, not a volume type

manage_volumes handles BlockingVolume, TriggerVolume, KillZ, PainCausing, Physics, Audio, etc. ExponentialHeightFog has a dedicated tool because it is not a volume in the technical sense.

Parameter names are exact, not generic

The most common retry-causing mistakes when writing prompts manually:

• create_level_sequence wants name + path, not sequence_path.
• add_camera_cut_track wants a cuts array of {camera_label, start_time, end_time}, not flat fields.
• edit_actor_property wants property_value as a string, not value.
• organize_outliner wants folder, not folder_path.
• generate_structure wants type, not structure_type.

If you are unsure, just write the intent in plain English and let the AI pick the schema. The AUTO-SERVED tool details in the system prompt will steer it toward the right names.

"Plane" is not a valid actor class

Use a thin Cube for a flat ground: spawn_actors Cube, size {10000, 10000, 20}.

Budget your actor count per request

If a single prompt would spawn more than ~50 actors, split it into multiple requests, OR use generate_structure / PCG, OR call manage_mesh_merging at the end to bake the result into one merged static mesh (huge perf win).

Patterns: do vs don't

Don't: vague one-liner

The AI improvises. You get whatever it imagines, often unaligned with your goal.

Do: scoped, structured, named tools

Predictable, reproducible, debuggable.

Don't: ask for too many subsystems at once without scoping

This is a project, not a prompt. The AI will pick something arbitrary.

Do: prompt one subsystem at a time

Then in the next prompt: hunger system. Then inventory. Then UI. Each is a clean, testable unit.

Templates and Rule Packs: prompting on autopilot

Templates Library

The ✦ Templates button opens a library of 13 curated multi-pass prompts that already follow every rule above. Categories: Environment (church, village, sci-fi corridor, walkable room, two-story house, modular pack builder), Gameplay (health system, inventory UI), VFX (explosion, magic portal), Blueprint (door with key, pickupable item), Cinematic (hero reveal shot). Click any entry, send, watch it work.

You can add your own templates by editing Saved/CodeScape/user_templates.json using the same schema as the bundled defaults.

Rule Packs

Open Global AI Rules and you'll find 7 stackable presets. Toggle them per project to pin behavior across every prompt:

• Strict Greybox: no materials, only /Engine/BasicShapes, size in cm.
• Rapid Prototype: speed first, skip naming polish.
• Production Quality: enforces UE5 naming, outliner folders, compile checks.
• Multiplayer-Ready: Replicated variables, Server RPCs, authority guards.
• C++ First: prefer C++ over Blueprints.
• Modular Architecture: forces wall panels and gaps for walkable buildings.
• Plan First (Safety Net): AI announces a plan and waits for "go" before executing.

Prompt Reformulator

Type your draft in any tone or language, hit the 🪄 button (or Ctrl+Shift+R), and CodeScape rewrites it into the optimal structure: numbered passes, size: in cm, tool names spelled out, anti-pattern callouts. Press the button again to undo.

Why imported packs misbehave

Many marketplace packs (Fab, Kitbash3D, ArtStation bundles, Megascans collections) ship as FBX files exported with the world transforms baked in. The mesh's pivot stays at world origin (0, 0, 0), but the actual geometry sits hundreds of centimeters away on X and Y. When you spawn one of these meshes in Unreal, the engine places the pivot at your target location, but the visible mesh appears wherever its baked offset puts it.

Concretely, you ask for a wall at (1000, 0, 0), CodeScape spawns it correctly via spawn_actors, and the wall ends up at (200, -800, 0) because the pack's pivot-to-geometry offset was (-800, 800, 0). Multiply that across 30 walls in a fort and the result looks like a pile of cubes thrown at the level, not a structure.

This is not a CodeScape bug. It is the pack. But CodeScape now compensates for it automatically when you ask.

The anchor parameter on spawn_actors

Every actor passed to spawn_actors accepts an anchor field that controls how its world bounding box is aligned with location:

• "pivot" (default): raw mesh pivot at location.xyz, zero offset. Backwards compatible. Use only when you know the pivot is meaningful (e.g. a Blueprint with a gameplay socket).
• "center": bounding box center aligned with location.xyz. Robust against broken pivots in any axis.
• "bottom": bbox bottom Z at location.z, bbox center on X/Y. The right choice for walls, pillars, columns, anything sitting on the ground.
• "top": bbox top Z at location.z, bbox center on X/Y. For ceiling slabs hanging from a known top edge.

Rule of thumb: any mesh under /Game/<something_you_did_not_author>/* should be spawned with anchor: "bottom". The default "pivot" stays in place to avoid breaking existing call sites and Blueprints with intentional pivots.

Recommended workflow

1. Validate the pack first. Open Templates, run Modular Pack Builder (Fab / Kitbash). Paste your pack's content path when asked. The template builds a 12 m × 12 m sample fort using the most wall-shaped mesh in the pack, with anchor: "bottom" on every actor.
2. Walk through the door on the south side. If the walls align cleanly side-by-side and stand on the ground, the pack is good.
3. If walls float, overlap, or look offset: the pack has additional pivot quirks (rotation baked in, scale baked in, or per-mesh offsets that vary by panel). Generate a bug report from inside the same chat. We will look at the pack-specific signature and add another fix.
4. Once validated, ask CodeScape to build a bigger structure. Always remind it to use anchor: "bottom" on imported packs. It is in the system prompt, but a one-line reminder in your message is cheap insurance.

Prompt skeleton you can adapt

If you skip the template and prompt by hand, this skeleton works for any modular pack. Replace the path and the dimensions, keep the structure.

Choosing a provider for your task

CodeScape is provider-agnostic by design: every supported model can drive every one of the 329 tools in the registry. The plugin formats prompts, parses tool calls, and renders results identically regardless of which model is talking. What changes between providers is the model itself. Its ability to follow the tool schema, validate before acting, and avoid hallucinating API names.

This distinction matters because when a generation fails it is tempting to blame "CodeScape", but in most cases the plugin correctly forwarded the model's request to the engine and the engine correctly rejected it because the model invented something that does not exist.

Pick by task complexity

How to tell whether a failure is the plugin or the provider

Every CodeScape session writes a structured bug report to Saved/CodeScape/Reports/Bugs/report_<timestamp>_<id>/ (use the bug-reporter button in the chat). Open activity_log.jsonl, search for "success":false, and look at the arguments object next to the error string. The failure is almost always one of two cases:

1. The plugin's tool rejected an invalid request (provider issue)

Real examples we have seen in user reports, every one verifiable by hand in the editor:

In every row above the tool did exactly what it should have done. The model hallucinated a component name, a node id, an action name, or tried to wire pins of incompatible types. No plugin change can prevent a model from inventing input it never validated. Defenses CodeScape adds (did_you_mean suggestions, available_functions echoed in errors, Use force=true hints) help good models recover. They do not help models that ignore error responses.

2. The plugin's tool itself misbehaved (plugin issue)

These look different. The arguments are objectively correct, the error mentions internals (LogBlueprint Warning, an ensureMsgf trip, a stack trace pointing inside CodeScape's own modules), and the same call works on a different model. When in doubt, file a bug report through the chat. It captures everything we need to reproduce.

Field notes per provider family

These are observations, not benchmarks. Mileage varies by task, prompt quality, and model release version.

• Top-tier (Claude Sonnet 4+, GPT-5, Gemini 2.5 Pro). Reliable on multi-step Blueprint generation. Reads validate_blueprint_graph results before acting on them, reads error replies and adjusts the next call, honours Use force=true hints. For complete gamemodes (multiple BPs + Widget UI + Input setup + level wiring) we have only seen reliable end-to-end results from this tier.
• Mid-tier (Gemini 2.5 Flash, Grok-3-mini, GLM-4.6, Mistral Large). Reliable on single-tool tasks and on level-dressing recipes that are sequences of independent calls. They lose track when the BP graph starts to depend on its own previous state, so re-run individual phases rather than asking for the whole thing in one shot.
• Small / cheap tiers (MiniMax-M2.x, GPT-4o-mini, GLM small, etc.). This is where the provider/plugin split becomes most visible. We have a verified user session report (Reports/Bugs/report_2026-04-29_11-30-45_A286395F, MiniMax-M2.7 asked to assemble a complete Postman gamemode) with these headline numbers:
  • 385 total tool calls, 326 succeeded (84.7% success rate)
  • 12 distinct error signatures, every single one traceable to the failure pattern shown in the table above
  • edit_blueprint_node was called 7 times and failed 6 of them. Every failure was a node_id the model invented instead of looking up via search_nodes first
  • delete_asset calls without force=true despite the engine returning the hint four times
  The plugin did its job in every one of those failures. The model ignored the corrective hints and re-tried with the same invented inputs. If a model does not read its own tool replies, no amount of plugin polish recovers the run. Keep small tiers for one-shot tasks (translate a description into a single tool call, summarise an asset, generate a single Material). Do not ask them to assemble multi-asset gameplay systems.
• Local (Ollama, llama.cpp). 7B/8B models drop tool-call formatting frequently. 32B+ instruct-tuned models are usable for single-tool tasks. For sustained Blueprint generation, expect the same hallucination pattern as small-tier cloud models unless you are running a top-tier model locally (Llama-3.1-405B, Qwen 2.5 Coder 32B+).

What to do when a generation goes off the rails

1. Stop early. If you see repeated identical errors in the chat (the model retrying the same invented call), interrupt and rephrase. Models that fail to learn from their own error replies will keep failing on that same step.
2. Switch providers for that one task. The plugin lets you switch providers from the chat header without losing the conversation history. Send the same prompt to a top-tier model and compare.
3. Break the task down. Multi-asset gamemodes work best when each phase (create assets → wire variables → wire events → final compile) is a separate prompt. This holds even for top-tier models.
4. File a bug report if and only if the failure is clearly inside the plugin (case 2 above). Provider hallucinations are a model-vendor problem; no plugin patch fixes them.

Google Gemini

Gemini offers excellent multi-modal capabilities with image understanding. A free tier is available for experimentation.

OpenAI

The industry-standard large language model with broad knowledge of game development patterns.

Anthropic Claude

Claude excels at complex reasoning and understanding nuanced instructions. Large context window for complex projects.

DeepSeek

High-performance open model with excellent code generation capabilities at competitive pricing.

MiniMax

Specialized generation model for creative and structured content tasks.

Groq

Ultra-fast inference on open-source models (Llama, Qwen). Ideal when response latency matters.

Mistral AI

European LLM provider with strong multilingual support and the Codestral model tuned for code.

Cohere

Enterprise-grade LLM with a strong focus on retrieval-augmented generation and command-style models.

xAI Grok

xAI's Grok family, reasoning-first models with long context and tool use.

Zhipu GLM (z.ai)

Zhipu's GLM family via z.ai. OpenAI-compatible endpoint with strong coding performance and competitive pricing. The Coding Plan offers a flat $18/month rate for heavy coding workloads.

Ollama (Local)

Run AI models completely locally on your machine. No API key needed, no internet required. Full privacy for sensitive projects.

Templates Library

A new ✦ Templates button in the chat action bar opens a curated library of multi-pass prompt recipes. Click an entry to inject a fully-structured prompt into your input, ready to send.

v2.1 ships with 10 templates across 5 categories:

• Environment: Gothic Church Greybox, Medieval Village Square, Sci-Fi Corridor
• Gameplay: Health & Damage System, Inventory UI Widget
• VFX: Explosion (Niagara), Magic Portal
• Blueprint: Door With Key, Pickupable Item
• Cinematic: Hero Reveal Shot

Every shipped template uses the new size: parameter (in cm) and names tools explicitly, so the AI cannot fall into the "100x too big" scale trap. You can add your own templates in Saved/CodeScape/user_templates.json using the same schema as the bundled defaults.

Rule Packs

Open Global AI Rules and you'll find a new section above your custom instructions: a list of toggleable presets that stack with your own rules. Each pack is capped at ~500 characters (~125 tokens) so you can combine three or four without burning your context window.

v2.1 ships with 6 rule packs:

• Strict Greybox: forbids materials, forces size-in-cm, only /Engine/BasicShapes. Use for level design experiments.
• Rapid Prototype: cuts corners on naming and polish, collapses multi-actor calls into bulk spawn_actors.
• Production Quality: enforces UE5 naming (BP_, M_, WBP_, etc.), variable categories, outliner folders, compile-after-edit.
• Multiplayer-Ready: mark variables as Replicated/RepNotify, split logic into Server RPCs and OnRep, add HasAuthority() guards.
• C++ First: prefer C++ over Blueprints for new systems, expose API via UFUNCTION(BlueprintCallable).
• Plan First (Safety Net): for any 3+ tool-call request, the AI announces a numbered plan and waits for your "go" before executing.

Toggle state persists in Saved/CodeScape/enabled_rule_packs.json using atomic file writes (no corruption if the editor crashes mid-toggle). The injection point preserves Claude's prompt cache.

Prompt Reformulator

The wand button (🪄) next to the chat input rewrites your draft into the optimal CodeScape format before you send it. Powered by your active AI provider as a one-shot request that does NOT pollute the chat history.

v2.1 enriches the reformulator's system prompt with CodeScape-specific best practices:

• Multi-step requests get rewritten as numbered PASSES with explicit announce-before-tool-call instructions.
• Level design dimensions are converted to the size: parameter in cm (never raw scale).
• Tool names get spelled out by name when intent is clear (spawn_actors, configure_sky_light, organize_outliner, etc.).
• Anti-patterns get flagged (e.g. Plane is not a valid actor class, use a thin Cube instead).

Press Ctrl + Shift + R to invoke without taking your hands off the keyboard. A second press undoes the rewrite.

size: parameter on spawn_actors

Before v2.1, spawn_actors only accepted scale (a multiplier on the mesh). LLMs frequently confused this with "target size in cm" and produced geometry 100x too big: scale:{x:3000} on a /Engine/BasicShapes/Cube (which is 100 cm by default) yields a 300-meter cube, not a 30-meter cube.

v2.1 adds an intuitive size parameter (alias size_cm) that takes target dimensions in centimeters and auto-derives the correct scale from the mesh's actual bounding box:

Result: a Cube measuring exactly 30 m x 16 m x 15 m, regardless of the underlying mesh's local size. The legacy scale parameter still works as before for cases where you genuinely want a multiplier.