Skip to content
CAI
Software that uses CAICheck a score

CoplayDev/unity-mcp

49.9

Weak · 11 November 2026

126.6k

lines of production code

C#

with Python

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add MCP for Unity editor menu shortcuts

A new menu item group labeled 'MCP for Unity' has been added to the Unity Editor menu bar, providing direct access to three key windows: the main MCP window (toggled via Cmd+M/Ctrl+M), the Local Setup Window for configuration, and a new EditorPrefs management window for debugging configuration settings.

MCPForUnity/Editor/MenuItems · high confidence

Added Blender Bridge socket client for external addon communication

This change introduces the \BlenderSocketClient\ component within the Blender service layer, enabling the Unity editor to communicate with the BlenderMCP addon via a TCP socket. Users can now send commands (such as executing Python code or retrieving scene information) to a running Blender instance, with the client handling JSON parsing, connection timeouts, and error unwrapping. This provides the underlying connectivity required for the Generative-tab settings and other Blender-integrated features.

MCPForUnity/Editor/Services/Blender · high confidence

Added JSON serialization support for Unity math and geometry types

The serialization module now includes a new \UnityTypeConverters.cs\ file that provides custom JSON converters for common Unity types, including \Vector2\, \Vector3\, \Vector4\, \Quaternion\, \Color\, \Rect\, and \Bounds\. This enables these types to be correctly serialized to and deserialized from JSON structures (supporting both object and array formats) within the MCPForUnity runtime, ensuring data integrity when exchanging state or configuration involving these geometric primitives.

MCPForUnity/Runtime/Serialization · high confidence

Added Resources section to the MCP for Unity editor window

A new Resources section has been added to the MCP for Unity editor window, allowing users to discover, filter, and manage MCP resources directly from the UI. This feature introduces controls to enable or disable all resources at once, rescan for new resources, and toggle individual resources on or off. Resources are categorized into Built-in and Custom groups, with their enabled state persisted via editor preferences, providing a centralized interface for resource management within the editor.

MCPForUnity/Editor/Windows/Components/Resources · high confidence

Added Unity test scenes for the MCP test project

The test project now includes two Unity scenes, SampleScene and Test, located in TestProjects/UnityMCPTests/Assets/Scenes. SampleScene provides a standard environment with a directional light, while Test.unity establishes a minimal structure with a ComponentHost and a GameObject, serving as the base environment for running unit tests.

TestProjects/UnityMCPTests/Assets/Scenes · high confidence

Asset generation job management and model catalog discovery

The AssetGen service now includes a central job manager that orchestrates model, image, and audio generation tasks, persisting their state to Unity SessionState so that status queries remain valid across editor domain reloads. A new model catalog system provides a curated list of bundled models for providers like fal, OpenRouter, Tripo, and Meshy, and supports on-demand discovery of live fal and OpenRouter model catalogs with compatibility checks to ensure only valid models are used for generation.

MCPForUnity/Editor/Services/AssetGen · high confidence

Automated documentation regeneration and Unity version parity checks via Git hooks

Developers can now install optional Git hooks that automate maintenance tasks locally. The pre-commit hook automatically regenerates the Docusaurus tool and resource reference documentation whenever changes are made to tool, resource, or registry modules, ensuring the docs stay in sync with the code. The pre-push hook runs a local Unity-version parity check (compile-only mode) when changes affect Unity-specific paths, helping catch version mismatches before pushing to the remote repository.

tools/hooks · high confidence

Embed resolution-independent brand mark in Editor UI

The Editor now displays the MCP for Unity brand mark using crisp, resolution-independent vector geometry on Unity 2022.1 and later, ensuring the logo remains sharp at any DPI and is independent of the Editor theme. For older Unity versions (pre-2022.1) that lack the necessary Painter2D support, the UI automatically falls back to the existing raster brand icon, with improved logging if the fallback asset fails to load.

MCPForUnity/Editor/Windows/Components/Branding · high confidence

Expanded MCP client configurators for AI coding tools

The MCP for Unity editor now includes dedicated configuration support for a wide range of AI coding clients, including Antigravity (split into 2.0 and IDE variants), Cherry Studio, Claude Code, Claude Desktop, Cline, CodeBuddy CLI, Codex, GitHub Copilot CLI, Cursor, Gemini CLI, Kilo Code, Kimi Code, Kiro, OpenClaw, OpenCode, Qwen Code, and JetBrains Rider. Each configurator handles the specific config file paths, transport modes (stdio or HTTP), and installation steps required for its respective client, enabling seamless integration of Unity MCP servers into these environments.

MCPForUnity/Editor/Clients/Configurators · high confidence

Initial structure for MCPForUnity runtime assembly

The MCPForUnity/Runtime directory now contains the foundational files for the runtime assembly, including an Assembly Definition (asmdef) file, its metadata, and an AssemblyInfo.cs file. The AssemblyInfo.cs explicitly grants internal visibility to the editor assembly (MCPForUnity.Editor) and both edit-mode and play-mode test assemblies, enabling proper access to internal types during development and testing. This change establishes the modular assembly structure for the runtime code.

MCPForUnity/Runtime · high confidence

Introduce MCP build tooling with job tracking and platform-specific fixes

This change adds the core editor build infrastructure for MCPForUnity, including BuildJob and BuildRunner classes that manage asynchronous build scheduling, status polling, and batch execution. It introduces BuildSettingsHelper for reading and writing player settings (product name, bundle ID, scripting backend, etc.) and BuildTargetMapping for resolving platform names to Unity build targets. The implementation includes specific fixes: it prevents forcing PVRTC texture compression on Android by only applying subtarget settings to Standalone platforms, and it guards VisionOS enum references with version checks to avoid compile-time errors on older Unity versions.

MCPForUnity/Editor/Tools/Build · high confidence

Introduce Unity MCP CLI with command-line control and usage guide

Users can now control the Unity Editor via a new command-line interface (\unity-mcp\) that communicates with the MCP server over HTTP. The CLI supports global options for host, port, timeout, output format, and verbose logging, and provides commands to check connection status, list connected Unity instances, and send raw commands. A comprehensive usage guide (\CLI\_USAGE\_GUIDE.md\) is included to help developers and AI assistants understand the command structure, syntax, and common pitfalls.

Server/src/cli · high confidence

Introduce auto-discovery registry with group-based tool visibility

The server now uses a centralized registry system in \Server/src/services/registry\ to automatically discover and manage MCP tools and resources. Tools can be assigned to specific groups (such as 'core', 'docs', 'vfx', 'animation', 'ui', 'scripting\_ext', 'testing', 'probuilder', 'profiling', and 'asset\_gen') via the \mcp\_for\_unity\_tool\ decorator, which maps these groups to FastMCP tags for dynamic, per-session visibility control. This allows users to toggle tool availability in real-time through the \manage\_tools\ meta-tool, with 'core' tools enabled by default and others disabled unless explicitly activated. Resources are similarly registered via \mcp\_for\_unity\_resource\ for auto-discovery.

