Skip to main content
Glama
Sign In
Unity MCP Claude Code

Unity MCP Claude Code

by MauricePutinas
OverviewSchemaSourceRelated ServersDiscussionsAdmin
Python
Local

Unity MCP Claude Code

Ein professioneller MCP-Server, mit dem Claude Unity Hub + den Unity-Editor real bedient — und damit komplette Spiele headless baut, eigene Premium-2D/3D-Assets erzeugt und hochwertige PBR-Texturen erstellt.

License: MIT Platform Python Tools MCP Tested

Dieser Server gibt Claude (Claude Code und Claude Desktop) echte Hände in Unity: nicht nur über Unity reden, sondern Editoren installieren, Projekte anlegen, Code schreiben, ganze Szenen aus einer Beschreibung bauen, Assets selbst erzeugen, Tests laufen lassen, profilen und am Ende eine fertige .exe produzieren — alles automatisiert über die jeweils stabilste Schnittstelle.

Entwickelt und live verifiziert gegen Unity Hub 3.18 + Unity-Editor 6000.4.10f1 (Unity 6) auf Windows 11.

Inhalt

Related MCP server: UniMCP4CC

Highlights

  • 🎮 Komplette Spiele headless bauen — von C#-Gameplay über eine aus JSON gebaute Szene bis zur fertigen .exe, ohne den Editor manuell anzufassen.

  • 🧱 Profi-Szenen aus JSON — GameObjects, URP-Materialien mit vollem PBR (BaseColor + Normal + AO + Metallic/Mask), Physik, beliebige Komponenten-Properties (inkl. Objekt-/Asset-Referenzen), Prefabs, Environment und Post-Processing (Bloom/Vignette/Tonemapping …).

  • 🎨 Assets selbst erzeugen — Blender headless (Mesh/Material/Bake/Export GLB+FBX, CYCLES-Render), free-tex-packer (Sprite-Atlanten), Figma-REST (UI → PNG/SVG), Krita (.kra → PNG).

  • 🪨 Premium-PBR-Texturen — CC0-Bibliotheken ambientCG & Poly Haven (gescannt, 1K–8K) plus prozedurale Blender-Bakes — automatisch korrekt in URP verdrahtet.

  • 🤖 Animation — Animator-Controller, prozedurale Clips, Clip-Namen aus FBX (z.B. Mixamo/KayKit).

  • 🔍 Visuelle QA & Profiling — Szene → PNG (Claude sieht das Ergebnis), Compiler-Fehler strukturiert, Laufzeit-FPS/Speicher/GC.

  • 🖱️ GUI-Automation — echte Klicks/Tastatur + UIA-Inspektion für GUI-only-Flows des Electron-Hubs.

  • 🛡️ Sicher by Design — Confirm-Gates, Pfad-Sandbox, Auto-Backups, redigiertes Audit-Log, Schutz sensibler Hub-Dateien.

Was kann Claude damit? (104 Tools)

Vollständiger Katalog mit Parametern: docs/TOOLS.md. Überblick nach Bereich:

#

Bereich

Tools

Beispiele

1

Status & Prozesse

6

get_environment_status, launch_hub, stop_editor

2

Editoren & Installation

9

install_editor, list_installed_editors, resolve_editor_changeset

3

Projekte

8

create_project, open_project, register_project_in_hub

4

Editor-Automation

9

build_player, run_tests, check_compile, run_editor_method

5

Pakete (manifest.json)

3

add_project_package, remove_project_package

6

Hub-Einstellungen

4

get_hub_settings, set_default_project_dir

7

Logs, Jobs & Diagnose

8

read_editor_log, get_job_status, detect_errors_in_log

8

Lizenz (sicher)

3

get_license_status, create_manual_activation_file

9

Deep-Links / GUI-Brücke

4

open_create_project_ui, screenshot_desktop

10

Backups & Sicherheit

2

list_backups, restore_backup

11

Game-Authoring

19

write_script, build_scene, capture_scene_render, profile_play, build_animator_controller

12

GUI-Automation

6

gui_click, gui_inspect_window, gui_send_keys

13

Asset-Erstellung — Blender

4

blender_run_python, blender_render_preview, blender_bake_pbr

14

2D-Atlas (free-tex-packer)

1

pack_sprite_atlas

15

Figma-UI-Export

2

figma_export_images, figma_get_outline

16

Krita

2

krita_export, krita_open

17

Premium-PBR-Texturen

4

download_pbr_material, download_polyhaven_texture

18

Vision & Verify (neu)

10

dump_scene, inspect_gameobject, get_ui_layout, assert_scene, play_and_capture, render_scene_multi, render_animation_strip, run_play_scenario, read_image, visual_diff

Vision & Verify — sehen, verstehen, prüfen

Damit Claude nicht „blind" baut, sondern das Ergebnis wirklich wahrnimmt und belegt:

  • Sehen: play_and_capture nimmt echte Gameplay-Frames im PlayMode auf (Bewegung/Physik sichtbar, nicht nur ein Standbild); render_scene_multi rendert die Szene aus N Winkeln (Turntable) oder als Wireframe (deckt Lücken/Z-Fighting auf); render_animation_strip zeigt einen Clip als Posen-Serie; read_image gibt Renders als echtes MCP-Bild direkt ins Tool-Ergebnis.

  • Verstehen: dump_scene / inspect_gameobject lesen die gebaute Szene als strukturiertes JSON zurück (Hierarchie, Komponenten, Property-Werte); get_ui_layout liest Canvas/RectTransforms — Soll/Ist statt Vermutung.

  • Prüfen: assert_scene wertet Regeln gegen das Dump aus (z. B. „Player hat Rigidbody", „Kamera folgt Player"); run_play_scenario misst den Laufzeit-Zustand im PlayMode (Bewegung + [MCP_EVENT]-Logs); visual_diff fängt visuelle Regressionen (Baseline-Vergleich + Heatmap).

