MCP for Unity

Build scenes, edit C# scripts and run tests in the Unity Editor from a chat.

Started in our test
★ 15.4K GitHub stars
29 downloads a week
Last commit 19 Oct 2026

At a glance

MCP for Unity comes in two parts: a Unity package that opens a bridge inside the Editor, and a Python server that your MCP client starts. With both running, the assistant can create and change GameObjects and scenes, write and fix C# scripts, manage assets and prefabs, read the console, run tests and start builds.

It started as justinpbarnett/unity-mcp and is now maintained by Coplay under CoplayDev/unity-mcp. The Editor package has a window that writes the client config for you, which is the easiest way to set it up.

Made by: Coplay (CoplayDev), started by Justin P. Barnett
Licence: MIT
Latest version: 10.3.0 (4 Oct 2026)
PyPI package: mcpforunityserver
GitHub stars: 15.4K
Downloads: 29 a week
Last commit: 19 Oct 2026
Tools: 48
Runs on: Your computer

Our check: We ran this exact config on 27 Oct 2026: it started and answered with 48 tools. The npm package called "unity-mcp" has no link to this project. The server is published to PyPI as mcpforunityserver, whose project links point back to CoplayDev/unity-mcp.

What's in the pod: its tools

We found 48 tools when we started it on 27 Oct 2026. 6 only read. The rest can change things, so keep your app's "ask before each tool call" setting on for them.

How we tested it: Started mcpforunityserver 10.3.0 from PyPI with no Unity Editor attached. It lists its tools on its own; calling them needs the Editor open with the MCP for Unity package.

Runs commands10 tools · Can start programs or run code.

Tool	What it is for
`batch_execute`	Runs many commands in one call, which is much faster for big changes.
`create_script`	Creates a new C# script at a path in the project.
`delete_script`	Deletes a C# script.
`execute_code`	Runs C# code inside the Editor with full access to the Unity APIs.
`execute_menu_item`	Runs any Unity menu command by its path.
`manage_script`	An older all-in-one script tool, kept for compatibility.
`manage_script_capabilities`	Reports which script operations and limits the server supports.
`run_tests`	Starts a Unity test run and returns a job ID.
`script_apply_edits`	Edits a script by method or class rather than by line, which is safer for bigger changes.
`validate_script`	Checks a C# script and returns compiler diagnostics.

Changes things32 tools · Can create, edit, send or delete.

Tool	What it is for
`apply_text_edits`	Changes exact character ranges in a script.
`blender_bridge`	Talks to a Blender instance running the BlenderMCP add-on: read its scene, take a viewport screenshot, run Python there and bring models across.
`find_gameobjects`	Finds GameObjects by name, tag, layer, component or path and returns their IDs.
`generate_audio`	Generates sound effects or music with your own fal.ai key and imports them as audio clips.
`generate_image`	Generates 2D images with your own fal.ai or OpenRouter key and imports them as textures or sprites.
`generate_model`	Generates 3D models with your own Tripo, Meshy or fal key and imports them.
`import_model`	Imports a model from Sketchfab, using your own Sketchfab token.
`import_model_file`	Imports a model file that is already on disk, such as an FBX or glTF.
`manage_animation`	Controls Animators and creates animation clips.
`manage_asset`	Imports, creates, searches, moves and deletes assets.
`manage_build`	Starts player builds, switches platform and manages build settings and profiles.
`manage_camera`	Sets up cameras, including Cinemachine if it is installed.
`manage_components`	Adds or removes components and sets their properties.
`manage_editor`	Enters and leaves play mode, adds tags and layers, switches the active tool and runs undo and redo.
`manage_gameobject`	Creates, changes, duplicates, moves and deletes GameObjects.
`manage_graphics`	Changes volumes, post-processing, light baking and render pipeline settings.
`manage_material`	Creates materials and sets colours, shaders and properties.
`manage_packages`	Lists, installs and removes Unity packages and registries.
`manage_physics`	Changes physics settings, collision layers, materials and joints, and runs physics queries.
`manage_prefabs`	Creates prefabs from objects, edits their contents and saves them.
`manage_probuilder`	Builds and edits ProBuilder meshes for quick level geometry.
`manage_profiler`	Starts the profiler, reads counters, takes memory snapshots and opens the Frame Debugger.
`manage_scene`	Opens, creates, saves and inspects scenes, including the hierarchy and build settings.
`manage_scriptable_object`	Creates and edits ScriptableObject assets field by field.
`manage_shader`	Creates, reads, updates and deletes shader files.
`manage_texture`	Generates simple textures such as fills, gradients and patterns.
`manage_tools`	Shows and switches the optional tool groups for the session.
`manage_ui`	Creates and edits UI Toolkit documents, styles and components.
`manage_vfx`	Sets up particle systems, VFX Graph, line and trail renderers.
`read_console`	Reads or clears messages in the Unity console.
`refresh_unity`	Refreshes the asset database and can wait for scripts to compile.
`set_active_instance`	Picks which Unity Editor to talk to when several are open.

Only reads6 tools · Looks things up and changes nothing.