Server/src/services/registry · high confidence

Introduce centralized MCP client configurator interface and registry

The editor now uses a unified \IMcpClientConfigurator\ contract and a \McpClientRegistry\ to manage MCP client setup. This change adds a standardized interface for detecting installation status, supporting multiple transport types (stdio/HTTP), and handling idempotent configuration and unregistration, replacing the previous scattered helper logic with a discoverable, type-cache-driven registry.

MCPForUnity/Editor/Clients · high confidence

Introduce new 'manage\_gameobject' tool for scene GameObject manipulation

The Editor now includes a new 'manage\_gameobject' tool that allows users to create, modify, delete, and duplicate GameObjects within the current scene. This tool supports instantiating prefabs or primitives, setting transform properties (position, rotation, scale), managing parent-child hierarchies, and modifying component properties. It also includes utilities for moving objects relative to others and making them look at specific targets or positions. The tool handles common Unity constraints, such as preventing the addition of multiple Transform components or mixing 2D and 3D physics components, and provides clear error messages for invalid operations.

MCPForUnity/Editor/Tools/GameObjects · high confidence

Introduce structured CLI command groups for Unity operations

The CLI now exposes a set of dedicated command groups—animation, asset, asset-gen, audio, batch, build, camera, code, component, docs, and editor—allowing users to manage Unity scenes, assets, builds, and editor state through organized subcommands rather than a flat command list.

Server/src/cli/commands · high confidence

Introduces CLI utility modules for configuration, connection, and output formatting

This change adds a new set of utility modules under \Server/src/cli/utils\ that support the CLI's interaction with the Unity MCP server. The \config\ module provides a \CLIConfig\ dataclass and environment-variable-based configuration loading (via \UNITY\_MCP\_HOST\, \UNITY\_MCP\_HTTP\_PORT\, etc.). The \connection\ module introduces \UnityConnectionError\, a \handle\_unity\_errors\ decorator for consistent error handling, and functions to send commands to \http://{host}:{port}/api/command\, check health at \/health\, and list instances at \/api/instances\, including a security warning when connecting to non-localhost hosts. The \output\ module adds formatting utilities for text, JSON, and ASCII tables, along with colored print helpers. Additional utilities include \confirmation\ for destructive-action prompts, \parsers\ for robust JSON/value parsing with shell-friendly fixes, \suggestions\ for fuzzy-match suggestions, and \constants\ defining search-method choices used across CLI commands.

Server/src/cli/utils · high confidence

Introduces anonymous telemetry, new transport models, and E2E bridge smoke tests

The server now collects anonymous, privacy-focused telemetry (configurable via environment variables) to track usage and stability. A new set of Pydantic models defines the transport contract between the server and Unity plugin, including session details and tool definitions. Additionally, a deterministic end-to-end smoke test has been added to validate the Python-to-Unity bridge functionality without requiring an LLM API key.

mcpforunityserver · high confidence

Launch of new Docusaurus-based documentation site

The documentation site has been rebuilt using Docusaurus 3.x, replacing the previous structure. This new site features a modern minimalist layout with Satoshi and JetBrains Mono typography, a redesigned landing page with dynamic stats (such as client configurator counts), and a reorganized information architecture with dedicated sections for Getting Started, Guides, Reference, Architecture, and Contributing. The reference section now includes auto-generated tool and resource documentation, and the site is configured for deployment to GitHub Pages under the CoplayDev organization.

website · high confidence

MCP for Unity v10.2.0 release with new tooling and documentation

This release updates the package manifest to version 10.2.0 and introduces a suite of new files to support the v10 architecture and developer workflow. A new \mcp\_source.py\ helper script allows users to switch the MCP package source between upstream main, beta, remote branches, and local workspaces. The project now includes a Docker Compose configuration for running the Python server in a container, a \.mcpbignore\ file for the Claude Desktop bundle, and a \CLAUDE.md\ file providing detailed architectural guidance for AI assistants. Documentation has been restructured with new \CODE\_OF\_CONDUCT.md\, \CONTRIBUTING.md\, and \SECURITY.md\ files, while the legacy \HOW\_TO\_ADD\_A\_TOOL.md\ and \config.json\ have been removed in favor of the new centralized documentation and dynamic configuration.

(repo-wide) · high confidence

New Advanced Settings section in the Editor window

A new Advanced Settings section has been added to the MCPForUnity Editor window, providing users with granular control over server configuration and diagnostics. Users can now override the uvx executable path and specify a custom server source (such as a local Git repository or PyPI package) via the new 'Server Source' field. The section includes toggles for enabling verbose debug logging, recording tool execution logs to mcp.log, forcing fresh server installs during development, and configuring HTTP server binding (allowing LAN access or insecure remote HTTP connections). Additionally, users can override the default screenshots folder path and manage package deployment by selecting a source folder, deploying the package to the project, or restoring from a backup. A health indicator and test connection button allow users to verify the status of the MCP server connection.

MCPForUnity/Editor/Windows/Components/Advanced · high confidence

New Animation and Animator toolset

Added a comprehensive set of editor tools for managing Unity animations and Animator controllers. This includes creating and editing AnimationClips (with curve/keyframe manipulation and preset generation like bounce, rotate, pulse), building and modifying AnimatorControllers (adding states, transitions, layers, and blend trees), and controlling runtime Animator instances (playing states, crossfading, setting parameters, and reading status). These tools enable programmatic creation and manipulation of animation assets and runtime behavior directly through the MCP interface.

MCPForUnity/Editor/Tools · high confidence

New Asset Generation configuration tab with Blender Bridge integration

A new Asset Generation settings tab has been added to the MCP for Unity editor window. This tab allows users to configure per-provider API keys (stored securely in the OS keychain), toggle provider availability, and set generation preferences such as the default 3D output format (GLB, FBX, OBJ), the output root folder, and an auto-normalize toggle for imported models. It also includes a Blender Bridge section that lets users configure the local Blender MCP addon socket (host/port), manage a local blender-mcp checkout for addon syncing and update checking, and trigger local operations like importing Blender selections as GLB files directly into the Unity scene.

MCPForUnity/Editor/Windows/Components/AssetGen · high confidence

New Blender Bridge tool for direct Blender-to-Unity handoff

Added the Blender Bridge tool (BlenderBridgeTool.cs), which enables the Unity Editor to communicate directly with a running Blender instance via a socket connection. This allows users to perform actions such as checking status, retrieving scene/object info, taking viewport screenshots, running Python scripts in Blender, and importing models (exporting from Blender, importing through the shared pipeline, and placing them in Unity) without manual multi-step orchestration. The tool is registered under the 'asset\_gen' group and supports actions like 'status', 'scene\_info', 'object\_info', 'screenshot', 'run\_python', 'import\_model', 'compare\_screenshot', 'setup\_bloom', 'check\_updates', and 'sync\_addon'.