Der Server ist zudem gegen die offizielle MCP-Conformance-Suite geprüft (spec-konform in allem, was er implementiert; alle Tool-Schemas gültig).

„Game from scratch" in einer Pipeline

create_project                # leeres Unity-Projekt
  └─ write_script             # C#-Gameplay (MonoBehaviours) nach Assets/
       └─ build_scene         # Welt + Komponenten + Material/Physik aus JSON
            └─ check_compile   # Fehler strukturiert prüfen → ggf. write_script (Auto-Fix)
                 └─ capture_scene_render   # Szene → PNG: Claude prüft das Bild
                      └─ build_player      # fertige .exe

build_scene ist das Herzstück: eine JSON-Spezifikation beschreibt die ganze Szene und wird über ein injiziertes C#-Editor-Skript in eine echte .unity umgesetzt — inklusive URP-/PBR-Materialien, Rigidbody/PhysicsMaterial, generischem Property-Setter (Field → Property → SerializedObject) mit Objekt-/Asset-Referenzen, Prefabs, Environment/Fog/Ambient und Post-Processing-Volumes.

Bewiesen baubar (Demos in scripts/): mehrere spielbare 3D-Games headless inkl. Physik, WASD-Steuerung, Score, Bloom-HUD und animierten Charakteren.

Premium-Grafik selbst erzeugen

Das Kohärenz-Prinzip: eine Quelle = einheitlicher Look. Der Server kann hochwertige Assets holen, selbst erzeugen und korrekt verbauen:

Bedarf

Tool(s)

Quelle

3D-Meshes/Materialien

blender_run_python

Blender (bpy, headless) → GLB/FBX

3D-Vorschau prüfen

blender_render_preview

Blender CYCLES → PNG

PBR-Texturen (gescannt)

search_pbr_materials / download_pbr_material

ambientCG (CC0, 1K–8K)

PBR-Texturen (gescannt)

search_polyhaven_textures / download_polyhaven_texture

Poly Haven (CC0)

PBR-Texturen (prozedural)

blender_bake_pbr

Blender-Bake (brick/rock/wood/metal)

Sprite-Atlas (2D)

pack_sprite_atlas

free-tex-packer

Game-UI

figma_export_images

Figma REST (PNG/SVG)

2D-Hand-Polish

krita_open / krita_export

Krita

Heruntergeladene/gebackene Maps werden in build_scene automatisch korrekt behandelt: die Normal-Map als NormalMap importiert (_NORMALMAP + _BumpMap/_BumpScale), AO/Mask linear (_OcclusionMap / _MetallicGlossMap). Ergebnis: echtes Relief und Tiefe statt flach aufgeklebter Textur — premium Look ohne Handarbeit.

Voraussetzung für die Asset-Tools sind die jeweiligen Programme (Blender, Krita) bzw. ein FIGMA_TOKEN. Fehlt ein Programm, melden die Tools das sauber; der Unity-Kern funktioniert ohne sie.

Steuerungsstrategie

Es gibt keine allmächtige Unity-API. Stattdessen nutzt der Server einen Hybrid aus den jeweils stabilsten Mechanismen — jeder durch direkte Messung bestätigt:

Schicht

Wofür

Stabilität

Unity-Hub-CLI (Unity Hub.exe -- --headless …)

Editoren/Module installieren, auflisten, Install-Pfad

hoch

Unity-Editor-CLI (Unity.exe -batchmode … -executeMethod)

Projekt erstellen/öffnen, Build, Tests, Szenenbau

hoch

Datei-/JSON-Schicht

projects-v1.json, user-settings.json, manifest.json, ProjectVersion.txt

hoch

Log-Schicht

Editor.log, Hub-Logs, NUnit-XML, [MCP_RESULT]-Marker

hoch

Release-API

Version → Changeset + Deep-Link

hoch (online)

GUI-Automation / Deep-Links / Screenshot

GUI-only-Flows (Login, Serial-Aktivierung)

best-effort

Blender / free-tex-packer / Figma / Krita

Asset-Erstellung headless

hoch (sofern installiert)

Im Code berücksichtigte Besonderheiten (Auszug):

  • Unity Hub ist ein GUI-Subsystem-Electron-Binary → Ausgabe nur über echte Pipes; harmloses Chromium-/GPU-stderr-Rauschen wird gefiltert.

  • Unity-6-Batchmode-Regression: statt EditorApplication.Exit() nur Environment.ExitCode + -quit, Ergebnis primär aus einer Result-Datei + Watchdog (sonst Zombie-Editor).

  • Unity-6-Renames werden beachtet (Rigidbody.drag → linearDamping, PhysicMaterial → PhysicsMaterial, URP-_BaseColor/_Smoothness, FindObjectsByType).

  • EEVEE rendert headless unter Windows nicht → Blender-Render/-Bake nutzen CYCLES.

Mehr Detail: docs/ARCHITECTURE.md.

Installation

Voraussetzungen

  • Windows 10/11

  • Unity Hub (Standard: C:\Program Files\Unity Hub\Unity Hub.exe)

  • Mindestens ein Unity-Editor über den Hub installiert

  • uv (empfohlen) oder Python ≥ 3.10

  • Optional für Asset-Tools: Blender, Krita, ein Figma-Account (Token)

Schnellstart

git clone https://github.com/MauricePutinas/Unity-MCP-Claude-Code.git
cd Unity-MCP-Claude-Code

uv sync                               # erstellt .venv + installiert Abhängigkeiten
uv run python scripts\test_smoke.py   # Funktionstest → "SMOKE TEST OK"

Optionale Konfiguration: config.example.json → config.json kopieren und allowed_roots anpassen. Ohne Datei wird alles automatisch erkannt; Schreibzugriffe sind dann auf Default-Projektordner, Hub-AppData und Server-Datenbereich beschränkt. Ausführlich: docs/INSTALL.md.

