patina-unity-mcp

# Patina

[![npm version](https://img.shields.io/npm/v/com.taygunsavas.patina-unity-mcp.svg)](https://www.npmjs.com/package/com.taygunsavas.patina-unity-mcp)
[![MCP Registry](https://img.shields.io/badge/MCP%20Registry-io.github.taygunsavas%2Fpatina--unity--mcp-blue)](https://registry.modelcontextprotocol.io/v0.1/servers?search=io.github.taygunsavas/patina-unity-mcp)
[![Glama MCP server](https://glama.ai/mcp/servers/taygunsavas/patina-unity-mcp/badges/score.svg)](https://glama.ai/mcp/servers/taygunsavas/patina-unity-mcp)
[![Indexed on TensorBlock MCP Index](https://mcp-index.tensorblock.co/v1/servers/github-taygunsavas-patina-unity-mcp-8c8f04b5/badge.svg)](https://tensorblock.co/mcp/servers/github-taygunsavas-patina-unity-mcp-8c8f04b5)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)

Control the Unity Editor from any MCP host. One package install, one click, and your AI assistant can see your scene, create objects, and talk to the console.

Patina is a Rust MCP server paired with a C# Unity bridge. It connects your favorite AI coding tool directly to the Unity Editor over a local TCP channel, with zero manual config.

## Why Patina?

- **One-click setup.** Install the UPM package, click a button, and every supported host is configured automatically.
- **No Rust required.** Release packages ship pre-built binaries for Windows, Linux, and macOS. Just install and go.
- **Built for speed.** The Rust sidecar keeps the MCP layer fast and lightweight while Unity stays on the main thread.
- **Multi-host.** Works with Claude Code, Cursor, VS Code, Gemini CLI, JetBrains Rider, Codex CLI, and more.

## How It Works

```
MCP Host  <-- stdio -->  Patina Server  <-- local TCP -->  Unity Editor
```

The host launches the Rust binary over stdio MCP. The Rust server forwards tool calls into Unity through a local loopback TCP bridge. Unity executes them on the main thread and returns the result.

## Quick Start

### 1. Install the Unity package
In Unity, open **Project Settings > Package Manager**, add a scoped registry, then install the package by name.

Scoped registry:

| Field | Value |
|------|-------|
| Name | `npmjs` |
| URL | `https://registry.npmjs.org` |
| Scope(s) | `com.taygunsavas` |

Then open the **Package Manager** (Window > Package Manager), click the **+** icon in the top left, select **Add package by name...**, and enter:

```text
com.taygunsavas.patina-unity-mcp
```

Registry releases are signed during the release workflow for Unity Package Manager verification.

Alternatively, open the **Package Manager**, click the **+** icon, select **Add package from git URL...**, and enter:

```text
https://github.com/taygunsavas/patina-unity-mcp.git?path=/unity-package
```

Patina is distributed as a complete Unity package artifact with the editor code, native Rust runtime binaries under `Plugins/<platform>/`, and the Unity metadata needed for import. End users do not need the Rust toolchain or a Git checkout of this repository.

### 2. Run One-Click Setup
Open **Window > Patina Unity MCP** and click **One-Click Setup**.

The setup flow verifies the binary, starts the Unity bridge, auto-configures every detected host, replaces stale entries, and shows restart guidance where needed.

Patina writes host configs to a stable user-level runtime path instead of a per-project Unity package cache path. When the package is updated, the Unity editor package refreshes that managed runtime automatically, so supported MCP hosts do not need to be reconfigured just because the package cache path changed.

### 3. Start building
Open your MCP host and try:
- *"Log hello to Unity console"*
- *"Show me the scene hierarchy"*
- *"Create a cube at position 0, 2, 0"*

## Available Capabilities

Patina keeps the advertised MCP surface compact so hosts do not need to load every Unity command schema into context. Agents should use:

| MCP tool | What it does |
|------|-------------|
| `patina_capabilities` | Search or browse the Unity command catalog; request schemas only for specific commands |
| `patina_call` | Execute a catalog command with JSON parameters |
| `patina_health` | Inspect Patina version, command count, bridge port, optional Unity editor state, and bridge diagnostics |

The 87 commands below are available through `patina_capabilities` and `patina_call`.

### Scene

| Tool | What it does |
|------|-------------|
| `get_hierarchy` | Retrieve the active scene's GameObject tree as nested JSON; supports `max_depth` and `name_filter` |
| `get_scene_info` | Active scene metadata (name, path, build index, root count, dirty state); pass `include_all_scenes` for all loaded scenes |
| `open_scene` | Open a scene by project-relative path; `mode` single (default) or additive |
| `save_scene` | Save the active scene or any loaded scene; supports Save As |
| `new_scene` | Create and save a new scene with optional empty or default-game-objects setup |

### GameObjects

| Tool | What it does |
|------|-------------|
| `create_game_object` | Spawn an empty GameObject or a built-in primitive (Cube, Sphere, Capsule, Cylinder, Plane, Quad) |
| `delete_game_object` | Permanently delete a GameObject and all its children |
| `duplicate_game_object` | Duplicate a GameObject and its children |
| `reparent_game_object` | Move a GameObject under a new parent; pass `null` to promote to scene root |
| `get_game_object_info` | Full details for a named GameObject: transform, tag, layer, and all component properties |
| `set_active_state` | Show or hide a GameObject via `SetActive()` |
| `set_tag` | Set the tag on a GameObject (tag must be registered in Tags & Layers) |
| `set_layer` | Set the layer by name; optionally apply to all children |
| `set_transform` | Set position, rotation (Euler), and/or scale in world or local space in one call |

### Components & Properties

| Tool | What it does |
|------|-------------|
| `add_component` | Add a component by short name (`Rigidbody`) or fully qualified name |
| `remove_component` | Remove a component by type name |
| `set_property` | Set a public field, a public writable property or a `[SerializeField]` field (including inherited ones) on a component by name |
| `get_game_object_components` | Return a lightweight component list for a GameObject |

### Batch Operations

| Tool | What it does |
|------|-------------|
| `batch_set_properties` | Apply `set_property` style changes (public members or `[SerializeField]` fields) across multiple GameObjects |
| `batch_add_components` | Add components to multiple GameObjects |
| `batch_set_transform` | Apply transform changes to multiple GameObjects |

### Prefabs

| Tool | What it does |
|------|-------------|
| `create_prefab` | Save a scene GameObject as a prefab asset |
| `instantiate_prefab` | Instantiate a prefab into the scene at an optional world position |
| `get_prefab_info` | Inspect a prefab asset or scene instance; returns asset type, overrides list, and instance status |
| `unpack_prefab` | Sever a prefab instance link; `outermost` (default) or `completely` |
| `apply_prefab_overrides` | Apply all instance overrides back to the source prefab asset on disk |
| `revert_prefab_overrides` | Restore a prefab instance to match its source asset |
| `list_prefab_components` | List component types and instance IDs on a prefab asset; optionally includes child GameObjects with transform paths |
| `edit_prefab_asset` | Perform a batch of edit operations (add/remove component, add/remove child, set field) on a prefab asset, including object-reference fields and GameObject-level `layer`, `tag`, `isStatic`, `name` and `activeSelf`; after saving, runs `OnValidate` on touched components and saves again |
| `open_prefab_stage` | Open a prefab asset in Unity's prefab stage for editing; exit using `close_prefab_stage` |
| `close_prefab_stage` | Close the active prefab stage; `save_changes` parameter resolves dirty stages without Unity's blocking save prompt, giving save or discard decision |

After saving and reimporting, `edit_prefab_asset` runs `OnValidate` by reflection on the saved asset for every component of each type touched by `add_component` or `set_field` on the touched GameObject, then saves again, so state computed there (such as Netcode `NetworkObject` hashes) is persisted. If an `OnValidate` throws, the command still succeeds and the result gains a `warnings` string array listing components whose OnValidate was skipped or threw, including when the saved prefab cannot be loaded or a tracked path or component cannot be resolved.

**Example: Set GameObject-level values.**

`set_field` targets the GameObject itself when `component_type` is omitted, `"GameObject"` or `"UnityEngine.GameObject"`. Supported `field_name` values are `layer` (index 0-31 or layer name), `tag`, `isStatic`, `name` and `activeSelf` (the prefab root name follows the asset file name, so `name` on the root is rejected). `add_child` also accepts optional `layer`, `tag` and `is_static`:

```json
{
  "asset_path": "Assets/Prefabs/MyPrefab.prefab",
  "actions": [
    {"action_type": "add_child", "child_name": "Wall0", "layer": "Water", "tag": "Player", "is_static": true},
    {"action_type": "set_field", "transform_path": "Wall0", "component_type": "UnityEngine.GameObject", "field_name": "layer", "value": 5}
  ]
}
```

**Example: Set a component reference within a prefab.**

To point a serialized field at another component inside the same prefab, pass an `edit_prefab_asset` action with `set_field` and an object reference value. The `transform_path` inside `value` is resolved against the prefab root, not against the action's own `transform_path`:

```json
{
  "asset_path": "Assets/Prefabs/MyPrefab.prefab",
  "actions": [
    {
      "action_type": "set_field",
      "component_type": "MyNamespace.MyComponent",
      "field_name": "targetReference",
      "value": {"transform_path": "Container/Button", "component_type": "MyNamespace.TargetComponent"}
    }
  ]
}
```

### A