Skip to main content
hc
Submit
4 compared

3D & game dev MCP servers compared

3D and game-engine MCP servers that let Claude drive creative and game tooling, compared on trust, setup, and safety.

Open in the interactive comparison tool
FieldBlender MCP Server

MCP server and Blender add-on that let Claude inspect scenes, create and modify 3D objects, run Blender Python, capture viewport screenshots, and use asset or 3D-generation integrations from inside Blender.

Open dossier 		Unity MCP Server

Unity Editor MCP bridge that lets AI assistants manage assets, edit scripts, control scenes, run tests, and automate Unity workflows through the Model Context Protocol.

Open dossier 		Godot MCP Server

MCP server for controlling the Godot game engine, launching the editor, running projects, capturing debug output, and editing scenes and resources.

Open dossier 		Unreal Engine MCP Server

MCP server and native Unreal Engine automation bridge for controlling UE5 projects, assets, actors, levels, Blueprints, Niagara, Sequencer, tests, screenshots, logs, and editor automation from Claude.

Open dossier
Trust
Install riskReview firstReview firstReview firstReview first
Notes Safety ✓ Privacy ✓ Safety ✓ Privacy ✓ Safety ✓ Privacy ✓ Safety ✓ Privacy ✓
Categorymcpmcpmcpmcp
Sourcesource-backedsource-backedsource-backedsource-backed
AuthorSiddharth AhujaCoplayDevCoding SoloChiR24
Added2026-06-062026-06-062026-06-052026-06-06
Platforms
Claude CodeClaude Desktop
Claude CodeClaude Desktop
Claude CodeClaude Desktop
Claude CodeClaude Desktop
Source repo————
Safety notes✓The MCP server talks to a Blender add-on over a socket and can create, modify, delete, import, and inspect objects in the active Blender scene. The `execute_blender_code` tool can run arbitrary Python code inside Blender, so save work before use and review generated scripts before allowing execution. Optional Poly Haven, Sketchfab, Hyper3D, and Hunyuan3D workflows can download assets, import generated models, or call external services that may have their own usage limits, licenses, and terms. The README warns to run only one MCP server instance for the same Blender connection to avoid confusing the socket workflow. Do not expose the Blender socket or any remote-host setup beyond trusted local or development networks without reviewing access controls.✓Unity MCP can create, modify, delete, and inspect Unity project assets, scenes, scripts, tests, editor state, and generated files. Agents may execute Unity Editor actions that trigger imports, compilation, play mode, tests, package changes, or custom editor scripts. Use tool groups and project-level scoping to limit which Unity workflows an agent can access. Test automation in a disposable project before connecting the server to production game, simulation, AR, VR, or client work. Remote server auth and multi-instance routing should be configured carefully so an agent controls only the intended Unity Editor instance.✓Godot MCP can launch the editor, run projects, stop projects, inspect project structure, create scenes, add nodes, load sprites, export MeshLibrary resources, save scenes, and update UID references. Running a Godot project can execute project scripts, editor plugins, tool scripts, and asset import logic, so use trusted projects and review side effects before agent-driven runs. Scene and resource tools can modify project files; review generated changes before committing or overwriting assets. Debug logging can be verbose and may expose paths, errors, project internals, or runtime state.✓Unreal Engine MCP Server can create, import, duplicate, rename, move, delete, and modify project assets, actors, levels, Blueprints, Niagara systems, Sequencer tracks, materials, audio, tests, logs, console variables, and editor state. The bridge exposes editor automation through native HTTP/SSE or WebSocket transports; keep listeners on loopback unless you intentionally enable and secure LAN access. Capability-token authentication, TLS, command validation, path sanitization, rate limits, and loopback binding should be reviewed before using remote or multi-user setups. Require confirmation before running console commands, Python execution, UnrealBuildTool tasks, Play-In-Editor sessions, asset deletion, level saves, plugin changes, imports, exports, or source-control-affecting operations. Test against disposable projects before allowing an agent to automate production levels, gameplay systems, render settings, or content directories.
Privacy notes✓Tool calls can expose scene names, object metadata, materials, generated Python snippets, viewport screenshots, prompt text, and asset queries to the connected MCP client and model provider. Blender MCP includes telemetry code and project terms describing collection of prompts, generated code, scene metadata, screenshots or viewport images when telemetry consent is enabled. The repository documents `DISABLE_TELEMETRY=true`, `BLENDER_MCP_DISABLE_TELEMETRY=true`, and `MCP_DISABLE_TELEMETRY=true` as environment-variable opt-outs for telemetry. The terms state that collected data may be retained, used for AI training or research, and shared in anonymized or aggregated datasets; review the current terms before using it on confidential client work. Third-party asset and generation services may receive prompts, image references, asset searches, downloads, or account identifiers depending on which integrations are enabled.✓Scene names, asset paths, scripts, serialized object data, test results, editor logs, package metadata, and project structure may be exposed to the MCP client and model. Unity projects can contain proprietary artwork, gameplay systems, licensed assets, unpublished game logic, client IP, and credentials embedded in editor tooling. Remote server mode may expose project context over the network; require authentication and avoid sharing endpoints beyond trusted clients. Review generated scripts and asset changes before committing, shipping, or syncing them to shared repositories.✓Project paths, scene names, asset names, debug output, errors, source structure, node trees, generated resources, and prompts may be visible to the MCP client and model provider. Godot projects may contain unreleased game content, licensed assets, gameplay logic, credentials in config files, or private build paths. Avoid sharing debug logs or generated scene diffs publicly until they are reviewed for sensitive project details.✓Project paths, asset names, level contents, screenshots, editor logs, test output, Blueprint graphs, console variables, and generated automation reports can be exposed to the MCP client. Screenshot and viewport tools may capture unpublished game content, UI, debug overlays, local paths, or proprietary assets. Native plugin logs, TypeScript bridge logs, metrics endpoints, and MCP transcripts can reveal project names, file-system paths, automation requests, and tool results. Treat capability tokens, project paths, LAN listener settings, and generated screenshots as sensitive local configuration. Keep automation output inside approved project or scratch directories and remove temporary artifacts before sharing traces or bug reports.
Prerequisites
  • Blender installed locally with permission to install and enable the repository's `addon.py` file.
  • uv or uvx available to run the packaged `blender-mcp` server.
  • Blender MCP add-on running in Blender and connected through the local socket server, usually on `localhost:9876`.
  • Optional API keys or account setup for third-party integrations such as Hyper3D, Sketchfab, Hunyuan3D, or asset-download workflows.
  • Unity Editor installed with a project you are authorized to modify.
  • Unity Package Manager access to add a package from a git URL, or another install path documented by the project.
  • Python 3.10 or newer for the MCP server side documented by the project.
  • MCP-capable client such as Claude, Codex, VS Code, Cursor, or another supported host.
  • Godot Engine installed on the development machine.
  • Node.js 18 or newer and npm available to the MCP client runtime.
  • Godot project directory containing a `project.godot` file.
  • Clear approval rules for when an agent may run, stop, or edit a project.
  • Unreal Engine 5.0 through 5.8 with a project that can load the included McpAutomationBridge plugin.
  • Node.js 18 or newer when using the TypeScript stdio bridge; native MCP transport can run inside the plugin without Node.js.
  • A code-enabled Unreal project or a prebuilt plugin package that matches the target Unreal Engine version.
  • Required Unreal plugins such as MCP Automation Bridge, Editor Scripting Utilities, and Niagara enabled before automation starts.