Claude-Integration

Claude Desktop — 1-Klick-Erweiterung (empfohlen)

Fertiges Bundle: dist/unity-hub-mcp.mcpb. Claude Desktop → Einstellungen → Erweiterungen → „Erweiterung installieren" → .mcpb auswählen → „Erlaubte Projekt-Ordner" setzen (leer = Auto-Erkennung) → aktivieren. uv muss im PATH sein.

Bundle neu bauen:

npx -y @anthropic-ai/mcpb@latest pack dist\mcpb dist\unity-hub-mcp.mcpb

Claude Code (CLI/IDE)

claude mcp add --scope user --transport stdio unity-control -- uv --directory "C:\Pfad\zu\Unity-MCP-Claude-Code" run python -m unity_hub_mcp

oder projektweit eine .mcp.json aus claude_code.mcp.example.json. Prüfen mit claude mcp list bzw. /mcp in der Session.

Claude Desktop (manuell)

%APPDATA%\Claude\claude_desktop_config.json aus claude_desktop_config.example.json befüllen und Claude Desktop komplett neu starten.

Sicherheit

  • Confirm-Gates: verändernde/zerstörende Tools verlangen confirm=true; ohne Bestätigung gibt es nur eine Vorschau (Dry-Run-Charakter).

  • Pfad-Sandbox: Datei-Schreib-/Lösch-Tools wirken nur innerhalb erlaubter Roots (allowed_roots), Traversal (..) wird geblockt.

  • Auto-Backups: vor JSON-/Asset-Änderungen (list_backups / restore_backup).

  • Audit-Log: jede Aktion wird redigiert nach actions.jsonl geschrieben — Parameter und Ergebnisse laufen durch eine Redaktion (Token/Secrets/License-Entitlements werden ausgeblendet).

  • Sensible Hub-Dateien (encryptedTokens.json, userInfoKey.json, Local State, Preferences) werden von den Lese-Pfaden aktiv verweigert — nie ausgegeben oder geloggt.

  • Keine Secrets im Code: ein FIGMA_TOKEN kommt nur aus der Umgebung/Parametern, nichts wird hartkodiert oder persistiert.

Ehrliche Hinweise für mächtige Tools: run_editor_method und blender_run_python führen bewusst beliebigen Code aus (das ist ihr Zweck). Einige Hub-/Lizenz-/Restore-Schreib-Tools (z.B. set_default_project_dir, apply_license_file, restore_backup, import_external_asset) sind durch confirm=true gesichert, greifen aber außerhalb der allowed_roots-Sandbox. Den Server nur in einer vertrauenswürdigen lokalen Umgebung betreiben.

Projektstruktur

unity_hub_mcp/        # der MCP-Server (Tool-Registry in server.py)
  ├─ core.py          # Prozess-Runner, Logging/Redaktion, Backups, Pfad-Sicherheit
  ├─ settings.py      # Pfad-Auflösung (Env → config.json → Auto-Detect)
  ├─ csharp_templates.py  # injiziertes C#-Automationsskript (Szenenbau etc.)
  ├─ scene_builder.py / authoring.py / editor_cli.py / hub_cli.py / projects.py …
  ├─ blender.py / texpacker.py / figma.py / krita.py / textures.py   # Asset-Erstellung
  └─ gui.py / process.py / logs.py / releases.py / deeplinks.py
scripts/              # Smoke-/Live-Tests + Demo-Pipelines
docs/                 # TOOLS.md · ARCHITECTURE.md · INSTALL.md
dist/                 # mcpb/manifest.json + gebautes unity-hub-mcp.mcpb

Entwicklung & Tests

uv sync
uv run python scripts\test_smoke.py        # datei-basiert, schnell  → "SMOKE TEST OK"
uv run python scripts\test_live.py         # Hub-CLI + Release-API (read-only)
uv run python scripts\demo_make_game.py    # baut ein komplettes Mini-Game → .exe

Der Server loggt ausschließlich nach stderr (stdout ist dem MCP-Protokoll vorbehalten). Eigene Logs und das Audit-Log liegen unter %LOCALAPPDATA%\unity-hub-mcp\.

Lizenz

MIT © 2026 Maurice Putinas

Unity, Unity Hub und das Unity-Logo sind Marken von Unity Technologies. Dieses Projekt ist ein unabhängiges Automationswerkzeug und steht in keiner Verbindung zu Unity Technologies.

Available Tools

94 tools
add_existing_editorB

Bindet einen außerhalb des Hubs installierten Editor ein (Hub-CLI 'editors --add'). confirm=true.

Inputs: editor_path (required), confirm.

add_project_packageA

Fügt ein Paket zu Packages/manifest.json hinzu/ändert die Version (Backup wird erstellt). version kann SemVer, git-URL oder 'file:'-Pfad sein. confirm=true nötig.

Inputs: project_path (required), name (required), version (required), confirm.

analyze_scene_performanceA

Statische Performance-Analyse einer Szene (Job): Dreiecke/Vertices, Mesh-/Renderer-Anzahl, eindeutige Materialien (Draw-Call-Proxy), Lichter/Echtzeitlichter. Ergebnis via get_build_result(result_file) — liefert Budget-Daten zum Optimieren ohne Play-Modus.

Inputs: project_path (required), scene_path, version.

apply_license_fileB

Wendet eine heruntergeladene .ulf-Lizenzdatei an (manuelle Aktivierung, Schritt 3). confirm=true.

Inputs: ulf_path (required), version, confirm.

blender_bake_pbrA

Erzeugt prozedural einen tileable PBR-Textursatz (baseColor/normal/roughness/ao) via Blender-CYCLES-Bake — eigene Premium-Texturen ohne Download, für Dinge, die keine CC0-Bibliothek hat. preset: 'brick' | 'rock' | 'wood' | 'metal'. resolution z.B. 512/1024/2048. Danach in Unity via build_scene material (mainTexture=baseColor, normalMap=normal, occlusionMap=ao) verbaubar.

