AkerMCP

<p align="center"> <img src="readmeData/AkerMCP.png" alt="AkerMCP: Aker, the twin lions, bridging the AI and the game engine" width="680"> </p>

Aker (Egyptian: ꜣkr) was an ancient Egyptian earth god, depicted as two lions seated back-to-back facing opposite horizons, Sef and Duau (Yesterday and Today), guarding the sun's safe passage through the underworld. In this architecture, Aker is the bridge: one face speaking JSON-RPC to the LLM, the other manipulating the engine's main thread via IPC.

AkerMCP is an MCP server that lets an AI client (Claude Code, Cursor, Copilot, Antigravity, any stdio MCP client) work inside a running C# game editor: read the scene, change it with undo, run C# on the editor's main thread, take a screenshot, enter play mode and check what happened. One server and one tool set for three engines, Unity, Godot and Stride Game Studio, each behind a small adapter over the same core.

What it does

Most engine integrations ship one hand-written tool per operation and break with every engine update. AkerMCP ships forty generic tools built on reflection and Roslyn. inspect shows what an object is made of, set_property changes any property by a dot path with undo, query finds objects, execute compiles and runs any C# against the live editor (with using lines and type declarations hoisted, so a helper class or a MonoBehaviour can be written and attached in one call), take_screenshot shows the result. The runtime loop, enter_play, send_input, sample_state, assert_state and the one-call playtest, runs the game and checks a mechanic against real values instead of pixels. Placeholder art and audio work the same way: the model writes a spec, the server returns a PNG or a WAV. Whatever the editor can do, the model can do, and it can see whether it worked.

AI: "Set the player's position to (10, 0, 5)"

-> set_property {"object_path": "/Player", "property_path": "position", "value": {"x":10,"y":0,"z":5}}
<- Property 'position' set successfully on /Player

Supported engines

| Capability | Unity | Godot | Stride | |---|:--:|:--:|:--:| | Inspect · query · get/set property (incl. nested) | ✅ | ✅ | ✅ | | call_method · create · delete (native Undo) | ✅ | ✅ | ✅ | | execute: arbitrary C# via Roslyn | ✅ | ✅ | ✅ | | Selection · console logs · recompile/compile-errors | ✅ | ✅ | ✅ | | Scene-view screenshot with editor gizmos | ✅ | ✅ | ✅ | | Platform/build tools (list · switch · build_player) | ✅ | ✅ | ✅ | | OS window capture (list_windows · capture_window · focus_window) | ✅ | ✅ | ✅ | | 2D sprites from a JSON shape-spec (create_sprite, rasterized server-side) | ✅ | ✅ | ✅ | | Placeholder audio (create_sound, synthesized server-side) | ✅ | ✅ | ❌ | | Gameplay primitive scripts (add_primitive) | ✅ | ❌ | ❌ | | Scene management (new_scene · open_scene · save_scene) | ✅ | ✅ | ✅ | | Runtime loop (enter_play/exit_play · capture_sequence · send_input) | ✅ | ◑ | ◑ |

Every ✅ is implemented and was verified live in that engine's editor. A ❌ answers NOT_SUPPORTED and names what is missing rather than failing quietly: Stride has no sound importer yet, and the primitive catalog carries Unity variants only. The window tools are the exception to the whole table, since they talk to the operating system, Windows or macOS, and work with no engine connected at all: they are how you see and dismiss a modal dialog that has frozen the editor's main thread.

What it does that the others do not

The other MCP servers for game engines are tied to one engine each: unity-mcp and Unity-MCP to Unity, godot-mcp to Godot. Here one tool set covers Unity, Godot and Stride from a shared core, so what you learn driving Unity works unchanged in the other two, and Stride Game Studio is supported at all.

execute hoists using lines and type declarations, so a MonoBehaviour can be written, compiled and attached in one call instead of three. playtest drives input and evaluates C# assertions server-side at exact moments on the timeline, which is the only way to catch a transient as short as the top of a jump arc: separate tool calls arrive whenever the round trip lets them, and by then the frame is gone.

Then there is the asset gap. A model writes code, not pixels. create_sprite closes it: the model describes the shape in JSON, with ellipses, rectangles, polygons and SVG path data, plus linear gradients and per-shape opacity, and the server rasterises that to an RGBA PNG at 4x supersampling before the plugin imports it as a sprite. The vector never reaches the editor, so Godot and Stride need no SVG support of their own to get the same placeholder Unity gets. create_sound does the same for audio on Unity and Godot, synthesising a WAV from a jsfxr-style spec. The prototype stops waiting for someone to draw the bird.

Pair it with LynxMCP for code search over the project and its library docs: Aker is the hands, Lynx the memory.

<img src="docs/images/unity-execution-demo.png" alt="AkerMCP in Unity: a ring of spheres spawned by one execute call" width="1024">

The same request in Stride Game Studio. execute duplicated a sphere into a ring through Stride's asset layer, so they are real, selectable, saved entities (note AkerSphere_* in the hierarchy), then the editor captured itself:

<img src="readmeData/Stride.png" alt="AkerMCP in Stride Game Studio" width="1024">

