Overdare MCP
Uses a local Blender installation to prepare 3D model files for import, making them import-ready before driving them through OVERDARE Studio's mesh import dialog (including bulk import of many prepared meshes). The Blender executable can be auto-detected or configured via the OVERDARE_BLENDER environment variable.
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
Overdare MCP
An MCP server that lets AI agents (Claude Code / Claude Desktop) drive OVERDARE Studio — browse the DataModel, create and edit instances, write Luau scripts, and start playtests.
How it works
OVERDARE Studio already hosts a local JSON-RPC server (the same one its built-in
"diligent" agent uses). This MCP server is a thin bridge to it — much like
unity-mcp's connector, except Studio hosts the local server itself, so
there's no plugin to install.
Claude ──stdio──▶ overdare-mcp ──raw TCP──▶ Studio RPC (127.0.0.1:13377)
──HTTP────▶ UE Remote Control (127.0.0.1:30010)
└─ OVERDARE Studio (must be running)Port 13377 is not HTTP. It is newline-delimited JSON-RPC 2.0 straight over a
TCP socket, one connection per call — speaking HTTP at it yields a protocol
violation instead of a response. Remote Control on 30010 is HTTP, and is a
separate surface (the overdare_rc_* tools) that reaches the Unreal editor
underneath rather than the OVERDARE DataModel.
Studio must be open with a project for tools to work. If Studio isn't running, tools return a clear "cannot reach Studio" error instead of hanging.
Related MCP server: onyx MCP
Setup
git clone https://github.com/ShootTheMoon/overdare-mcp
cd overdare-mcp
npm install
npm run buildVerify the connection (open OVERDARE Studio first):
npm run probe # smoke test + level.browse
npm run probe -- instance.read '{"path":"Workspace.Baseplate"}' # inspect any methodRegister with Claude Code
Add to .mcp.json in your project (an example is included in this repo):
{
"mcpServers": {
"overdare": {
"command": "node",
"args": ["/ABSOLUTE/PATH/TO/overdare-mcp/dist/index.js"]
}
}
}For Claude Desktop, add the same block under mcpServers in
claude_desktop_config.json.
Configuration (env vars)
Var | Default | Purpose |
|
| Studio RPC host ( |
|
| Studio RPC port ( |
|
| Per-call timeout |
| auto-detected | Fallback project directory for the file-backed tools |
| auto-detected | Blender executable used by |
Tools
Three backends sit behind these, and the difference matters when something
fails. RPC talks to Studio live over 13377. File edits the saved
.ovdrjm and asks Studio to reload, which is how the tools whose RPC method
does not exist are implemented — stop any playtest before using those. Each such
edit first copies the level into .ovdr-backups/ beside it, keeping the last
ten, and reports the path it wrote. RC is Unreal Remote Control on 30010.
Reading
Tool | Via | Purpose |
| RPC | Browse the DataModel tree. Start here — everything else targets |
| File | Search by name substring and/or class; far more practical than browsing a large project |
| File | Read one instance's properties as saved |
| File | Read a script's Luau source |
| luau-lsp | Type-check scripts against the OVERDARE type definitions |
| — | Report what is reachable and configured |
overdare_validate_lua runs the luau-lsp and overdare-types.d.lua that ship
beside Studio's bundled agent, so it knows the real API surface — it will tell
you that Key 'Bold' not found in external type 'TextLabel', which is exactly
the kind of break an engine update causes and that otherwise only shows up as a
runtime warning in Sandbox.log. It takes scripts already in the project (by
GUID or dotted path, as overdare_find reports them) or files on disk.
Its blind spot is worth knowing: a local from Instance.new("TextLabel") is not
narrowed to TextLabel, so property errors on that local go unreported. Annotate
the local, or check the value at runtime with overdare_observe.
Editing
Tool | Via | Purpose |
| File | Create a Part |
| File | Create one instance of any class |
| File | Bulk-create under one parent in a single reload |
| File | Change properties and/or rename |
| File | Reparent |
| File | Copy a subtree with fresh GUIDs |
| File | Delete by GUID |
| RPC | Create live, under one parent, no reload |
| RPC | Change properties live, no reload |
| RPC | Delete live, without a reload |
| File | Create a Script / LocalScript / ModuleScript |
| File | Replace a script's source, or toggle |
Prefer the RPC three when you are iterating: the file-backed tools rewrite the project and ask Studio to reload, so they need the playtest stopped, while these go to the running editor. Two things about them are worth knowing before you trust a result:
Properties go flat. Nesting them under a
Propertieskey does not fail — the call succeeds,messagesaysProperties is not a valid property of Frame, and every value is dropped. Same for a misspelled property name: a[WARNING]inmessage, not an error. Readmessage.A class this build lacks is not an error either. The call succeeds and returns fewer GUIDs than you asked for.
overdare_instance_createpairs them back up and reportsguid: nullper instance.UICorner,UIGradient,UIPadding,UISizeConstraint,UITextSizeConstraint,ViewportFrame,TextBox,CanvasGroupandVideoFrameare all absent;UIStroke,UIListLayout,UIGridLayout,UIAspectRatioConstraint,ProgressBarandScrollingFrameare present.
Composite property values are tagged objects, and UDim2 spells its second axis
with a lower-case y — an upper-case Y is silently dropped. Rather than write
those by hand, pass the array short forms (Size: [0.5, 10, 0, 64],
BackgroundColor3: [20, 180, 90], AnchorPoint: [0.5, 1]); see src/props.ts.
Project lifecycle
Tool | Via | Purpose |
| RPC | Save the project to disk |
| RPC | Reload pending level changes |
| RPC | Publish to the Hub (owner only) |
| — | Re-detect or pin the project directory |
Playtest and viewport
Tool | Via | Purpose |
| RPC | Start / stop a playtest |
| RPC | Capture the viewport and return the image. UI is included; |
| RC | Aim the editor camera before a screenshot |
| RC | Read or change how the editor viewport renders |
Runtime observation
Only meaningful while a playtest is running. A screenshot shows pixels and the
saved project shows what was authored; neither shows what the running game
currently holds, which is where UI bugs live — a label a script rewrote, a frame
a layout pushed off screen, a button buried under a higher ZIndex.
Tool | Via | Purpose |
| RPC | Is a playtest running, and which clients take input |
| RPC | The live UI as flat elements: path, class, text, normalized rect, visibility |
| RPC | Character, UI, and live instance state in one game-thread read |
| RPC | CFrame, speed, facing, what it stands on |
| RPC | Keys, pointer, look, scroll, waits — up to 64 events |
Two things the underlying method does not tell you, which the tool handles:
pieSessionIdandclientIdare mandatory on the wire. Omitting either fails the batch with the sameInvalid input eventas a malformed event, sooverdare_input_injectresolves both fromgame.pie.statuswhen you leave them out.action: "press"is documented but rejected by this build; onlydown/upare accepted. The tool expandspressinto adown/wait/uptriple so the short form still works.
Pointer events only land on the part of the viewport that lies inside the Studio
window. When the window hangs off screen the reachable region shrinks — sometimes
to a sliver — and overdare_ui_browse reports it under viewport.reachable.
The game still renders the whole frame, so a screenshot looks fine while a click
at those coordinates goes nowhere.
Assets
Tool | Via | Purpose |
| — | List the curated Asset Drawer catalog |
| RPC | Import an Asset Drawer model by id |
| RPC | Import a local PNG/JPG into the asset manager |
| Blender | Make a 3D file import-ready (see below) |
| GUI | Drive many prepared meshes through the import dialog |
| RC | Query the engine asset registry |
| RC | Search the Unreal asset library |
Unreal Remote Control (low level)
Tool | Purpose |
| Call a UFunction on an Unreal object |
| Read or write a property |
| Describe an object's properties and functions |
| Enumerate live actors and their object paths |
| Read or change the editor's actor selection |
| Run a console command or read a cvar |
| Several RC requests in one round-trip |
| Run an Unreal Python command |
overdare_rc_batch and overdare_rc_python do not work against a shipping
Studio build: PUT /remote/batch has crashed Studio outright, and
ExecutePythonCommand returns 400 because the Python plugin is not loaded.
They are kept for builds that do support them.
Escape hatch
Tool | Purpose |
| Call any Studio RPC method with raw params |
| Read a build recipe adapted from the built-in agent's skills |
Smart mesh import (overdare_mesh_prepare)
OVERDARE caps imported meshes at 30,000 triangles per mesh and recommends
512px textures (large 4K textures OOM the importer). overdare_mesh_prepare
runs headless Blender to make any .fbx / .obj / .glb / .gltf / .blend
import-ready:
decimates an over-budget mesh to fit the triangle limit,
downscales & re-embeds textures to the target size,
writes a self-contained
<name>_overdare.fbx.
The final Import into Studio (Home ▸ Import) is still a manual GUI step. Requires
Blender installed — Steam installs are auto-detected; set OVERDARE_BLENDER to
override the path.
Switching projects (overdare_set_project)
The .ovdrjm file-edit tools now auto-follow whichever project is open in
Studio (recovered from its screenshot path). After switching projects in
Studio, call overdare_set_project with no args to re-detect, or pass a dir to
pin a specific project directory. OVERDARE_PROJECT_DIR remains a fallback.
Which RPC methods actually exist
Method names were originally read out of the Studio runtime, and several of them turned out not to be dispatchable. Probed against a live Studio (2026-09-07):
Present. level.browse · level.apply · level.save.file ·
level.publish · instance.create · instance.update · instance.read ·
instance.move · instance.delete · game.play · game.stop ·
game.screenshot · game.observe · game.ui.browse · game.pie.status ·
game.character.read · game.input.inject · viewport.camera.read ·
viewport.camera.set · hub.token.read
Absent — these return -32601, so anything routed to them fails: every
script.* method, instance.upsert, procedural.run, the asset-import
methods, and validatelua. They belong to the bundled agent, not to the RPC
surface. The script and instance tools here go through the project file instead,
which is why they carry the "stop the playtest first" caveat.
There is no discovery method — rpc.discover and system.listMethods are both
absent. To check whether a method exists, call it with empty params and read the
error: -32601 means no such method, anything else means it is there.
npm run probe -- <method> '<json>' does this, and overdare_rpc is the
fallback for a method with no dedicated tool.
Reading results back without being misled
Every trap below returns a plausible answer rather than an error, so it costs a
while to notice. All measured against a live Studio while building the UI motion
work in onlyoneshot (2026-09-07/08).
A screenshot without UI looks like a correct screenshot. game.screenshot
renders the world alone by default, despite documenting the opposite.
overdare_screenshot now sends includeGui: true for you, but a raw
overdare_rpc game.screenshot still needs it spelled out.
Screenshots are refused while two playtest clients are running — the error is
game.screenshot is ambiguous. Start one client when you intend to look at the
screen, or read state with overdare_observe instead.
game.ui.browse rects are in render-viewport pixels, not UI pixels. The two
differ by the display scale: a 2266-wide render against a 1511-wide UI space is
1.5x, so a 700px-wide label reports 1050. Compare normalized values against each
other, or divide before checking against a layout number — otherwise correctly
placed elements read as 14px out of position.
AbsoluteSize is the wrong thing to verify a tween with. It is zero while the
owning ScreenGui is disabled, and it trails the property by a frame. Read the
property the tween actually drives — Size.X.Scale, BackgroundTransparency —
which is also live when the GUI is hidden.
task.wait overshoots badly while the level is still loading. Sampling a
0.5s tween with task.wait(0.25) can land after it finished, which reads as
"tweens snap instantly" — they do not. Count frames in a RenderStepped
connection and log (elapsed, value) pairs instead. This produced a wrong
conclusion twice before the frame-counting check settled it.
level.apply can exceed the 10s default timeout. The edit lands; only the
RPC gives up. Raise STUDIO_RPC_TIMEOUT_MS or re-read the tree to confirm,
rather than retrying an edit that already succeeded.
Drawing with Rotation
GuiObject.Rotation works, which matters because stacking small squares to fake
a diagonal is the most expensive habit in a UI script — instance count is the
only lever that has ever moved this project's framerate.
Screen y points down, so rotating a vertical bar (0,1) by t yields
(-sin t, cos t). To aim it along (dx, dy) the angle is
math.deg(math.atan2(-dx, dy)) — drop the minus and you get a mirrored zigzag.
Building a curve from segments, tilt each piece along the chord between two adjacent sample points, not along the tangent at one point. The chord gives the length and the angle together, so the joints close; tangents leave gaps.
Replacing stacked pieces with one solid bar also exposes overlaps that the gaps used to hide — expect to re-tune positions, not just counts.
Mesh pipeline scripts
scripts/ holds the Blender and Node helpers used to move large maps into Studio.
OVERDARE caps a FBX at 30k triangles and 200 meshes, so big assets are split first.
Script | Purpose |
| Cut one asset into <=30k-tri pieces with world coordinates baked into the vertices, so every piece places at the same origin |
| Run |
| Merge thin ornamental faces (friezes, glyphs) into one mesh so decimation can't leave floating slabs |
| Build placement items for a split asset from |
| Earlier recentred-split workflow (per-piece offsets) |
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Related MCP Connectors
Make games with AI: one MCP server that connects your agent to Unity, Unreal and Godot editors.
MCP server for building and testing AI agents with multi-model experimentation and insights.
MCP server that lets your AI assistant build and deploy apps, hosting each one at a live URL.
Official MCP server for Agentwork — delegate tasks to AI agents with human-in-the-loop
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceAn MCP server that enables AI agents to act as dynamic dungeon masters for text-based RPGs with dynamically generated rule systems and comprehensive game state management.15MIT
- AlicenseNot gradedqualityDmaintenanceLocal MCP server that gives AI agents 44 engine tools to build, run, and debug real 2D and 3D games through conversation.MIT
- AlicenseNot gradedqualityCmaintenanceAn AI-native game engine MCP server that enables AI agents to create, modify, and run games using 53 tools for scene creation, physics, audio, 3D rendering, and AI-generated images and music.1MIT
- AlicenseNot gradedqualityCmaintenanceA Discord MCP server that gives AI agents full control of a Discord bot — messages, channels, roles, threads, forums, events, webhooks, reactions, moderation, image generation, and real-time voice.7MIT