Inputs: preset (required), out_dir (required), resolution.

blender_render_previewA

Rendert eine Vorschau-PNG eines 3D-Modells (GLB/FBX/OBJ) headless in Blender (CYCLES) — damit Claude generierte/importierte 3D-Assets per Bild prüfen kann.

Inputs: model_path (required), output_png (required), width, height.

blender_run_pythonA

Führt ein bpy-Python-Skript headless in Blender aus → eigene 3D-Assets erzeugen (Mesh/Material/UV/Bake/Export GLB+FBX/Render) für Unity. Das mächtige Primitiv der 3D-Erstellung.

Im Skript verfügbar: mcp_args() (Argumente nach '--') und mcp_result(dict) (Ergebnis-JSON). Exportiere für Unity nach Assets/ (dann import_external_asset/build_scene). Beispiel-Skriptkern: import bpy bpy.ops.mesh.primitive_cube_add(size=2) ob = bpy.context.active_object bpy.ops.export_scene.gltf(filepath=mcp_args()[0], export_format='GLB', use_selection=True) mcp_result({"ok": True, "out": mcp_args()[0]})

Inputs: script (required), args, timeout.

blender_statusA
Read-only

Prüft, ob Blender (headless) verfügbar ist (Version, Python, glTF/FBX-Export).

Inputs: no named parameters.

build_animator_controllerA

Baut einen Animator-Controller (.controller, Job) mit States, Parametern und Transitions — macht Charaktere animiert (Idle/Run/Jump). Clips referenzieren via '.anim'-Pfad oder 'Pfad.fbx::ClipName'. Danach den Controller per build_scene an einen Animator hängen: components:["Animator"], props:[{"component":"Animator","name":"runtimeAnimatorController", "asset":"Assets/Animators/Player.controller"}]. spec = {"path":"...","parameters":[{"name":"Speed","type":"Float"}],"defaultState":"Idle", "states":[{"name":"Idle","clip":"..."},{"name":"Run","clip":"..."}], "transitions":[{"from":"Idle","to":"Run","conditions":[{"param":"Speed","mode":"Greater","threshold":0.1}]}]} Parameter-Typen: Float/Int/Bool/Trigger. Condition-Modi: Greater/Less/If/IfNot/Equals/NotEqual.

Inputs: project_path (required), spec (required).

build_playerB