Under the hood

• A shared .NET Standard 2.1 core holds the tool logic; each engine adds an adapter that implements the engine interfaces (scene graph, editor context, code executor, play mode, input, capture). A fourth engine is another adapter; the server and the tools do not change.
• The standalone server talks JSON-RPC over stdio to the client and MessagePack over a named pipe to the plugin inside the editor, which runs every request on the engine's main thread.
• A reflection-based type system converts JSON to engine structs (Vector3, Color, Bounds, ...) case-insensitively, the same way for all three engines.
• Screenshots come from the editor's own render buffer with gizmos; when an adapter cannot, an OS-level capture (Windows PrintWindow, macOS Quartz) takes over without stealing focus.
• The server answers the MCP handshake in well under a second, connected engine or not, and sends the model its usage instructions with the tool list. See How the model learns to use it.

Details: Architecture and Writing an Engine Adapter.

---

Table of Contents

• Quick Start (Recommended)
• Connecting an AI Client
• Advanced: Building from Source (For Developers)
• Verifying the Connection
• MCP Tools
• MCP Resources
• Type System
• Example Session
• Architecture
• Writing an Engine Adapter
• Two sessions, as they happened
• How the model learns to use it
• Troubleshooting
• License

---

Quick Start (Recommended)

Two steps: (1) install the adapter for your engine, Unity, Godot or Stride (they are peers; pick the one you use), then (2) run the standalone MCP server, which is identical for all of them and auto-discovers whichever engine is running.

1a. Unity Setup

You do not need to install the .NET SDK or compile any code for Unity.

1. Go to the latest GitHub Release and download AkerMCP.unitypackage.

2. Open your Unity project and double-click the package to import it. (This package already contains all necessary C# scripts, dependencies, and Roslyn compilers).

3. (Optional) Open the menu AkerMcp → Setup Test Scene to create a ready-to-test scene.

4. Open Window → AkerMcp and click Start AkerMcp Plugin. You should see a green Running status. (Tip: The plugin must be running before you start the server. The server discovers it automatically via a lock file).

   

1b. Godot Setup

AkerMCP ships a Godot 4.x (.NET/C#) adapter with the same full toolset as Unity. Because a Godot project is a real .csproj, there are no DLLs to copy: references and the Roslyn engine come via NuGet/ProjectReference.

1. Download AkerMcp.Godot-addon.zip from the latest Release and extract it so you get addons/aker_mcp/ in your Godot project (or copy this repo's plugins/godot folder into your project as addons/aker_mcp).
2. Add the AkerMcp core to your game's .csproj (or use the included samples/godot project directly; run setup-samples first to link the addon):

   <ProjectReference Include="path/to/AkerMcp.Shared.csproj" />
   <ProjectReference Include="path/to/AkerMcp.Client.csproj" />
   <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="4.8.0" />
   

   Make sure your project has <EnableDynamicLoading>true</EnableDynamicLoading> (required for editor plugins).
3. Build the C# solution once (Project → Tools → C#: Create/Build), then enable the plugin under Project → Project Settings → Plugins → AkerMcp.

The plugin auto-starts with the editor and pumps requests on the main thread every frame. Scene paths follow the edited scene root (e.g. /TestScene/Box), property paths are case-insensitive (position.x resolves to Position.X), and screenshots capture the editor's 3D viewport. The standalone MCP server discovers the Godot plugin automatically, with no server changes.

1c. Stride Setup

AkerMCP ships a Stride (Game Studio) adapter with the same full toolset, including undoable edits via Stride's Quantum graph, execute (Roslyn), real Scene-view screenshots (editor back-buffer, with gizmos), and the platform/build tools (dotnet build per executable project).

Stride support runs as a Game Studio editor plugin. Game Studio has no third-party plugin discovery, so AkerMcp registers itself with one tiny bootstrap. Pick the path that matches how you got Stride.

Option A (recommended): Stride installed from the Launcher, official binaries, no Stride rebuild

A per-launch wrapper injects the plugin only into the Game Studio process it starts, via the .NET runtime's DOTNET_STARTUP_HOOKS. The variable is never written to your user/machine environment, so it cannot affect any other .NET app; if the plugin DLL is ever missing, the wrapper just launches Game Studio without AkerMcp.

# one-time, from the repo root
.\install-stride-wrapper.ps1 -GameStudioPath "C:\path\to\Stride.GameStudio.exe"
# (omit -GameStudioPath to auto-detect a Launcher install)

This builds the adapter against your installed Game Studio, drops it into <GameStudio>/AkerMcpPlugins, and creates a "Stride Game Studio (AkerMCP)" shortcut (Desktop + Start Menu). Launch Stride from that shortcut and open a project + scene; the pipe server starts automatically. Your official Stride shortcut keeps launching Game Studio untouched. Remove everything with .\install-stride-wrapper.ps1 -Uninstall.

Option B: you build Stride Game Studio from source

The adapter loads in-process via a drop-in loader patched into Game Studio itself (no wrapper needed).

1. Build Stride Game Studio from source (the adapter references its editor assem