Install
claude mcp add blender uvx blender-mcp
Add https://github.com/CoplayDev/unity-mcp.git?path=/MCPForUnity#main through Unity Package Manager, then run Window > MCP for Unity > Configure All Detected Clients.
npx @coding-solo/godot-mcp
npx unreal-engine-mcp-server
Config
{
  "mcpServers": {
    "blender": {
      "command": "uvx",
      "args": ["blender-mcp"],
      "env": {
        "DISABLE_TELEMETRY": "true"
      }
    }
  }
}
{
  "mcpServers": {
    "UnityMCP": {
      "command": "uvx",
      "args": [
        "--from",
        "mcpforunityserver",
        "mcp-for-unity",
        "--transport",
        "stdio"
      ]
    }
  }
}
{
  "mcpServers": {
    "godot": {
      "command": "npx",
      "args": ["@coding-solo/godot-mcp"],
      "env": {
        "GODOT_PATH": "PATH_TO_GODOT_EXECUTABLE",
        "DEBUG": "true"
      }
    }
  }
}
Manual-only setup:
claude mcp add unreal-engine -- npx unreal-engine-mcp-server
Citations
ClaimUnclaimedUnclaimedUnclaimedUnclaimed
More comparisons, weekly

A short, calm digest of reviewed Claude resources. Unsubscribe any time.