Baut einen Player (BuildPipeline.BuildPlayer via injiziertem C#) als Hintergrund-Job. build_target z.B.: win64, StandaloneWindows64, android, webgl, ios, linux64, osxuniversal. scenes optional (sonst aktivierte Build-Settings-Szenen). Ergebnis nach Jobende aus result_file lesen (get_build_result). confirm=true nötig.

Inputs: project_path (required), build_target (required), output_path (required), scenes, +3 more.

build_sceneA

Baut aus einer JSON-Spezifikation eine echte .unity-Szene (via injiziertes C#), als Job.

spec = { "scenePath": "Assets/Scenes/Game.unity", "addToBuildSettings": true, "gameObjects": [ {"name":"Main Camera","camera":true,"position":[0,1,-10]}, {"name":"Sun","light":{"type":"Directional","intensity":1.0},"rotation":[50,-30,0]}, {"name":"Floor","primitive":"Plane","scale":[5,1,5]}, {"name":"Player","primitive":"Capsule","position":[0,1,0],"tag":"Player", "components":["Rigidbody","PlayerController"]} ] } components dürfen eingebaute Typen (Rigidbody, BoxCollider …) ODER eigene MonoBehaviour- Klassennamen sein (vorher per write_script anlegen).

PROFI-Features pro gameObject (optional): "material": {"color":[r,g,b],"metallic":0.0,"smoothness":0.6,"emission":[r,g,b],"emissionIntensity":2.0, "mainTexture":"Assets/.../baseColor.png","normalMap":"Assets/.../normal.png", "occlusionMap":"Assets/.../ao.png","metallicGlossMap":"Assets/.../mask.png","normalScale":1.0} (URP-aware, wird als .mat gespeichert+zugewiesen; PBR-Maps automatisch korrekt importiert: normalMap→NormalMap+_NORMALMAP, ao/mask→linear. Maps z.B. via download_pbr_material / download_polyhaven_texture holen = Premium-Look) "physicMaterial": {"bounciness":0.8,"dynamicFriction":0.3,"staticFriction":0.4} "props": Komponenten-Properties setzen (Werte/Referenzen/Assets/Enums/Vektoren/Farben), z.B. {"component":"Rigidbody","name":"mass","value":2.0} {"component":"Rigidbody","name":"linearDamping","value":0.5} # Unity-6-Name (alt: drag) {"component":"Rigidbody","name":"constraints","enum":"FreezeRotationX|FreezeRotationZ"} {"component":"CameraFollow","name":"target","ref":"Player"} # Referenz auf Scene-Objekt {"component":"AudioSource","name":"clip","asset":"Assets/Audio/x.wav"} {"component":"Light","name":"color","color":[1,0.9,0.7]} "prefab": "Assets/Prefabs/X.prefab" # statt primitive eine Prefab-Instanz erzeugen "isStatic": true, "tag":"Player", "layer":8, "parent":"OtherObjectName" Top-Level optional: "environment": {"ambientMode":"Trilight","ambient":[r,g,b],"skyboxMaterial":"Assets/...","fog":true,"fogColor":[..],"fogDensity":0.01} "postProcessing": {"bloom":{"intensity":1.2,"threshold":0.9,"scatter":0.7}, "colorAdjustments":{"postExposure":0.2,"contrast":10,"saturation":15}, "vignette":{"intensity":0.3},"tonemapping":{"mode":"ACES"}, "antialiasing":"SubpixelMorphologicalAntiAliasing"} (URP; Bloom braucht emissive/HDR-Quellen) "saveAsPrefabs": [{"object":"Enemy","path":"Assets/Prefabs/Enemy.prefab"}] Ergebnis via get_build_result(result_file).

Inputs: project_path (required), spec (required).

capture_scene_renderB

Rendert die Kamera einer Szene headless in eine PNG (Job) — für visuelle Prüfung: Claude kann die PNG anschließend per Bild-Werkzeug ansehen und Shader-/Clipping-/Layout-Fehler erkennen. Läuft bewusst OHNE -nographics (mit -force-d3d11), sonst schwarzes Bild. Nach Jobende output_png mit dem Read-/Bildwerkzeug öffnen.

Inputs: project_path (required), scene_path (required), output_png (required), width, +2 more.

check_compileA

Kompiliert alle Skripte des Projekts headless (öffnet+quittiert den Editor), als Job. Danach get_compile_result(log_file) für strukturierte Compiler-Fehler/Warnungen — funktioniert auch, wenn der Code NICHT kompiliert. Ideal für Schreiben→Prüfen→Auto-Fix-Schleifen.

Inputs: project_path (required), version.

check_hub_runningA
Read-only

Prüft, ob Unity Hub aktuell läuft (Prozessliste).

Inputs: no named parameters.

close_hubA
Destructive

Beendet alle Unity-Hub-Prozesse (NICHT die Editoren). Erfordert confirm=true.

Inputs: confirm.

configure_asset_importB

Setzt Import-Einstellungen eines Assets (Job) und reimportiert. asset_path ist projektrelativ (z.B. 'Assets/Textures/hero.png'). settings_props = Liste von {name, value} oder {name, enum}: Texturen: maxTextureSize(int), textureCompression(enum Uncompressed/Compressed/CompressedHQ/LQ), crunchedCompression(bool), mipmapEnabled(bool), isReadable(bool), textureType(enum) Modelle: globalScale(float), meshCompression(enum Off/Low/Medium/High), materialImportMode(enum), animationType(enum), optimizeMeshPolygons(bool), optimizeMeshVertices(bool) Audio: forceToMono(bool)

Inputs: project_path (required), asset_path (required), settings_props (required).

configure_projectA

Setzt Projekt-Einstellungen (Job): PlayerSettings (productName/companyName/bundleVersion/ Auflösung/fullScreenMode/runInBackground/colorSpace), Quality-Level, sowie eigene Tags und Layer.

config = { "productName":"My Game","companyName":"My Studio","bundleVersion":"1.0.0", "defaultWidth":1920,"defaultHeight":1080,"fullScreenMode":"FullScreenWindow", "runInBackground":true,"colorSpace":"Linear","qualityLevel":5, "tags":["Player","Enemy"],"layers":{"8":"Ground","9":"Interactable"} } Layer-Indizes müssen 8..31 sein (0..7 sind reserviert).

Inputs: project_path (required), config (required).

create_animation_clipA

Erzeugt eine AnimationClip (.anim, Job) aus Keyframe-Kurven — prozedurale Animation ohne externe Assets (z.B. Idle-Bob, Pulsieren, Rotation). spec = {"path":"Assets/Anims/Bob.anim","frameRate":30,"loop":true, "curves":[{"relativePath":"Visual","type":"Transform","property":"localPosition.y", "keys":[{"t":0,"v":0},{"t":0.5,"v":0.25},{"t":1,"v":0}]}]}

Inputs: project_path (required), spec (required).

create_manual_activation_fileB

Erzeugt eine manuelle Aktivierungsdatei (.alf) zum Hochladen auf license.unity3d.com. confirm=true.

Inputs: version, confirm.

create_projectA

Erstellt ein neues, leeres Unity-Projekt (Unity.exe -createProject) als Job. version optional (sonst neuester installierter Editor). confirm=true nötig.

Inputs: project_path (required), version, confirm.

create_project_folderB

Erstellt einen Ordner im Projekt (z.B. 'Assets/Scripts'). Path-Sandbox aktiv.

Inputs: project_path (required), rel_path (required).

create_spriteB

Erzeugt einen prozeduralen Platzhalter-Sprite (PNG → als Sprite importiert, Job) für 2D-Spiele ohne externe Art. shape: 'square' | 'circle'. Danach via build_scene an einen 'SpriteRenderer' hängen (components:['SpriteRenderer'], props:[{component:'SpriteRenderer',name:'sprite',asset:path}]). 2D-Kamera: props {component:'Camera',name:'orthographic',value:true} + 'orthographicSize'. 2D-Physik: Komponenten 'Rigidbody2D' / 'BoxCollider2D' / 'CircleCollider2D'.

Inputs: project_path (required), path (required), width, height, +2 more.

delete_project_assetA
Destructive

Löscht eine Asset-Datei (+ .meta) nach Backup. confirm=true nötig.

Inputs: project_path (required), rel_path (required), confirm.

detect_errors_in_logA
Read-only

Scannt ein Log auf Fehler/Exceptions. source: 'editor' | 'hub' | 'job' (mit job_id).

Inputs: source, job_id, tail_lines.

download_pbr_materialB
Read-only

Lädt ein CC0-PBR-Set von ambientCG (gescannt, kostenlos) und entpackt die Maps (baseColor/normal/roughness/ao/height/metallic). asset_id z.B. 'Bricks075A'; resolution z.B. '1K-PNG','2K-PNG','4K-PNG'. Danach in Unity (build_scene material mainTexture = baseColor, NormalMap importieren) oder Blender verbauen. Premium-Qualität ohne eigene Erstellung.

Inputs: asset_id (required), resolution, dest_dir.

download_polyhaven_textureB
Read-only

Lädt ein CC0-PBR-Set von Poly Haven und klassifiziert die Maps (baseColor/normal(nor_gl)/ roughness/ao/height/metallic/arm). asset_id z.B. 'brick_wall_02'; resolution '1k'/'2k'/'4k'/'8k'; fmt 'png'/'jpg'. Danach in Unity via build_scene material (mainTexture=baseColor, normalMap=normal, occlusionMap=ao) verbaubar — volle PBR-Qualität ohne eigene Erstellung.

Inputs: asset_id (required), resolution, fmt, dest_dir.

export_unitypackageA

Exportiert Assets als .unitypackage (AssetDatabase.ExportPackage via C#), als Job. asset_paths sind projektrelativ (z.B. ['Assets/Prefabs']). confirm=true nötig.

Inputs: project_path (required), asset_paths (required), output_path (required), version, +1 more.

figma_export_imagesA
Read-only

Exportiert Figma-Frames/Components als PNG/SVG (für Game-UI) und lädt sie nach output_dir. node_ids aus der Figma-URL (?node-id=…); '-' wird zu ':' konvertiert. Token via Parameter oder FIGMA_TOKEN. ⚠️ Free-Tier ~6 Calls/Monat → alle Nodes in EINEM Aufruf batchen.

Inputs: file_key (required), node_ids (required), output_dir (required), token, +2 more.

figma_get_outlineA
Read-only

Holt die obere Struktur einer Figma-Datei (Frame-/Node-IDs + Namen finden), sparsam (depth).

Inputs: file_key (required), token, depth.

get_build_resultC
Read-only

Liest das von build/export/info erzeugte Ergebnis-JSON (result_file aus dem jeweiligen Tool).

Inputs: result_file (required).

get_compile_resultA
Read-only

Parst Compiler-Fehler/Warnungen (Datei/Zeile/Spalte/CS-Code/Meldung) aus einem Editor-Log (von check_compile, build_scene, build_player …).

Inputs: log_file (required).

get_default_project_dirA
Read-only

Gibt den Standardordner für neue Projekte zurück (projectDir.json).

Inputs: no named parameters.

get_editor_install_pathA
Read-only

Gibt das aktuelle Editor-Installationsverzeichnis zurück (Hub-CLI 'install-path --get').

Inputs: no named parameters.

get_environment_statusA
Read-only

Vollständiger Umgebungsstatus: Hub-Pfad/-Version, installierte Editoren, neue unity-CLI, Standard-Projektordner, erlaubte Roots, ob Hub/Editor laufen. Idealer Einstiegspunkt.

Inputs: no named parameters.

get_hub_settingsA
Read-only

Liest die Unity-Hub-Einstellungen (user-settings.json): Theme, Tray, Download-Limit, Channel …

Inputs: no named parameters.

get_job_statusB
Read-only

Status eines Hintergrund-Jobs (Install/Build/Test/Import/Export/Methode).

Inputs: job_id (required).

get_license_statusB
Read-only

Best-effort Lizenzstatus über den Unity Licensing Client (read-only).

Inputs: no named parameters.

get_profile_resultB
Read-only

Liest das Profiling-Ergebnis: avgFrameMs, avgFps, maxMemMB, avgGcAllocBytes, maxDrawCalls/ maxSetPass/maxTriangles, renderCountersValid.

Inputs: perf_file (required).

get_project_infoA
Read-only

Liest Projekt-Metadaten aus Dateien (schnell, ohne Editor-Start): Unity-Version, Changeset, productName/companyName/bundleVersion, Paketanzahl, Build-Szenen, Assets-Größe.

Inputs: project_path (required).

get_project_info_liveB

Startet den Editor headless und liest Live-Infos (aktives BuildTarget, Scripting-Defines, aktive Szenen) via injiziertem C#-Skript. Läuft als Job; Ergebnis aus result_file lesen.

Inputs: project_path (required), version.

get_test_resultsA
Read-only

Parst eine NUnit3-Ergebnis-XML (von run_tests) und liefert Pass/Fail-Zahlen + Fehlerdetails.

Inputs: results_xml (required).

gui_clickA

Klickt an Bildschirmkoordinaten (button: left|right|middle). Für den selbst gezeichneten Editor der Fallback; vorher screenshot_desktop zur Orientierung nutzen.

Inputs: x (required), y (required), button, double.

gui_focus_windowB

Bringt ein Fenster in den Vordergrund (Teil-Titel genügt).

Inputs: title (required).

gui_inspect_windowA
Read-only

Listet den UIA-Steuerelementbaum eines Fensters (Buttons/Texte/IDs) — ideal für den Hub.

Inputs: title (required), max_nodes.

gui_list_windowsA
Read-only

Listet sichtbare Top-Level-Fenster (Titel, Klasse, Handle, Position). Filter z.B. 'Unity'.

Inputs: name_filter.

gui_send_keysA

Sendet rohe Tastenfolgen (pywinauto-Syntax), z.B. '^s' = Strg+S, '{ENTER}', '%{F4}'.

Inputs: keys (required).

gui_type_textC

Tippt literalen Text in das fokussierte Fenster.

Inputs: text (required).

import_external_assetA

Kopiert eine externe Datei (Modell/Textur/Audio …) nach dest_rel (unter Assets/) ins Projekt. Unity importiert sie beim nächsten Editor-Lauf; Feintuning danach via configure_asset_import.

Inputs: project_path (required), source_path (required), dest_rel (required).

import_unitypackageB

Importiert ein .unitypackage headless in ein Projekt (Unity.exe -importPackage), als Job. confirm=true nötig (verändert Projekt-Assets).

Inputs: project_path (required), package_path (required), version, confirm.

install_editorA

Installiert einen Unity-Editor (+ optionale Module) als Hintergrund-Job. changeset wird für nicht-gelistete Versionen benötigt (siehe resolve_editor_changeset). Module z.B.: android, ios, webgl, windows-il2cpp, mac-mono, linux-il2cpp, documentation. Fortschritt via get_job_status/read_job_output verfolgen. confirm=true nötig (großer Download).

Inputs: version (required), changeset, modules, child_modules, +1 more.

install_editor_modulesA

Fügt Module zu einem bereits installierten Editor hinzu (Hub-CLI 'install-modules'). Läuft als Hintergrund-Job. confirm=true nötig.

Inputs: version (required), modules (required), child_modules, confirm.

install_editor_via_deeplinkA

Startet die Editor-Installation über einen unityhub://-Deep-Link in der Hub-GUI (Alternative zur headless-Installation; nützlich wenn GUI-Bestätigung gewünscht).

Inputs: version (required), changeset (required).

krita_exportA

Konvertiert eine .kra/.psd/.tiff … in PNG/JPG (Endung von out_path) via Krita.

Inputs: kra_path (required), out_path (required).

krita_openB

Öffnet Krita (GUI) zum Hand-Polieren von 2D-Art; danach als .kra speichern → krita_export.

Inputs: file_path.

launch_hubA

Startet die Unity-Hub-GUI (losgelöster Prozess).

Inputs: no named parameters.

list_animation_clipsB

Listet die AnimationClip-Namen in einem importierten Asset (FBX/.anim, Job) — z.B. um die Clip-Namen eines Mixamo-/Asset-Pack-Charakters für build_animator_controller zu erfahren. Ergebnis via get_build_result(result_file) -> result.clips.

Inputs: project_path (required), asset_path (required).

list_available_releasesA
Read-only

Listet von Unity beworbene installierbare Releases (Hub-CLI, Online — kann dauern).

Inputs: no named parameters.

list_backupsB
Read-only

Listet die vom Server erstellten Datei-Backups (neueste zuerst).

Inputs: limit.

list_installed_editorsA
Read-only

Listet installierte Unity-Editoren (Hub-CLI 'editors --installed').

Inputs: no named parameters.

list_jobsB
Read-only

Listet die letzten Hintergrund-Jobs mit Status.

Inputs: limit.

list_project_assetsC
Read-only

Listet Asset-Dateien eines Projekts (rekursiv, ohne .meta). pattern z.B. '*.cs'.

Inputs: project_path (required), subdir, pattern, limit.

list_project_packagesA
Read-only

Listet die direkten Paket-Abhängigkeiten eines Projekts aus Packages/manifest.json.

Inputs: project_path (required).

list_recent_projectsA
Read-only

Listet die im Hub bekannten Projekte (aus projects-v1.json), nach Datum sortiert.

Inputs: no named parameters.

list_unity_processesA
Read-only

Listet alle laufenden Unity-Prozesse (Hub und Editoren getrennt).

Inputs: no named parameters.

open_create_project_uiA

Öffnet die 'Neues Projekt'-Oberfläche im Hub (Deep-Link).

Inputs: no named parameters.

open_deep_linkC

Öffnet einen beliebigen unityhub://-Deep-Link.

Inputs: link (required).

open_package_install_uiA

Öffnet im aktiven Editor den Package-Manager-Install für ein Paket (Deep-Link), z.B. 'com.unity.cinemachine@2.9.7'.

Inputs: package_and_version (required).

open_projectA

Öffnet ein Projekt in der Editor-GUI. Nutzt die neue unity-CLI ('unity open') falls vorhanden, sonst 'Unity.exe -projectPath' (Editor-Version aus ProjectVersion.txt).

Inputs: project_path (required), version.

pack_sprite_atlasA

Packt alle PNGs eines Ordners (rekursiv) in einen kohärenten Sprite-Atlas (atlas.png + atlas.json/JsonHash, POT, getrimmt) via free-tex-packer-core. Für 2D-Kohärenz

  • weniger Draw Calls. In Unity als Sprite (Multiple) slicen.

Inputs: input_dir (required), output_dir (required), name.

profile_playA

Laufzeit-Profiling SCHRITT 1 (Job): baut einen Development-Player der Szene (inkl. Profiling- Probe). Echte Draw-Call-/Frame-Zeit-Werte gibt es nur im laufenden Player (Headless-Editor liefert 0 Render-Zähler). Liefert exe_path + perf_file. Nach Build-Ende → run_profiled_player, dann get_profile_result.

Inputs: project_path (required), scene_path (required), frames, version.

read_editor_logB
Read-only

Liest die Unity-Editor-Logdatei (Editor.log bzw. Editor-prev.log), letzte tail_lines Zeilen.

Inputs: previous, tail_lines.

read_hub_logsA
Read-only

Liest die Unity-Hub-Logs. which: 'info' (info-log.json) oder 'install' (install-log.json).

Inputs: which, tail_lines.

read_job_outputC
Read-only

Liest die Ausgabe eines Jobs. stream: 'stdout' | 'stderr'.

Inputs: job_id (required), stream, tail_lines.

read_project_fileB
Read-only

Liest eine Projektdatei als Text (z.B. ein Skript oder eine Config).

Inputs: project_path (required), rel_path (required), max_bytes.

register_project_in_hubA

Trägt ein vorhandenes Projekt in die Hub-Recents ein (schreibt projects-v1.json). Hub sollte geschlossen sein (sonst überschreibt er die Änderung). confirm=true nötig.

Inputs: project_path (required), force_hub_running, confirm.

remove_automation_scriptC

Entfernt das vom Server injizierte C#-Automationsskript (Assets/Editor/MCP) wieder. confirm=true.

Inputs: project_path (required), confirm.

remove_project_packageA
Destructive

Entfernt ein Paket aus Packages/manifest.json (Backup wird erstellt). confirm=true nötig.

Inputs: project_path (required), name (required), confirm.

resolve_editor_changesetA
Read-only

Löst eine Editor-Version (z.B. '6000.4.10f1') über die Unity-Release-API zu Changeset + unityhub://-Deep-Link auf. Nötig für install_editor bei nicht-gelisteten Versionen.

Inputs: version (required).

restore_backupA
Destructive

Stellt eine gesicherte Datei an target_path wieder her (die aktuelle Datei wird vorher erneut gesichert). confirm=true nötig.

Inputs: backup_file (required), target_path (required), confirm.

run_editor_methodA
Destructive

Führt eine BELIEBIGE statische Editor-Methode headless aus (-executeMethod), als Job. Mächtig und potenziell riskant (führt projektinternen Code aus) — confirm=true nötig. method als 'Namespace.Klasse.Methode'. extra_args werden unverändert angehängt.

Inputs: project_path (required), method (required), extra_args, use_quit, +3 more.

run_profiled_playerA

Laufzeit-Profiling SCHRITT 2 (Job): startet den von profile_play gebauten Player im Fenster (mit GPU), misst N Frames (Frame-Zeit/FPS/Draw Calls/Speicher/GC) und schreibt das Perf-JSON; der Player beendet sich selbst. Danach get_profile_result(perf_file).

Inputs: exe_path (required), perf_file (required), frames, width, +1 more.

run_testsA

Führt Unity-Tests via Test Framework aus (Job). platform: EditMode | PlayMode | StandaloneWindows64. Schreibt NUnit-XML; danach get_test_results aufrufen.

Inputs: project_path (required), platform, test_filter, categories, +2 more.

screenshot_desktopA
Read-only

Erstellt einen Desktop-Screenshot (PNG) zur Sichtprüfung des aktuellen GUI-Zustands.

Inputs: no named parameters.

search_pbr_materialsA
Read-only

Sucht hochwertige CC0-PBR-Materialien auf ambientCG (z.B. 'brick', 'wood', 'metal', 'rock', 'fabric'). Liefert Asset-IDs für download_pbr_material.

Inputs: query, limit.

search_polyhaven_texturesA
Read-only

Sucht CC0-Texturen auf Poly Haven (zweite Premium-Quelle, oft schöner für Natur/Stein/Holz; Tags/Kategorien). Liefert Asset-Slugs für download_polyhaven_texture.

Inputs: query, limit.

set_default_project_dirB

Setzt den Standardordner für neue Projekte (projectDir.json). confirm=true nötig.

Inputs: directory (required), confirm.

set_editor_install_pathA

Setzt das Editor-Installationsverzeichnis (Hub-CLI 'install-path --set'). confirm=true nötig.

Inputs: path (required), confirm.

set_project_favoriteB

Setzt/entfernt den Favoriten-Stern eines Projekts in der Hub-Liste. confirm=true nötig.

Inputs: project_path (required), favorite, force_hub_running, confirm.

stop_editorA
Destructive

Beendet laufende Unity-Editor-Prozesse (Unity.exe), ohne den Hub. Erfordert confirm=true.

Inputs: confirm.

stop_jobB
Destructive

Bricht einen laufenden Job ab. confirm=true nötig.

Inputs: job_id (required), confirm.

unregister_project_from_hubA
Destructive

Entfernt ein Projekt aus der Hub-Liste (löscht NICHT die Projektdateien). confirm=true nötig.

Inputs: project_path (required), force_hub_running, confirm.

update_hub_settingA

Setzt einen Hub-Einstellungswert (verschachtelt per '.', z.B. 'download.maxConcurrentDownloads' oder 'themeSource'). Backup wird erstellt; wirksam nach Hub-Neustart. confirm=true nötig.

Inputs: key_path (required), value (required), confirm.

write_scriptA

Schreibt ein C#-Skript (MonoBehaviour etc.) ins Projekt, z.B. rel_path='Assets/Scripts/PlayerController.cs'. Überschreibt mit Backup. Path-Sandbox aktiv. Kernbaustein für Game-Logik; danach via build_scene als Komponente per Klassenname anhängbar.

Inputs: project_path (required), rel_path (required), content (required).

write_text_assetC

Schreibt eine beliebige Textdatei ins Projekt (JSON, .asmdef, .shader, .txt, .csv …). Path-Sandbox + Backup.

Inputs: project_path (required), rel_path (required), content (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Deploy Server
    Claude Code, inside the Godot 4 editorFlockbay puts an AI agent in the real Godot 4 editor: it writes GDScript, runs your game and fixes what breaks. Free, or bring your own Claude Code or Codex.flockbay.comAd

    TDQS

    B3.4/5.0

    Scored across 94 tools

    Disambiguation4/5

    Most tools have distinct purposes, and descriptions are detailed. However, with 94 tools, some overlap exists (e.g., multiple download texture tools, multiple install editor tools), which could cause minor confusion. Overall, well differentiated.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun snake_case pattern (e.g., create_project, build_scene, get_license_status). This makes the API predictable and easy to navigate.

    Tool Count2/5

    With 94 tools, the set is excessively large. Even for a broad scope like Unity development, this number risks overwhelming agents and increases the chance of misselection. The typical well-scoped range is 3-15 tools.

    Completeness5/5

    The tool surface is exceptionally comprehensive, covering project management, asset creation, scene building, animation, profiling, testing, external integrations (Blender, Figma, Krita), and more. There are no obvious gaps for the stated purpose of MCP-assisted Unity development.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Resources

    Related MCP Connectors

    Related MCP Servers

    • UniMCP4CC

      dsgarage
      A
      license
      Not graded
      quality
      C
      maintenance
      Enables Claude Code to directly control Unity Editor, supporting scene manipulation, component operations, asset management, prefab handling, and audio control through natural language commands.
      5
      MIT

    • Unity MCP Server

      AnkleBreaker-Studio
      F
      license
      B
      quality
      A
      maintenance
      Provides AI assistants with comprehensive control over Unity Hub and Unity Editor through over 200 specialized tools for project management and scene manipulation. It enables users to perform complex tasks like script creation, asset management, and project builds using natural language commands.
      80
      201 npm
      542
      -

    • mcp-server-unity

      handi425
      A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI assistants like Claude to interact with Unity projects programmatically, supporting project management, asset creation, and build automation.
      1
      MIT