MCPForUnity/Editor/Tools/Blender · high confidence

New EditorPrefs Manager window for debugging MCP configuration

Developers can now use a dedicated EditorPrefs Manager window to view, search, and edit MCP for Unity Editor preferences directly within the Unity Editor. This tool provides a searchable list of known MCP keys, allows modification of values and types (String, Int, Float, Bool), and includes controls to refresh the list or add new entries, simplifying the debugging and testing of internal configuration settings.

MCPForUnity/Editor/Windows/EditorPrefs · high confidence

New HTTP transport layer with per-instance routing and session isolation

The server now supports an HTTP transport mode alongside the existing stdio mode, enabling remote-hosted deployments with API key authentication and user-scoped session isolation. This change introduces a new WebSocket-based plugin hub that manages Unity connections, a registry for tracking active sessions, and middleware that routes tool calls to specific Unity instances based on per-session state. Users can now connect multiple Unity projects simultaneously, with the server automatically handling instance selection, connection health monitoring, and command routing.

Server/src/transport · high confidence

New MCP for Unity Editor Window and Setup Wizard

The MCP for Unity Editor now features a redesigned main window with a tabbed interface (Connect, Tools, Resources, Generative, Deps, Advanced) and a dedicated Setup Wizard. The Setup Wizard guides users through system requirements (Python, UV, Git) and allows them to configure detected MCP clients during first-run. The main window includes a Script Validation section where users can adjust validation strictness (Basic, Standard, Comprehensive, Strict), and the UI has been branded with the Ocean mark and updated styling.

MCPForUnity/Editor/Windows · high confidence

New MCP resources for reading Unity editor state and scene data

The server now exposes a comprehensive set of read-only MCP resources that allow clients to inspect the current state of the Unity editor and scene without executing tools. This includes resources for editor context (active tool, selection, open windows, prefab stage), scene content (cameras, volumes, layers, tags, GameObjects with full component data, prefab hierarchy), and project metadata (project info, running instances, custom tools, tool groups). A central registration module in \\_\init\\_.py\ auto-discovers and registers these resources, handling serialization of Pydantic models and supporting both stdio and HTTP transport modes.

Server/src/services/resources · high confidence

New MCP tool for 2D sprite sheet animation management

Added the \manage\_sprite\ tool to the MCPForUnity editor, providing a unified interface for 2D sprite sheet animation workflows. This tool exposes five actions: \get\_info\ to inspect sprite sheets with pagination and optional inline image data, \slice\_sheet\ to define grid-based sprite extraction, \setup\_clips\ to generate AnimationClips from sliced frames, \setup\_controller\ to build AnimatorControllers with auto-detected states (Idle, Locomotion, Combat, etc.) and transitions, and \full\_setup\ to orchestrate the entire pipeline including optional scene attachment. The implementation includes robust parameter validation, diagnostic reporting for errors and warnings, and safety checks to prevent data loss or invalid asset creation.

MCPForUnity/Editor/Tools/Sprite2D · high confidence

New MCP tool suite and server infrastructure

This change introduces a comprehensive set of new MCP tools for the Unity Editor, including asset generation (generate\_image, generate\_model, generate\_audio, import\_model), code execution (execute\_code), and scene management (find\_gameobjects, find\_in\_file, batch\_execute). It also adds the \debug\_request\_context\ tool for inspecting server state and the \execute\_custom\tool\ entry point for project-scoped plugins. Under the hood, the server now features an auto-discovery registration system in \tools/\\init\\_.py\, a new \ExternalChangesScanner\ for detecting file system modifications, and a \batch\_execute\ tool that allows clients to send multiple commands in a single request to reduce latency and token costs.

Server/src/services/tools · high confidence

New Roslyn-based runtime C\# compilation tool for Unity

Users can now compile and execute C\# code at runtime within the Unity Editor without triggering a domain reload, using the new Roslyn Runtime Compilation feature. This capability is exposed via the \runtime\_compilation\ custom tool (in \ManageRuntimeCompilation.cs\) for programmatic access (e.g., by LLMs) and the \RoslynRuntimeCompiler\ MonoBehaviour for direct editor interaction. The tool allows compiling code in-memory, loading the resulting assembly, inspecting types, and executing entry-point methods, thereby enabling dynamic script updates without the traditional asset reload overhead.

CustomTools · high confidence

New Tools section with group-based discovery and project-scoped toggle

The MCP for Unity editor window now includes a dedicated Tools section that discovers and lists available tools, grouping them by category (Core, VFX, Animation, etc.) with built-in tools sorted alphabetically and custom tools displayed separately. Users can enable or disable all tools at once, rescan for new tools, or reconfigure clients. A new toggle allows enabling project-scoped custom tools when using HTTP Local or stdio transports, with persistence across editor sessions via EditorPrefs.

MCPForUnity/Editor/Windows/Components/Tools · high confidence

New VFX management tools for particles, lines, and trails

This update introduces a comprehensive set of editor tools for managing Unity visual effects, including ParticleSystem, LineRenderer, TrailRenderer, and Visual Effect Graph components. Users can now create, configure, and control particle systems (e.g., setting emission rates, shapes, and playback), manipulate line renderers (e.g., creating lines, circles, arcs, and Bezier curves, and adjusting width/color), and manage trail renderers. The tools also support reading and writing properties for these components, allowing for dynamic adjustment of materials, positions, and other attributes via JSON parameters.

MCPForUnity/Editor/Tools/Vfx · high confidence

New animation editing tools for Unity Animator and AnimationClips

This change introduces a new set of editor tools in the MCPForUnity Animation module, enabling programmatic creation and manipulation of Unity animation assets. Users can now create and modify AnimatorControllers (adding states, transitions, layers, and blend trees), generate AnimationClips with curves and events, and apply preset animation effects like bounce, rotate, or pulse. The tools also support runtime-like control of Animator parameters (play, crossfade, set parameter, set speed) and reading Animator state information. A key behavioral detail is the AnimatorResolver, which automatically finds Animators on child objects if the target GameObject does not have one directly, improving usability with imported models.

MCPForUnity/Editor/Tools/Animation · high confidence

New asset generation and import tools for audio, images, 3D models, and local files

This change introduces a suite of new editor tools under the \asset\_gen\ group to streamline asset creation and integration. Users can now generate audio via fal.ai, create 2D images through fal.ai or OpenRouter, and generate 3D models using providers like Tripo and Meshy; all generation tools support asynchronous job polling (status, cancel, list\_providers) to handle long-running tasks without blocking the editor. Additionally, a new \import\_model\ tool allows searching and importing 3D assets directly from Sketchfab, while \import\_model\_file\ enables importing local 3D files (FBX, OBJ, glTF, GLB, ZIP) into the project with automatic path staging and pipeline processing. These tools centralize provider key management via the secure store and provide a unified interface for asset lifecycle management.