Tool	What it is for
`debug_request_context`	Prints details of the current MCP session, for debugging the connection.
`find_in_file`	Searches a file with a regular expression and returns matching lines.
`get_sha`	Returns a script's hash and size without its contents, to detect changes.
`get_test_job`	Checks on a test run started with run_tests.
`unity_docs`	Looks up the official Unity documentation for a class or method.
`unity_reflect`	Checks the live Unity C# API by reflection, so the model does not invent methods.

Grouped and described by us. The README on GitHub lists the inputs each tool takes.

How clearly it describes its tools to your assistant

Tools with a description: 48 of 48
Say if they change things: 48 of 48
Context it takes, at least: ~10,200 tokens

Every tool says whether it only reads or can change things, so a client can ask before the risky ones. The tool list is large: switch off the tools you do not use if your client allows it.

From the tool list it sent us. The token figure counts names, descriptions and input names; the full schemas your client loads add more.

Set it up

In Unity, open Package Manager, choose Add package from git URL and paste https://github.com/CoplayDev/unity-mcp.git?path=/MCPForUnity#main
Open Window → MCP for Unity and click Configure All Detected Clients, or paste the config below into your client yourself.
Keep the Unity Editor open while you work: the server talks to the bridge inside it.

Pick your app for the exact snippet and where it goes.

Where it goes: claude_desktop_config.json (Settings → Developer → Edit Config)

Claude Desktop

{
  "mcpServers": {
    "unity-mcp": {
      "command": "uvx",
      "args": [
        "--from",
        "mcpforunityserver",
        "mcp-for-unity",
        "--transport",
        "stdio"
      ]
    }
  }
}

Where it goes: Your terminal, in the project folder

Claude Code

claude mcp add-json unity-mcp '{"command":"uvx","args":["--from","mcpforunityserver","mcp-for-unity","--transport","stdio"]}'

Where it goes: ~/.cursor/mcp.json, or .cursor/mcp.json in a project

Cursor

{
  "mcpServers": {
    "unity-mcp": {
      "command": "uvx",
      "args": [
        "--from",
        "mcpforunityserver",
        "mcp-for-unity",
        "--transport",
        "stdio"
      ]
    }
  }
}

Where it goes: .vscode/mcp.json in your project

VS Code

{
  "servers": {
    "unity-mcp": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "--from",
        "mcpforunityserver",
        "mcp-for-unity",
        "--transport",
        "stdio"
      ]
    }
  }
}

Where it goes: ~/.codeium/windsurf/mcp_config.json

Windsurf

{
  "mcpServers": {
    "unity-mcp": {
      "command": "uvx",
      "args": [
        "--from",
        "mcpforunityserver",
        "mcp-for-unity",
        "--transport",
        "stdio"
      ]
    }
  }
}

New to this? See the setup guides for Claude Code, Cursor, Claude Desktop and ChatGPT.

Settings

Names are exactly as the project spells them. Required ones are marked.

Setting	What it does
`--transport`Command line flag · required	stdio for clients that start the server themselves, or http to run it on a port that clients connect to by URL.`--transport stdio`
`--http-url`Command line flag	Where the HTTP server listens when you use --transport http. Clients then connect to the same address with /mcp on the end.`--http-url http://localhost:8080`
`Window → MCP for Unity`Config	The Editor window that shows the bridge status, writes client configs (Configure All Detected Clients) and holds the API keys for the generation tools.
`Tool groups`Config	Optional sets of tools (VFX, animation, UI, testing and others) you can switch on and off, so the model only sees what the project needs.

What it can touch

It can read

Scenes, GameObjects, assets and scripts in the open Unity project
The Unity console and test results
Unity's documentation and API

It can change

Scenes, prefabs, materials and other assets
C# scripts it creates, edits or deletes
Project and Editor settings, packages and builds
Whatever C# it runs through execute_code

Safer setup: Keep the project in version control and commit before a session, so every change shows up as a diff you can revert. Leave execute_code out of reach unless you need it.

Before you start

Unity 2021.3 LTS or newer, with the MCP for Unity package added
Python 3.10 or newer and uv (for uvx)

If it does not work

The client lists the tools but every call fails: The Unity Editor has to be open with the MCP for Unity package installed. Check the bridge status in Window → MCP for Unity.
uvx is not found when the client starts the server: Install uv, then use the full path to uvx in the config, since desktop apps often do not see your shell's PATH.
Changes go to the wrong Unity project: With more than one Editor open, ask the model to call set_active_instance with the project you mean.
Scripts are edited but nothing changes in the Editor: Ask it to call refresh_unity and wait for compilation, then check read_console for compile errors.

Peas in a pod: similar servers

How MCP for Unity lines up against other design, 3d and games servers on the shelf.

Server	Tools	Runs on	Licence	Stars
MCP for Unity	48	Your computer	MIT	15.4K
draw.io MCP	8	Your computer or hosted	Apache-2.0	5.7K
AntV Chart MCP	27	Your computer	MIT	4.4K
DaVinci Resolve MCP	37	Your computer	MIT	3.8K
FreeCAD MCP	17	Your computer	MIT	3.1K