MCPForUnity/Editor/Tools/AssetGen · high confidence

New asset generation provider adapters and registry

The Asset Generation system now supports a unified provider registry that resolves model, image, audio, and marketplace providers by ID. This change introduces adapters for Tripo, Meshy, and fal (for 3D models), fal and OpenRouter (for 2D images), fal (for audio), and Sketchfab (for marketplace imports). The registry validates API key configuration via the secure store and provides a centralized list of available providers and their capabilities. Adapter implementations handle provider-specific submission, polling, and result extraction, with security hardening including host validation for all API requests to prevent credential exfiltration.

MCPForUnity/Editor/Services/AssetGen/Providers · high confidence

New asset import pipelines for audio, images, and 3D models

The AssetGen import system now includes dedicated pipelines for handling generated audio clips, 2D images, and 3D models. Audio imports automatically configure load types (streaming, compressed, or decompressed) based on clip length to optimize memory usage. Image imports apply appropriate texture settings for sprites or color/normal maps. Model imports support FBX, OBJ, and glTF formats (with glTF requiring the glTFast package), including safe extraction of marketplace archives like Sketchfab while preventing execution of non-asset files.

MCPForUnity/Editor/Services/AssetGen/Import · high confidence

New asset-generation helpers and configuration utilities

The Editor Helpers area now includes a suite of new utilities to support the AI Asset Generation feature and improve client configuration. AssetGenPaths and AssetPathUtility provide robust, cross-platform path normalization and validation, ensuring generated assets are written safely within the project's Assets folder while preventing path traversal. AssetGenPrefs manages non-secret user preferences (such as default output folders, model/image/audio providers, and auto-normalization settings) via EditorPrefs, keeping API keys secure. CodexConfigHelper and ConfigJsonBuilder generate and update MCP client configuration files (TOML for Codex, JSON for others) with support for both HTTP and stdio transports, handling client-specific quirks like transport types and environment variables. ComponentOps offers low-level, Undo-aware operations for adding, removing, and setting properties on Unity components, with special handling for UnityEvent serialization. BlenderDetection assists the Asset Gen tab by locating the local Blender installation for handoff workflows. EditorWindowScreenshotUtility enables capturing the Scene View viewport to PNG files for use in AI interactions.

MCPForUnity/Editor/Helpers · high confidence

New client configuration section with per-client setup and manual configuration options

The MCP for Unity editor window now includes a dedicated Client Configuration section that allows users to manage individual MCP clients. This new UI component features a 'Configure All Detected Clients' button for bulk actions, a dropdown to select specific clients, and a collapsible 'Per-client setup' foldout containing status indicators, individual configure/install buttons, and visibility toggles for Claude CLI path and project directory settings. Additionally, a 'Manual Configuration' foldout is provided for advanced users to view and edit raw configuration JSON, copy paths, and open config files directly.

MCPForUnity/Editor/Windows/Components/ClientConfig · high confidence

New connection section with transport selection and remote authentication

The editor window now includes a dedicated Connection section that lets users choose between HTTP (local or remote) and stdio transports via a dropdown. For remote HTTP connections, users can configure an API key for authentication. The UI provides controls to start the local HTTP server, set the Unity socket port, and view connection status, along with warnings for transport or version mismatches.

MCPForUnity/Editor/Windows/Components/Connection · high confidence

New dependency validation and uv installer infrastructure

The Editor now includes a new dependency management subsystem that validates the presence of required tools (Python, uv, Git) and provides one-click installation for the uv package manager. This change introduces a platform-agnostic detection layer and a dedicated installer for uv, ensuring users receive clear guidance and automated setup steps for external dependencies before using MCP for Unity.

MCPForUnity/Editor/Dependencies · high confidence

New developer tooling for CI parity, licensing, and release automation

The tools directory now includes several new scripts to improve local development parity with CI and streamline release workflows. Developers can run \check-unity-versions\ (shell and PowerShell) to locally verify Unity version compatibility using either local Unity Hub installations or GameCI Docker containers, matching the CI matrix defined in \unity-versions.json\. A new \compile-check.sh\ script enables license-free semantic compilation checks on any PR (including forks) by invoking Roslyn directly against Unity's reference assemblies. CI reliability is enhanced with \check\_unity\_test\_results.py\ to validate NUnit output and \ci\_unity\_license.py\ to manage Unity license activation and return in Dockerized environments. Release processes are supported by \generate\_mcpb.py\ for creating Model Context Protocol Bundle artifacts, \docker\_publish.sh\ for manual Docker image publishing, \pypi\_publish.sh\ for Python package uploads, and \prepare\_unity\_asset\_store\_release.py\ for staging Asset Store packages with specific configuration overrides.

tools · high confidence

New editor commands to retrieve project layers, tags, and configuration details

The MCPForUnity editor now exposes three new resource commands—\get\_layers\, \get\_tags\, and \get\_project\_info\—allowing external tools to query Unity project metadata. The \get\_layers\ command returns a mapping of layer indices to their names, while \get\_tags\ provides the list of currently defined tags. The \get\_project\_info\ command aggregates static configuration data, including the project root, Unity version, active build platform, render pipeline, and the status of key packages (UGUI, TextMeshPro, Input System). It also detects the active input handler (Old, New, or Both) using reflection to avoid compile-time dependencies, giving users a comprehensive view of their project's setup directly through the MCP interface.

MCPForUnity/Editor/Resources/Project · high confidence

New editor resource handlers for tool, state, and selection queries

Added six new C\# resource handlers in the Editor/Resources/Editor directory to expose real-time Unity editor context to external clients: ActiveTool (reports the current tool, pivot mode/rotation, and handle position), EditorState (provides a cached snapshot of dynamic editor state), GetPrefabStage (reports the open prefab stage, including mode and dirty status), Selection (details the currently selected objects, game objects, and asset GUIDs), ToolStates (lists all discovered tools with their enabled status, groups, and parameters), and Windows (lists all open EditorWindows with their titles, types, and positions). These handlers register as MCP resources (e.g., get\_active\_tool, get\_selection) and return structured JSON responses, enabling external tools to query the editor's current state and configuration.

MCPForUnity/Editor/Resources/Editor · high confidence

New editor services for transport bridging, client configuration, and state caching

The Editor/Services area now includes a set of new services that manage the MCP bridge lifecycle and client setup. BridgeControlService and its interface handle starting, stopping, and verifying the HTTP or stdio transport, ensuring only one runs at a time. ClientConfigurationService coordinates detected clients, applying transport coercion so each client uses a supported transport (HTTP/HTTPRemote vs stdio) and cleaning stale build artifacts when using a local server path. EditorConfigurationCache centralizes EditorPrefs reads (transport mode, debug logs, path overrides) with change notifications, while EditorStateCache maintains a fast, cached snapshot of Unity/editor state (compilation, domain reloads, play mode, assets, tests) to keep status reads responsive. HttpAutoStartHandler and HttpBridgeReloadHandler manage auto-start on editor load and resume after domain reloads, using SessionState to survive reloads and avoiding conflicts with manual control. Additionally, EditorPrefsWindowService provides access to a debugging window for MCP configuration, and interfaces for package deployment and updates are introduced to support local source code deployment and version management.

MCPForUnity/Editor/Services · high confidence

New manage\_prefabs tool for headless prefab operations

A new \manage\_prefabs\ tool has been added to the MCPForUnity editor, enabling programmatic management of Unity prefabs without requiring an interactive UI. This tool supports actions such as creating prefabs from scene GameObjects (\create\_from\_gameobject\), retrieving prefab metadata and hierarchy (\get\_info\, \get\_hierarchy\), and modifying prefab contents (\modify\_contents\). It also provides workflow support for opening, saving, and closing prefab stages (\open\_prefab\_stage\, \save\_prefab\_stage\, \close\_prefab\_stage\), allowing external clients to automate prefab creation and inspection tasks within the Unity editor.

MCPForUnity/Editor/Tools/Prefabs · high confidence

New manage\_profiler tool for CPU, memory, and frame debugging

A new \manage\_profiler\ tool is available in the profiling group, providing a unified interface to control the Unity Editor profiler and extract performance data. Users can start and stop profiling sessions, configure specific profiler areas, and retrieve frame timing statistics (including CPU/GPU breakdowns). The tool also exposes detailed counter data for categories like Scripts, Render, and Physics, allows querying memory usage for specific scene objects or assets, and supports taking, listing, and comparing memory snapshots. Additionally, it enables the Frame Debugger to capture and inspect per-frame rendering events.

MCPForUnity/Editor/Tools/Profiler · high confidence

New physics management tools for Unity scenes

This update introduces a comprehensive set of editor tools for managing Unity physics, accessible via the 'manage\_physics' dispatcher. Users can now configure global physics settings (gravity, solver iterations), read and modify the layer collision matrix, and create, configure, or assign physics materials to colliders. The tools also support joint management (adding, configuring, and removing joints for both 2D and 3D), rigidbody inspection and configuration, and physics queries including raycasts, linecasts, and shape overlaps. Additionally, forces and torques can be applied to rigidbodies, and simulation steps can be triggered for testing.

MCPForUnity/Editor/Tools/Physics · high confidence

New resource attribute for auto-discovery of MCP handlers

The editor now includes a new \McpForUnityResourceAttribute\ that allows classes to be automatically discovered as MCP resource handlers. By marking a class with this attribute, developers can define a public static \HandleCommand\ method that will be routed based on a resource name (either explicitly set or auto-generated from the class name). This change also reorganizes several editor resource metadata files under the \MCPForUnity/Editor/Resources\ directory to support this new structure.

MCPForUnity/Editor/Resources · high confidence

New scene resource handlers for cameras, game objects, and rendering

Added new editor resource handlers in the Scene directory to expose scene data via MCP commands. This includes \CamerasResource\ for listing cameras, \GameObjectResource\ and \GameObjectComponentsResource\ for reading GameObject metadata and component details (with pagination support), and \RendererFeaturesResource\, \RenderingStatsResource\, and \VolumesResource\ for accessing graphics and rendering information.

MCPForUnity/Editor/Resources/Scene · high confidence

New scripts for unified adoption stats and brand asset generation

Added \website/scripts/fetch-stats.mjs\ to aggregate and render adoption metrics, prioritizing real-user signals like GitHub cloners and viewers while labeling PyPI download counts as an inflated proxy. Added \website/scripts/gen-brand-assets.mjs\ to rasterize the brand SVG into a full set of favicon and touch-icon PNGs. Both scripts include corresponding test coverage.

website/scripts · high confidence

New setup tools for Roslyn installation and GitHub skill syncing

The Editor Setup area now includes a new Roslyn installer that automatically downloads and places Microsoft.CodeAnalysis DLLs (v4.12.0) and their dependencies into Assets/Plugins/Roslyn, with version checks to prevent stale assembly conflicts. Additionally, a new GitHub-based skill sync window allows users to incrementally mirror the latest Unity MCP skill files from a specified repository branch without cloning the full repository, with configuration persisted via EditorPrefs.

MCPForUnity/Editor/Setup · high confidence

New utility modules for focus management, logging, and module discovery

Added three new utility modules to the server: \focus\_nudge.py\ handles OS-level focus restoration to prevent Unity from being throttled during PlayMode tests, including a fix for macOS where it now correctly restores focus to VS Code instead of launching a new Electron instance; \log\_paths.py\ provides OS-aware resolution for log directories (using XDG\_STATE\_HOME on Linux, Application Support on macOS, and LOCALAPPDATA on Windows); and \module\_discovery.py\ enables auto-registration of tools and resources by dynamically discovering and importing Python modules from specified directories.

Server/src/utils · high confidence

Runtime compatibility shims and screenshot utility for Unity 2021–6.x

The Runtime/Helpers folder now includes a new ScreenshotUtility class that provides robust screenshot capture (including composited, UI, and camera-based captures with optional base64 encoding) and a suite of version-compatibility shims (UnityFindObjectsCompat, UnityObjectIdCompat, UnityPhysicsCompat, UnityAssembliesCompat) that wrap deprecated or removed Unity APIs—such as FindObjectsByType, EntityId migration, Physics.autoSimulation, and CoreCLR assembly enumeration—using reflection and conditional compilation to ensure the package compiles and runs correctly across Unity 2021 LTS through 6.x without warnings or breakage.

MCPForUnity/Runtime/Helpers · high confidence

Server distribution via Docker and PyPI

The Server component is now distributable as a Docker image and via PyPI, allowing users to run the MCP server without local source installation. The Dockerfile uses Python 3.13-slim and \uv\ for dependency management, exposing port 8080 for HTTP transport. The server supports a remote-hosted mode with API key authentication for multi-user isolation, configurable via environment variables or CLI flags. Documentation (README, DOCKER\_OVERVIEW) details installation via \uvx\, Docker, or source, and explains configuration for stdio/HTTP transports, telemetry, and remote auth.

Server · high confidence

Removals

Removal of legacy Editor command handlers and registry

The \Editor/Commands\ directory has been cleared of its previous implementation files, including \AssetCommandHandler\, \CommandRegistry\, \EditorControlHandler\, \MaterialCommandHandler\, \ObjectCommandHandler\, \SceneCommandHandler\, and \ScriptCommandHandler\. This removes the existing set of editor commands for managing assets, scenes, objects, materials, and scripts, as well as the central registry that mapped command names to these handlers.

Editor/Commands · high confidence

Removal of legacy Unity MCP Editor components

The Editor area no longer includes the \MCPEditorWindow\, \UnityMCPBridge\, and \Vector3Helper\ classes. This removes the previous implementation of the Unity MCP Editor window, the TCP-based bridge for handling commands, and the Vector3 JSON parsing helper, effectively deleting these legacy editor features.

Editor · high confidence

Security

Secure storage for AI provider API keys

The Editor now stores AI asset-generation provider keys (e.g., Tripo, Meshy, Sketchfab, Fal, OpenRouter) in platform-native secure stores—macOS Keychain, Windows Credential Manager, or Linux libsecret—instead of plaintext. A cross-platform encrypted-file fallback (AES-256-CBC + HMAC-SHA256 with PBKDF2) is used when no OS service is available, and keys are never sent over the MCP bridge or logged. An environment-variable override (MCPFORUNITY\_\<PROVIDER\>\_API\_KEY) allows CI/headless usage, and a SecretRedactor utility masks secrets in logs and error output.

MCPForUnity/Editor/Security · high confidence

Architecture

Server restructured with new transport, middleware, and logging infrastructure

The server codebase has been reorganized into a modular structure under \Server/src\, introducing a new \main.py\ entry point that integrates Starlette/FastMCP for HTTP and WebSocket support. This change adds a \UnityInstanceMiddleware\ to route requests to specific Unity instances, implements a \PluginRegistry\ and \PluginHub\ for extensibility, and configures OS-compliant rotating file logging (with Windows-specific safety fixes) alongside telemetry. It also includes a workaround for Windows asyncio event loop policies and ensures typing compatibility in tool signature evaluation.

Server/src · high confidence

Behavioural changes

Added utilities to normalize Unity transport responses into a standard MCP format

New modules in the models package now provide functions to normalize Unity's specific {status, result} payloads into a consistent MCPResponse shape. This ensures that downstream components receive a uniform structure with success, message, error, and data fields, regardless of whether the original Unity response was already in the expected format or required transformation. Additionally, a helper function is available to parse these normalized responses into typed classes while safely handling error cases to prevent validation failures.

Server/src/models · high confidence

Asset Store Tools test project scaffolding and API abstraction layer

The TestProjects/AssetStoreUploads location now includes a complete Unity project structure (URP settings, sample scene, tutorial info) and the com.unity.asset-store-tools package. The package introduces a refactored API layer with abstractions for authentication, HTTP client interactions, and package uploading, alongside a new CHANGELOG documenting version 12.0.0 changes such as the Newtonsoft.Json dependency, higher-resolution preview generation, and a dedicated Preview Generator window.

TestProjects/AssetStoreUploads, TestProjects/AssetStoreUploads/Packages/com.unity.asset-store-tools · high confidence

Automated migration for legacy server configurations and stdio version updates

The editor now automatically handles two types of configuration updates on startup. First, it detects and migrates legacy embedded-server preferences (ServerSrc and UseEmbeddedServer keys) to the new uvx/stdio path, cleaning up old keys to prevent migration loops. Second, it keeps stdio-based MCP client configurations in sync with the current package version by re-registering them when the package updates, while skipping clients that do not support the currently active transport (e.g., skipping stdio clients when HTTP transport is enabled).

MCPForUnity/Editor/Migrations · high confidence

Automated validation of NL/T fragment coverage

A new shell script has been added to automatically verify that all expected Natural Language and Test fragment result files (NL-0 through NL-4 and T-A through T-J) are present in the reports directory. This ensures that CI pipelines can detect missing test outputs early, preventing incomplete coverage reports from being accepted.

scripts · high confidence

Configure static assets for Docusaurus deployment

Added a .nojekyll file to prevent static site processing interference and a robots.txt file to allow indexing and specify the sitemap location at https://coplaydev.github.io/unity-mcp/sitemap.xml, preparing the website for hosting on CoplayDev.

website/static · high confidence

Editor UI component structure and styling overhaul

The Editor window's UI components have been reorganized into distinct sub-folders (Advanced, AssetGen, Branding, ClientConfig, Connection, Resources, Tools, Validation) to improve modularity. A new shared stylesheet (Common.uss) has been introduced to standardize the visual appearance of sections, setting rows, and status indicators, while also fixing USS warnings related to unsupported pseudo-classes like :last-child by using programmatic class application.

MCPForUnity/Editor/Windows/Components · high confidence

Editor assembly structure and CI boot behavior changes

The Editor assembly now explicitly references the Runtime assembly and pre-compiled Roslyn/JSON libraries, while also defining the UNITY\_VFX\_GRAPH symbol when the Visual Effect Graph package is present. Additionally, a new CI boot helper pins the transport to stdio for the current session to ensure stable CI execution without altering the developer's persistent Editor preferences.

MCPForUnity/Editor · high confidence

Editor plugin renamed to MCPForUnity with bundled TOML config library

The editor plugin folder has been renamed to MCPForUnity, and the package now includes the external TOML parsing library (Tommy.cs) to handle configuration files. The README has been updated to reflect the new structure and document the editor window, client configuration, and bridge setup.

MCPForUnity · high confidence

Improved Unity port discovery with per-project support and active verification

The server now supports per-project Unity instance tracking by scanning for hashed port registry files (e.g., \unity-mcp-port-\<hash\>.json\) in addition to the legacy single-file registry, preferring the most recently modified file. To prevent connecting to stale or incorrect ports, the discovery process actively probes candidate ports using a framed ping/pong handshake (with a legacy fallback) before selecting one, and prioritizes the port from the latest heartbeat status file if it responds successfully.

Server/src/transport/legacy · high confidence

Modern minimalist design system for the documentation site

The documentation website now uses a new custom CSS theme that replaces the default Docusaurus styling with a modern, minimalist aesthetic. This change introduces Satoshi for body text and JetBrains Mono for code, adjusts typography with tighter letter-spacing and specific heading sizes, and refines the visual hierarchy for code blocks, tables, and the navbar. It also includes specific styling for the search input and keyboard hints to ensure they blend with the new design language.

website/src/css · high confidence

New platform-specific dependency detection for Python, uv, and Git

The editor now uses a new \PlatformDetectors\ subsystem to reliably detect required tools on Windows, macOS, and Linux. This change introduces platform-specific detectors that validate Python (minimum version 3.10), the \uv\ package manager, and Git, providing accurate status reporting and installation guidance. On macOS, detection now includes \pyenv\ shims in the PATH to resolve issues where Unity is launched from the Dock or Spotlight. On Windows, the detector can fall back to finding Python via \uv\ if it is not directly in the system PATH. Git is now reported as optional, with specific advice provided if the Package Manager fails due to directory ownership issues.

MCPForUnity/Editor/Dependencies/PlatformDetectors · high confidence

Python server and tool modules removed; docs generation and test harness added

The legacy Python server implementation (including \server.py\, \config.py\, \unity\_connection.py\, and all tool modules under \Python/tools/\) has been removed, along with the \Python/.python-version\ file. In its place, a new documentation generation tool (\tools/generate\_docs\_reference.py\) has been added to auto-generate Docusaurus reference pages from the Python tool registry, and a local headless test harness (\tools/local\_harness.py\) has been introduced to orchestrate Unity Editor tests (smoke, EditMode, PlayMode) and produce JUnit reports.

Python · high confidence

Redesigned v10 homepage with terminal-blueprint aesthetic and new interactive components

The website's homepage has been completely restyled with a modern, minimalist 'terminal-blueprint' look, featuring hairline borders, mono microcopy, and a dot-grid backdrop. This redesign introduces several new React components: a \HomeHero\ section with a live demo video and copyable Unity Package Manager URLs (powered by a new \CopyButton\ utility), a \HomeStats\ spec sheet displaying dynamic tool and client counts, a \HomeFeatures\ grid detailing capabilities like multi-instance routing and custom tool extension, a \HomeArchitecture\ diagram explaining the three-layer MCP client/Python server/Unity plugin flow, and a \HomeCloser\ section with installation CTAs and a research citation block.

website/src/components · high confidence

Refactored MCP configuration models and added transport mismatch detection

The editor's model layer has been reorganized under the \MCPForUnity\ namespace and expanded to support multiple MCP client configurations and transport types. New model classes (\McpClient\, \McpConfigServer\, \McpConfig\) introduce fields for per-client transport settings (HTTP vs. stdio), specific server command arguments, and client-specific configuration layouts (e.g., VS Code vs. Kilo formats). Additionally, a new \ConfiguredTransport\ enum and related properties in \McpClient\ enable the editor to detect and warn about transport mismatches between the client and the MCP server.

MCPForUnity/Editor/Models · high confidence

Refactored local HTTP server launch and management into modular, platform-specific services

The local HTTP server startup and lifecycle management in the MCP for Unity Editor has been restructured into a set of dedicated, platform-aware components. This change introduces interfaces and implementations for building server commands (ServerCommandBuilder), launching processes in headless or terminal modes (TerminalLauncher), detecting and terminating server processes (ProcessDetector, ProcessTerminator), and persisting server state across Unity domain reloads (PidFileManager). These services work together to provide more robust cross-platform support (macOS, Windows, Linux) for launching the uvx-based MCP server, handling stdin redirection on Windows, and ensuring reliable process cleanup.

MCPForUnity/Editor/Services/Server · high confidence

Remote-hosted authentication and project-scoped custom tool registration

The server now supports a remote-hosted mode that requires API key validation via an external endpoint before allowing access, replacing the previous unauthenticated or locally-bound model. In this mode, the public REST endpoint for registering custom tools is disabled to prevent unauthorized tool injection, while tool execution remains gated by the validated user identity. Additionally, custom tools can now be registered with project-scoped isolation, allowing different projects to maintain separate tool definitions while still supporting global tool registration when needed.

Server/src/services · high confidence

Standardized product identity and centralized configuration constants

The editor now uses the canonical product name 'MCP for Unity' in the main menu (Window/MCP for Unity) and UI branding. Editor preferences are now managed through a centralized constants file, introducing keys for HTTP transport scope (local/remote), security settings (allow LAN binding, allow insecure remote HTTP), asset generation model providers, and various server lifecycle states, ensuring consistent configuration handling across the package.

MCPForUnity/Editor/Constants · high confidence

Updated website logo mark to split-cube design

The static image asset for the website logo has been replaced with a new 'split-cube' SVG design. This visual update reflects the finalized brand identity, featuring two interlocking geometric shapes in blue and teal tones, replacing the previous logo mark used across the site.

website/static/img · high confidence

Fixes

Introduces configurable server settings and robust timeout handling

The server now uses a centralized configuration module that exposes network, transport, and timeout settings via environment variables. Specifically, the connection timeout (default 300s) and command total timeout (default 600s) can be overridden via \UNITY\_MCP\_CONNECTION\_TIMEOUT\ and \UNITY\_MCP\_COMMAND\_TOTAL\_TIMEOUT\, with validation that rejects non-finite or non-positive values to prevent misconfiguration. The default network host is set to \127.0.0.1\ to avoid IPv4/IPv6 ambiguity on Windows, and API key authentication endpoints are now configurable for remote HTTP modes.

Server/src/core · high confidence

Refactored transport layer with unified interface and improved reload resilience

The transport subsystem has been restructured to improve stability during Unity domain reloads and background thread execution. A new \IMcpTransportClient\ interface standardizes transport implementations (such as WebSocket and stdio), while \TransportManager\ now coordinates lifecycle events and reconciles stdio state to prevent the editor from reporting a dead connection after a reload. \TransportCommandDispatcher\ ensures all MCP commands are executed on the Unity main thread, preventing race conditions and crashes when commands arrive from background threads. These changes make the editor more robust against connection drops and reload-induced state inconsistencies.

MCPForUnity/Editor/Services/Transport · high confidence

Stabilize stdio and WebSocket transport connections across domain reloads

The stdio bridge host now uses a configurable command timeout (defaulting to 5 minutes via the UNITY\_MCP\_STDIO\_COMMAND\_TIMEOUT\_MS environment variable) to prevent long-running tool calls from being cut off, and implements a retry window for port-bind races that occurred after domain reloads. The stdio transport client now waits up to 5 seconds for the bridge to become ready after a restart, eliminating false "Bridge not running" UI errors. The WebSocket transport client has been hardened to handle editor shutdowns and domain reloads gracefully by using a force-stop path that aborts the socket immediately when async cleanup is not possible, ensuring reliable reconnection and state recovery.

MCPForUnity/Editor/Services/Transport/Transports · high confidence

Test coverage

Added Edit Mode tests for the Blender Bridge integration; Added EditMode test suite for setup, transport, and utilities; Added EditMode tests for AssetGen job management, providers, and adapters; Added EditMode tests for helper utilities; Added PlayMode test suite for Unity coroutine and lifecycle verification; Added characterization tests for Editor Services; Added characterization tests for Editor Services; Added characterization tests for build, release, and CI infrastructure; Added test assembly definition and components for UnityEvent wiring validation; Added test helper scripts for Unity MCP validation; Added test metadata files for EditMode, Editor, and PlayMode test folders; Added test project asset structure and default UI theme; Added tests for client configuration status, installation detection, and transport support; Added tests for connection health debounce and orphan detection; Added tests for the GetTests resource implementation; Added tests to verify Roslyn assembly references and usage in the Editor; Added unit tests for server-side process management and command building; Expanded Edit Mode test coverage for editor services; Expanded EditMode test coverage for MCP tools and infrastructure; Initial test suite for Server-side Python components; Integration test suite for the MCP server.

Dependencies

Initial release of MCP for Unity package and server dependencies

This change introduces the foundational dependency manifests for the project's initial release. It adds the Unity package manifest (\MCPForUnity/package.json\) declaring the \com.coplaydev.unity-mcp\ package (version 10.2.1-beta.6) and its required Unity modules and NuGet dependencies. It also adds the Python server manifest (\Server/pyproject.toml\) for \mcpforunityserver\ (version 10.2.0), specifying runtime dependencies like \fastmcp\, \mcp\, and \fastapi\, along with development tools. Additionally, it establishes the documentation site dependencies (\website/package.json\ and \package-lock.json\) using Docusaurus 3.6.3 and React 18, while removing legacy placeholder manifests from the \Python/\ and root directories.

(dependencies) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 53 → 50 (-3.4)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 47 → 47 (+0.0)
  • Architecture 95 → 69 (-25.9)
  • Maturity 70 → 47 (-22.7)
  • Readiness 56 → 56 (+0.0)
  • Security 55 → 56 (+0.7)
  • Performance 60 → 60 (+0.0)

Resolved (28)

  • Change coupling: McpClientConfigSection.cs ↔ EditorPrefsWindow.cs (MCPForUnity/Editor/Windows/Components/ClientConfig/McpClientConfigSection.cs)
  • Critical CVE: [GHSA redacted] (Server/uv.lock)
  • Documentation: contradicts the code (website/docs/contributing/releases.md)
  • Duplicate intent with ambiguous naming. Both methods appear to query the same Unity physics setting (Auto Sync Transforms), but one is explicitly 2D and the other is generic. In Unity, 'Auto Sync Transforms' is a global setting affecting both 2D and 3D physics, making the 2D-specific name potentially misleading or redundant.
  • Duplicate intent with ambiguous naming. Same issue as the getters; two setters for what is likely the same underlying Unity property.
  • Duplicated block (11 lines × 3) (MCPForUnity/Runtime/Helpers/ScreenshotUtility.cs)
  • FileTooLong: tools/local_harness.py (tools/local_harness.py)
  • Inconsistent method naming and parameter structure. CaptureToProjectFolder implies capturing the screen (default behavior) but requires a folderOverride parameter. CaptureFromCameraToProjectFolder explicitly specifies the source (Camera) but has a different parameter list (e.g., include... suggests additional options not present in the first method). This forces users to remember two different signatures for similar 'save screenshot' operations.
  • Off-boarding risk: anonymized user #1
  • Off-boarding risk: anonymized user #2
  • Off-boarding risk: anonymized user #3
  • Repeated repair: Server/src/cli/commands/camera.py (Server/src/cli/commands/camera.py)
  • generate_docs_reference._render_type (cognitive 30) (tools/generate_docs_reference.py)
  • generate_docs_reference._render_type (cyclomatic 24) (tools/generate_docs_reference.py)
  • generate_docs_reference.generate (cognitive 16) (tools/generate_docs_reference.py)
  • local_harness._outcome_from_terminal (cognitive 55) (tools/local_harness.py)
  • local_harness._outcome_from_terminal (cyclomatic 40) (tools/local_harness.py)
  • local_harness.discover_editor (cognitive 27) (tools/local_harness.py)
  • local_harness.discover_editor (cyclomatic 19) (tools/local_harness.py)
  • local_harness.instance_id_from_status (cognitive 18) (tools/local_harness.py)
  • …and 8 more

New (31)

  • Critical CVE: [GHSA redacted] (Server/uv.lock)
  • Edited copy of a member (10 corresponding lines) (MCPForUnity/Editor/Tools/Animation/ClipPresets.cs)
  • Edited copy of a member (12 corresponding lines) (MCPForUnity/Editor/Tools/Animation/ClipPresets.cs)
  • Edited copy of a member (12 corresponding lines) (MCPForUnity/Editor/Tools/ManageUI.cs)
  • Edited copy of a member (14 corresponding lines) (MCPForUnity/Editor/Clients/McpClientConfiguratorBase.cs)
  • Edited copy of a member (15 corresponding lines) (TestProjects/AssetStoreUploads/Packages/com.unity.asset-store-tools/Editor/Previews/Scripts/UI/Elements/PreviewGeneratorPathsElement.cs)
  • Edited copy of a member (17 corresponding lines) (TestProjects/AssetStoreUploads/Packages/com.unity.asset-store-tools/Editor/Previews/Scripts/Generators/Custom/Screenshotters/MaterialScreenshotter.cs)
  • Edited copy of a member (19 corresponding lines) (MCPForUnity/Editor/Windows/Components/Advanced/McpAdvancedSection.cs)
  • Edited copy of a member (21 corresponding lines) (MCPForUnity/Editor/Tools/Physics/PhysicsQueryOps.cs)
  • Edited copy of a member (23 corresponding lines) (MCPForUnity/Editor/Helpers/ComponentOps.cs)
  • Edited copy of a member (24 corresponding lines) (Server/src/services/tools/manage_gameobject.py)
  • Edited copy of a member (26 corresponding lines) (MCPForUnity/Editor/Helpers/ParamCoercion.cs)
  • Edited copy of a member (27 corresponding lines) (MCPForUnity/Editor/Helpers/VectorParsing.cs)
  • Edited copy of a member (27 corresponding lines) (MCPForUnity/Editor/Tools/Physics/PhysicsMaterialOps.cs)
  • Edited copy of a member (28 corresponding lines) (MCPForUnity/Editor/Tools/AssetGen/GenerateAudio.cs)
  • Edited copy of a member (29 corresponding lines) (TestProjects/AssetStoreUploads/Packages/com.unity.asset-store-tools/Editor/Previews/Scripts/Generators/Custom/TypeGenerators/ModelTypePreviewGenerator.cs)
  • Edited copy of a member (37 corresponding lines) (MCPForUnity/Editor/Tools/Physics/PhysicsQueryOps.cs)
  • Edited copy of a member (38 corresponding lines) (Server/src/cli/commands/ui.py)
  • Edited copy of a member (47 corresponding lines) (MCPForUnity/Editor/Tools/AssetGen/GenerateImage.cs)
  • Edited copy of a member (47 corresponding lines) (MCPForUnity/Editor/Tools/Physics/PhysicsQueryOps.cs)
  • …and 11 more

Changes since last survey

  • 1 commits — 1 feature/other, 0 fixes

By area

  • (root) — 1 commit

Notable commits

  • change: Update README.md

Architecture

  • Unchanged — 0 containers · 2 contexts · 0 edges

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

CoplayDev/unity-mcp was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 11 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit e2fd09c71644d1d9fa1ae134526ce913cbf97536 — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.29+preprod-106b68c3c303.