CoplayDev/unity-mcp

MCP for Unity is a bridge that connects the Unity Editor to external AI coding assistants and automated tools. It provides a comprehensive suite of editor-side tools for managing scenes, assets, physics, and animations, while a Python server handles the Model Context Protocol (MCP) communication. The system supports both local and remote deployments, enabling AI clients to inspect and modify the Unity environment programmatically.

61 changes.

The project underwent a major architectural shift by removing the legacy Python-based MCP server and editor components, replacing them with a new C\#-centric plugin structure and a Dockerized Python server. This period focused on establishing a robust HTTP transport layer, comprehensive test coverage, and extensive tooling for Unity editor integration.

30 changes.

This period focused on expanding the project's capabilities through a comprehensive CLI interface and new asset generation tools. The team introduced command-line management for animations, assets, and AI-driven content creation, alongside robust server process management and security improvements for API keys.

Added new utility modules in the CLI to support command-line interactions with Unity. This includes configuration management via environment variables (UNITY\_MCP\_HOST, UNITY\_MCP\_HTTP\_PORT, etc.), connection handling with HTTP client wrappers for sending commands and checking server health, output formatting for text/JSON/table representations, JSON parsing with automatic fixes for shell quoting issues, and helper functions for user confirmation prompts and typo-tolerant suggestions.

Server/src/cli/utils · high confidence

The serialization module now includes a new \UnityTypeConverters.cs\ file that provides custom JSON converters for Unity's core math types, including \Vector2\, \Vector3\, \Vector4\, \Quaternion\, \Color\, \Rect\, and \Bounds\. This enables these types to be directly serialized and deserialized to and from JSON objects or arrays, improving data interchange capabilities.

MCPForUnity/Runtime/Serialization · high confidence

The editor window now includes a dedicated Resources section that allows users to discover, filter, and enable or disable MCP resources. This new component provides bulk actions to enable or disable all resources, a rescan function to refresh the list, and individual toggles for each resource, with support for built-in and custom resource categories.

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

The VFX toolset now includes comprehensive support for LineRenderer and ParticleSystem components. For LineRenderer, the update introduces read, write, and creation capabilities, allowing users to get and set positions, width, color, and material properties, as well as create new lines, circles, arcs, and Bezier curves. For ParticleSystem, the update adds the ability to create new particle systems, control playback (play, stop, pause, restart, clear), and modify module states (emission, shape, color, size, velocity, noise, etc.). These changes expand the VFX tool to cover a broader range of visual effects, enabling more dynamic control over particle and line-based effects in the editor.

MCPForUnity/Editor/Tools/Vfx · high confidence

Users can now create and modify AnimatorControllers, add states and transitions, manage layers, and create or edit AnimationClips with curves and events. The new tools support 1D and 2D blend trees, preset animation clips, and reading/writing animator parameters and clip metadata.

MCPForUnity/Editor/Tools · high confidence

The MCP build tool now tracks build jobs and batch jobs through a new \BuildJob\ and \BuildRunner\ implementation. Users can schedule builds and poll for their status via a \BuildJobStore\ that manages job states (Pending, Building, Succeeded, Failed, Cancelled, Skipped). The \BuildRunner\ handles the actual build execution, extracting summary data (size, errors, warnings) and handling platform-specific build options, including a fix to avoid forcing PVRTC texture compression on Android. A \BuildSettingsHelper\ allows reading and writing player settings (product name, version, scripting backend, architecture), and \BuildTargetMapping\ resolves target names to Unity's \BuildTarget\ enums, with conditional support for VisionOS.

MCPForUnity/Editor/Tools/Build · high confidence

The MCPForUnity editor now includes a full suite of physics management tools, exposing operations for managing physics materials (create, configure, assign), joints (add, configure, remove), collision matrices (get, set), rigidbodies (get, configure), forces (apply), and queries (raycast, overlap, linecast, shapecast). A central dispatcher in ManagePhysics.cs routes actions to the respective operation classes, enabling users to inspect and modify the state of 2D and 3D physics objects, materials, and simulation settings directly through the MCP interface.

MCPForUnity/Editor/Tools/Physics · high confidence

Added new editor resource handlers for retrieving the active tool, current selection, open editor windows, and the enabled/disabled state of all discovered tools. These additions allow the MCP server to query the Unity editor's current state, including tool modes, selection details, window information, and tool configuration, enabling better synchronization and visibility into the editor environment.

MCPForUnity/Editor/Resources/Editor · high confidence

New editor resources have been added to the scene area, enabling read-only access to camera configurations, game object metadata and component lists, renderer features, rendering statistics, and volume settings. These additions expand the available commands for inspecting and managing scene data within the editor.

MCPForUnity/Editor/Resources/Scene · high confidence

A new Editor window titled 'EditorPrefs Manager' has been added to the MCP for Unity package. This tool allows users to view, search, and edit Unity EditorPrefs directly from the editor, which is useful for development and testing. The window displays a list of known MCP-related preferences, each showing the key, value, and type (String, Int, Float, or Bool), and allows users to create new entries or modify existing ones.

MCPForUnity/Editor/Windows/EditorPrefs · high confidence

Users can now compile and load C\# code at runtime within Unity without triggering a domain reload, using the Roslyn compiler. This feature, located in the CustomTools/RoslynRuntimeCompilation directory, provides a mechanism to dynamically generate assemblies from source code and execute them, supporting both static entry points and MonoBehaviour attachment. The implementation includes a static manager class for programmatic access and a MonoBehaviour component for direct scene integration, enabling workflows where code is generated and executed on the fly.

CustomTools · medium confidence

The MCP for Unity plugin now includes the Tommy TOML parser library (MIT licensed) to support configuration file handling. The plugin folder has been renamed to MCPForUnity, and the README has been updated to reflect the new structure and usage instructions.

MCPForUnity · high confidence

A new Unity test project structure has been added to the \TestProjects/AssetStoreUploads\ directory, including a \.gitignore\ file, a default scene, and URP settings. Additionally, the \com.unity.asset-store-tools\ package now includes a new \Api\ namespace containing C\# interfaces and base classes (such as \IAssetStoreApi\, \IAssetStoreClient\, and \AuthenticationBase\) that define the contract for the tool's internal API interactions.

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

New editor resource scripts (Layers.cs, ProjectInfo.cs, Tags.cs) expose 'get\_layers', 'get\_project\_info', and 'get\_tags' commands, allowing users to retrieve the current named layers, project configuration details (root, name, Unity version, platform, render pipeline, and installed packages), and all project tags via the MCP interface.

MCPForUnity/Editor/Resources/Project · high confidence

The project now includes new Unity scenes, specifically SampleScene and Test, which serve as the base environments for running unit tests. These scenes contain the necessary lighting, camera, and component host objects to support the test suite.

TestProjects/UnityMCPTests/Assets/Scenes · high confidence

Added three new utility modules to the server: a focus nudge system that temporarily brings Unity to the foreground to prevent OS-level throttling (especially on macOS), an OS-aware log path resolver that places logs in platform-appropriate directories (AppData/Library/XDG), and a shared module discovery utility for auto-registering tools and resources.

Server/src/utils · high confidence

Users can now run the MCP server as a standalone Docker container, enabling headless or remote-hosted deployments. The new Dockerfile and associated documentation provide a quick-start path for running the server via Docker, including support for remote-hosted mode with API key authentication, per-user session isolation, and environment variable configuration for security and logging.

Server · high confidence

The editor now displays the MCP for Unity brand mark as a resolution-independent vector graphic on Unity 2022.1 and newer, using the new \OceanMark\ component. On older Unity versions, it falls back to the existing raster icon. This change improves visual clarity across all supported Unity versions.

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

The MCPForUnity editor now includes a dedicated assembly definition (MCPForUnity.Editor.asmdef) that references the runtime library and the Newtonsoft.Json.dll precompiled dependency, and exposes internal members to the editor test assembly. A new McpCiBoot utility class provides a programmatic entry point to start the MCP client in headless CI environments by forcing the stdio transport. Additionally, a GetMenuItems resource has been added to the editor, allowing external tools to query and filter the list of available Unity menu items.

MCPForUnity/Editor · high confidence

Users can now control Unity animations via the new \animation\ CLI group, which includes commands to get and set Animator parameters, play states, and crossfade between animations. The \asset\ group provides commands to search, create, delete, duplicate, and move assets within the project. Additionally, the \asset-gen\ group introduces AI-powered asset generation, allowing users to generate 3D models, import marketplace models, generate images, and import local model files. These additions extend the CLI's capabilities for managing scene content and integrating external AI services.

Server/src/cli/commands · high confidence

Added configurators 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 Rider (GitHub Copilot). This allows the MCP for Unity editor to automatically detect and configure these clients, supporting both stdio and HTTP transports where applicable.

MCPForUnity/Editor/Clients/Configurators · high confidence

Added new backend services for remote-hosted authentication and custom tool management. The ApiKeyService validates API keys against an external endpoint, caching results and handling timeouts. The CustomToolService manages project-scoped and global custom tools, exposing HTTP routes for tool registration and execution, including support for long-running tools via a polling pipeline.

Server/src/services · high confidence

The server now supports an HTTP transport mode alongside the existing stdio transport, enabling remote-hosted deployments. This change adds a new \transport\ package containing \PluginHub\ (managing persistent WebSocket connections to Unity plugins), \PluginRegistry\ (in-memory session tracking), and \UnityInstanceMiddleware\ (per-session instance selection). The \unity\_transport\ module routes commands to Unity instances, enforcing API key authentication in remote-hosted mode and handling instance selection errors. Users can now run the server over HTTP, allowing multiple clients to connect simultaneously, with session isolation enforced by user ID.

Server/src/transport · high confidence

A new \McpForUnityResourceAttribute\ is added to the editor resources, allowing classes to be automatically discovered as MCP resource handlers. This attribute enables the system to route requests to any class implementing a public static \HandleCommand\ method, with an optional explicit resource name or an auto-generated snake\_case name derived from the class name. Additionally, several meta files are renamed to reflect the new resource structure, including \Editor\, \MenuItems\, \Project\, \Scene\, and \Tests\.

MCPForUnity/Editor/Resources · medium confidence

Users can now control the Unity Editor directly from the command line using the new 'unity-mcp' CLI tool. This release adds a full-featured command-line interface with global options for host, port, timeout, output format, and instance targeting, along with subcommands for status checks, instance listing, and raw command execution. The package is versioned at 1.0.0 and includes a detailed usage guide (CLI\_USAGE\_GUIDE.md) explaining syntax, common pitfalls, and command references for AI assistants and developers.

Server/src/cli · high confidence

Added new MCP tools for AI-driven asset generation (generate\_image, generate\_audio, generate\_model, import\_model) and arbitrary C\# code execution (execute\_code) within the Unity Editor. Introduced a batch\_execute tool to run multiple commands simultaneously for improved performance. Added a debug\_request\context tool for inspecting the current FastMCP request state. Implemented an ExternalChangesScanner to detect filesystem modifications outside of Unity's standard asset pipeline. The tools/\\init\\_.py now auto-discovers and registers all tools in the directory, with HTTP mode starting with only default tool groups enabled.

Server/src/services/tools · high confidence

A new Tools section has been added to the MCP for Unity editor window, providing a centralized UI for managing MCP tools. Users can now scan for and reconfigure tools, enable or disable all tools at once, and toggle project-scoped tools. The interface groups tools by category (e.g., Core, VFX, Animation) and distinguishes between built-in and custom tools, allowing users to manage tool states and discover new tools directly from the editor.

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

The 'manage\_gameobject' tool is now available for managing GameObjects in the active scene. It supports creating, modifying, deleting, and duplicating GameObjects, as well as moving them relative to other objects or making them look at a target. Users can also add, remove, and modify components on existing GameObjects, including setting properties, changing tags, layers, and static flags. The tool also supports instantiating prefabs and creating primitives.

MCPForUnity/Editor/Tools/GameObjects · high confidence

The editor now includes dedicated C\# model classes for managing MCP server and client configurations. New types include McpConfigServer (defining command, arguments, transport type, and URL), McpConfigServers (container for server definitions), McpConfig (root configuration with mcpServers), and McpClient (tracking client status, paths, and transport capabilities). Additionally, McpStatus and ConfiguredTransport enums define the possible states and transport types for MCP clients. These models support the editor's ability to configure and monitor MCP clients, including handling transport mismatches and status updates.

MCPForUnity/Editor/Models · high confidence

The editor now uses a new \PlatformDetectors\ module that detects Python and the \uv\ package manager on Linux, macOS, and Windows. Each platform has a dedicated detector (e.g., \LinuxPlatformDetector\) that validates installed versions, resolves paths, and provides installation recommendations. This replaces the previous generic detection logic with a structured, extensible interface (\IPlatformDetector\) and base class (\PlatformDetectorBase\) that handle cross-platform differences in how Python and \uv\ are found and validated.

MCPForUnity/Editor/Dependencies/PlatformDetectors · high confidence

Added a new set of interfaces and their implementations in the Editor's server service layer to manage the local HTTP server lifecycle. This includes IPidFileManager and PidFileManager for tracking server PIDs and handshake state across Unity domain reloads, IProcessDetector and ProcessDetector for inspecting and identifying MCP server processes on Windows and Unix, IProcessTerminator and ProcessTerminator for safely killing server processes, IServerCommandBuilder and ServerCommandBuilder for constructing the uvx launch commands, and ITerminalLauncher and TerminalLauncher for launching headless or interactive terminal sessions. These changes provide the underlying infrastructure for launching, monitoring, and terminating the local HTTP server.

MCPForUnity/Editor/Services/Server · high confidence

Added new Python models in the server's models package to standardize API responses and tool definitions. The \MCPResponse\ and \ToolDefinitionModel\ classes define the structure for server responses and tool metadata, including a new \max\_poll\_seconds\ field for long-running tools. Additionally, \UnityInstanceInfo\ tracks Unity editor instances, and the \unity\_response\ module provides utilities to normalize and parse Unity's transport payloads into consistent \MCPResponse\ shapes.

Server/src/models · high confidence

The server now includes a central configuration module (config.py) that defines network, transport, and timeout settings, including a default host of 127.0.0.1. A new telemetry system (telemetry.py) is added to collect anonymous usage data and milestones, with an option to disable it via environment variables. Additionally, logging decorators (logging\_decorator.py, telemetry\_decorator.py) are introduced to track tool and resource usage for both sync and async functions.

Server/src/core · high confidence

The documentation site has been rebuilt using Docusaurus 3.x, providing a modern, minimalist layout with auto-generated tool and resource references. The new site includes a dynamic homepage displaying real-time statistics (such as the number of supported clients and tools), a structured sidebar navigation, and a brand-neutral URL policy to future-proof against product name changes. The site is configured to be hosted on GitHub Pages under the CoplayDev organization.

website · high confidence

A new 'Advanced Settings' section has been added to the MCPForUnity editor window, providing a centralized interface for managing server sources, debug logging, and deployment paths. Users can now override the uvx executable path, specify a local Git URL for the server source, and configure toggles for debug logging, log recording, and dev mode refresh. The panel also includes controls for auto-starting the server on load, allowing LAN binding, enabling insecure remote HTTP, and managing screenshot and package deployment directories.

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

A new 'Asset Generation' tab has been added to the MCPForUnity editor window. This configuration-only interface allows users to manage API keys for supported providers (Tripo, Meshy, Sketchfab, fal, OpenRouter) using the OS secure store rather than project files. Users can also set default 3D model formats (glb, fbx, obj), specify an output root directory, and enable auto-normalization of imported models.

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

A new 'Client Configuration' section has been added to the MCP for Unity editor window. This component provides a centralized interface for managing client settings, including a dropdown to select between detected clients, a 'Configure All' button, and a 'Per-client setup' foldout. The foldout displays the client's status, allows manual configuration via a JSON editor, and exposes client-specific paths (such as the Claude CLI path and project directory) that appear contextually based on the selected client.

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

The server now exposes a comprehensive set of read-only MCP resources for inspecting the Unity editor's state and scene contents. This includes querying the active tool, camera configuration, custom tools, editor state (compilation, tests, assets), game objects, layers, menu items, prefabs (info and hierarchy), prefab editing stage, project info, renderer features, rendering stats, selection, tags, tests, tool groups, and open windows. These resources allow users to query the current editor context, inspect scene objects and their components, review project configuration, and monitor editor status without modifying state.

Server/src/services/resources · high confidence

A new ManagePrefabs tool has been introduced to the editor, providing a centralized interface for managing Unity prefabs. Users can now create prefabs from GameObjects, inspect and retrieve hierarchy information, and perform headless modifications to prefab contents. The tool also supports interactive prefab stage workflows, allowing users to open, save, and close prefab stages directly through the editor.

MCPForUnity/Editor/Tools/Prefabs · high confidence

Added several new helper classes in the Editor/Helpers directory to support the asset generation feature and improve editor stability. AssetGenPaths and AssetGenPrefs manage project-relative path conversion and user preferences for the asset generation tools. AssetPathUtility provides safe path sanitization and package root detection. CodexConfigHelper generates TOML configuration for the Codex CLI. ComponentOps handles low-level GameObject component operations. ConfigJsonBuilder constructs JSON configuration for MCP clients. EditorWindowScreenshotUtility captures scene view screenshots. ExecPath resolves the Claude CLI path. These changes introduce new capabilities for asset generation and improve the reliability of editor interactions.

MCPForUnity/Editor/Helpers · high confidence

The AssetGen toolset now provides dedicated handlers for generating audio, images, and 3D models, each supporting asynchronous job polling via a shared \status\/\cancel\/\list\_providers\ helper. A new \import\_model\ tool enables searching and importing 3D assets from the Sketchfab marketplace, while \import\_model\_file\ allows importing local 3D model files (FBX, OBJ, glTF, ZIP) into the Unity project. All tools enforce secure key storage and path normalization, with specific validation for each asset type's requirements.

MCPForUnity/Editor/Tools/AssetGen · medium confidence

The AssetGen service now includes a central job manager that tracks and polls external AI providers (Fal, OpenRouter, Tripo, Meshy, Sketchfab) for image, 3D model, and audio generation. The new \AssetGenJobManager\ coordinates the submit-poll-import lifecycle on the Unity main thread, while \AssetGenModelCatalog\ provides a curated list of available models with metadata for the UI. A new HTTP transport layer (\IHttpTransport\ and \UnityWebRequestTransport\) abstracts network calls, enabling testability via \FakeHttpTransport\. Import pipelines for audio, image, and 3D models are now handled by dedicated pipeline classes (\AudioImportPipeline\, \ImageImportPipeline\, \ModelImportPipeline\) that apply Unity-specific settings (e.g., load type, sprite vs texture) and enforce security constraints (e.g., safe zip extraction, extension allowlists).

MCPForUnity/Editor/Services/AssetGen · high confidence

The editor window now features a dedicated Connection section that consolidates transport protocol selection (HTTP local, HTTP remote, or stdio), HTTP URL and port configuration, and connection status monitoring. Users can now explicitly choose between local and remote HTTP transports, manage API keys for remote servers, and view real-time connection status and health checks within a single, unified interface.

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

The Editor now includes a new dependency management system that automatically detects and validates the presence of Python 3.10+ and the uv package manager on Windows, macOS, and Linux. This system provides a comprehensive check of all required tools, generates user-friendly summaries of the system's readiness, and offers direct installation recommendations and URLs for missing dependencies, streamlining the initial setup process for MCP for Unity.

MCPForUnity/Editor/Dependencies · high confidence

A new menu script (MCPForUnityMenu.cs) was added to the Editor/MenuItems directory, exposing three new entries under the 'MCP for Unity' menu: 'Toggle MCP Window' to open the main editor window, 'Local Setup Window' for setup tasks, and 'Edit EditorPrefs' to open a debugging window for configuration. This provides direct access to these editor windows from the Unity menu bar.

MCPForUnity/Editor/MenuItems · high confidence

Added a new "Unity MCP Skill Install (Sync)" editor window that allows users to sync Unity MCP skills from a GitHub repository using safe, incremental mirroring without cloning the full repository. Additionally, a new Roslyn installer was added to automatically download and install the required Microsoft.CodeAnalysis DLLs (v4.12.0) and dependencies (System.Runtime.CompilerServices.Unsafe v6.0.0) into the project's Plugins/Roslyn folder, enabling runtime\_compilation tools.

MCPForUnity/Editor/Setup · high confidence

The editor window now includes dedicated components for managing advanced settings, asset generation, client configuration, connection status, resource display, tool inspection, and validation. A shared stylesheet (Common.uss) is introduced to standardize the appearance of these sections, including styling for status indicators, setting rows, and narrow-width layout adjustments.

MCPForUnity/Editor/Windows/Components · high confidence

The website's homepage has been redesigned with a modern, minimalist 'terminal-blueprint' aesthetic. This includes new React components for the hero section (displaying the latest version, install links, and a demo video), a features grid, an architecture diagram, a stats/spec sheet, and a closing CTA with research citation. A new \CopyButton\ component has been added to provide a 'copy to clipboard' utility with a 1.5s confirmation state and legacy fallback support.

website/src/components · high confidence

A new \manage\_profiler\ tool has been added to the Profiler tool group, providing a unified interface for CPU timing, garbage collection allocation, and animation profiling. Users can now start, stop, and check the status of the Unity profiler, retrieve frame timing data via \FrameTimingManager\, query counter values asynchronously, and inspect per-object memory usage. The tool also supports taking, listing, and comparing memory snapshots, as well as enabling and querying the Frame Debugger for event extraction. This change introduces new operations for session management, counter retrieval, memory snapshotting, and frame debugging, all accessible through the \MCPForUnity\ editor interface.

MCPForUnity/Editor/Tools/Profiler · high confidence

The editor window now includes a new Script Validation section allowing users to choose between Basic, Standard, Comprehensive, and Strict validation levels, with descriptions for each. Additionally, the setup wizard has been updated to include a client configuration step where users can select which MCP clients to configure, or skip the step entirely.

MCPForUnity/Editor/Windows · high confidence

Added StdioBridgeHost, StdioTransportClient, and WebSocketTransportClient to the transport layer. The stdio client now waits for the bridge to become ready before reporting success, preventing false 'Bridge not running' errors during domain reloads. The WebSocket client now enforces remote URL security checks and manages connection lifecycle with keep-alives and reconnection logic.

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

Added several new scripts and reference files in the tools/ directory to improve build verification and documentation maintenance. A new compile-check.sh script enables a headless, license-free C\# compilation check using Unity's Roslyn compiler and reference assemblies, ensuring PRs are verified without requiring a Unity Editor license. A local parity check script (check-unity-versions.sh and .ps1) validates the CI Unity-version matrix by running compile-only or full EditMode tests against installed or Dockerized Unity versions. Additionally, a Python script (generate\_docs\_reference.py) and an LLM prompt (UPDATE\_DOCS\_PROMPT.md) were added to automate the generation of Docusaurus reference pages and keep documentation in sync with the codebase.

tools · high confidence

The repository received a comprehensive documentation and infrastructure update. A new \CLAUDE.md\ file was added to provide detailed architectural guidance for AI assistants and developers, while the \README.md\ was significantly restructured with a new header, community links, and a citation block. The project also adopted a Contributor Covenant Code of Conduct (\CODE\_OF\_CONDUCT.md\), a security policy (\SECURITY.md\), and a \licensing\ file (\LICENSE\). Additionally, a Python helper script (\mcp\_source.py\) was introduced to manage package sources, and various configuration files (\.dockerignore\, \.gitattributes\, \docker-compose.yml\) were added or updated to support development workflows.

(repo-wide) · high confidence

The server entry point (main.py) and package init are added, establishing the core startup sequence, telemetry, and logging configuration. Logging is redirected to a rotating file that follows OS conventions, with Windows-specific event loop and file-locking fixes. The server registers custom tools, resources, and plugin registries, and supports an HTTP server mode for tool registry access.

Server/src · medium confidence

Added scripts to generate the site's favicon and icon set from the brand SVG, and to fetch and render a unified adoption statistics dashboard. The new stats script (\fetch-stats.mjs\) consolidates GitHub metrics (stars, forks, cloners, viewers) and web pageviews, leading with honest user signals while explicitly labeling PyPI download counts as an inflated proxy. The brand asset script (\gen-brand-assets.mjs\) rasterizes the logo mark into various PNG sizes for the site's static assets.

website/scripts · high confidence

The legacy command handlers for assets, scenes, objects, materials, scripts, and editor control have been removed from the Editor/Commands directory. This eliminates the previous set of editor commands, meaning users can no longer perform operations such as importing assets, instantiating prefabs, scene management, object modification, or script creation through these specific handlers.

Editor/Commands · high confidence

The Python-based Unity MCP server implementation has been removed from the codebase. This includes the deletion of the server entry point (\server.py\), the Unity connection manager (\unity\_connection.py\), the configuration module (\config.py\), and the \.python-version\ and \uv.lock\ dependency lockfiles. This change eliminates the Python side of the Model Context Protocol integration with Unity.

Python · high confidence

The Python tools for managing Unity editor state (play, pause, stop, undo, redo, build, execute commands), scene operations (open, save, create, change scenes), object inspection and manipulation, asset management, and script handling have been removed. This eliminates the ability to programmatically control the Unity editor, modify scene objects, or manage assets and scripts via the Python tools directory.

Python/tools · high confidence

The editor now stores AI provider API keys in a secure, cross-platform key store rather than plain text. On macOS, Windows, and Linux, the editor uses the OS native secure stores (Keychain, Credential Manager, or libsecret) with an encrypted-file fallback, and supports environment-variable overrides for CI or headless use. Additionally, a secret redactor scrubs auth headers and keys from logs and error messages to prevent accidental exposure.

MCPForUnity/Editor/Security · high confidence

The editor's internal architecture for managing the MCP bridge and client configuration has been restructured. A new \BridgeControlService\ now handles starting, stopping, and verifying the HTTP or stdio transport bridge, including automatic resume after domain reloads. Client configuration is managed by \ClientConfigurationService\, which applies transport coercion to ensure clients are configured for the active transport (HTTP or stdio). Additionally, \EditorConfigurationCache\ centralizes EditorPrefs access for settings like transport mode and debug logs, while \EditorStateCache\ provides a fast, cached snapshot of the editor's state. These changes improve stability during domain reloads and provide a more robust foundation for the HTTP transport system.

MCPForUnity/Editor/Services · high confidence

A new SVG logo mark (logo-mark.svg) has been added to the website's static assets. This graphic, featuring a split-cube design with blue and teal tones, serves as the updated visual identity for the product.

website/static/img · high confidence

The MCPForUnity/Runtime directory now includes an Assembly Definition file (MCPForUnity.Runtime.asmdef) which defines the module's namespace and compilation scope. Additionally, AssemblyInfo.cs has been added to explicitly grant internal access to the editor and test assemblies, ensuring that internal members are accessible for testing and editor integration while remaining encapsulated from the rest of the application.

MCPForUnity/Runtime · high confidence

A new shell script, validate-nlt-coverage.sh, has been added to the repository. This script checks for the presence of specific NLT fragment result files (NL-0 through NL-4 and T-A through T-J) in the reports directory, ensuring that all expected test outputs are generated.

scripts · medium confidence

The editor now automatically detects and migrates legacy embedded server preferences and updates stdio-based client configurations when the package version changes. This ensures that existing client setups are updated to the current transport and version requirements without manual intervention, while safely skipping clients that are incompatible with the current transport settings.

MCPForUnity/Editor/Migrations · medium confidence

The editor now uses dedicated constant classes to manage all EditorPrefs keys and UI labels. This includes a new \EditorPrefKeys\ class that consolidates all preference keys (such as \MCPForUnity.UseHttpTransport\, \MCPForUnity.DebugLogs\, and \MCPForUnity.Security.AllowLanHttpBind\) into a single location to prevent typos and simplify future migrations. Additionally, \AuthConstants\ defines the \X-API-Key\ header name, \HealthStatus\ provides standard health check strings, and \ProductInfo\ centralizes the product name and menu path. These changes standardize how the editor stores and references its configuration data.

MCPForUnity/Editor/Constants · high confidence

Added .nojekyll to disable Jekyll processing and created a robots.txt file to allow all user-agents and specify the sitemap location, ensuring the Docusaurus site deploys correctly on GitHub Pages.

website/static · medium confidence

The server now uses a new registry system in the \Server/src/services/registry\ package to manage MCP tools and resources. This system supports grouping tools (e.g., 'core', 'docs', 'profiling') and allows for dynamic visibility control, where tools can be toggled on or off in real-time based on their group. The \mcp\_for\_unity\_tool\ decorator now accepts a \unity\_target\ parameter to control how tools are exposed to the user, and tools can be assigned to specific groups that map to FastMCP tags. This enables the 'Meta tool' feature to manage tool context and visibility dynamically.

Server/src/services/registry · high confidence

The editor now uses a new \IMcpClientConfigurator\ interface and a \McpClientRegistry\ to manage MCP client configurations. This refactors how clients are discovered, configured, and unregistered, providing a consistent API for status checks, transport selection, and manual snippets. The registry auto-discovers all registered configurators, ensuring each client's configuration lifecycle is handled uniformly.

MCPForUnity/Editor/Clients · high confidence

Added a new set of helper classes in the Runtime/Helpers directory to abstract away breaking or deprecated Unity API changes across versions. This includes UnityFindObjectsCompat for FindObjectsByType/FindAnyObjectByType, UnityObjectIdCompat for the InstanceID/EntityId migration, UnityPhysicsCompat for autoSyncTransforms and simulationMode changes, and UnityAssembliesCompat for assembly enumeration. These shims ensure the package compiles and functions correctly across Unity 2021 LTS through 6.x and CoreCLR 6.8, preventing CS0618/CS0619 warnings and handling API removals gracefully.

MCPForUnity/Runtime/Helpers · high confidence

The Docusaurus documentation site has been restyled with a modern, minimalist aesthetic. This introduces the Satoshi and JetBrains Mono typefaces, refines the color palette for both light and dark modes, and applies a cleaner layout with tighter headings, improved code block styling, and a reduced-height navbar. The search input in the navbar is now centered on desktop, and the keyboard shortcut hints are styled to match the new minimalist theme.

website/src/css · high confidence

The Editor area has been cleaned up by removing the MCPEditorWindow, UnityMCPBridge, and Vector3Helper files. This eliminates the legacy Unity editor window, the TCP-based bridge service, and the associated helper utilities, likely as part of a broader refactoring or migration of the editor's functionality.

Editor · high confidence

The server now uses a new \PortDiscovery\ module that scans for per-project port registry files (preferring the most recently modified) and verifies the port is actually a MCP for Unity listener before connecting. This replaces the previous single-file registry approach, reducing conflicts between projects. Additionally, the \UnityConnection\ class now implements a strict handshake requiring \FRAMING=1\ and includes a preflight check to detect and discard stale sockets caused by domain reloads, preventing connection hangs.

Server/src/transport/legacy · high confidence

The editor's transport layer has been refactored to use a new \IMcpTransportClient\ interface and a \TransportManager\ that coordinates HTTP (WebSocket) and stdio connections. A new \TransportCommandDispatcher\ ensures that MCP commands are executed on the Unity main thread, preventing race conditions and improving stability during domain reloads and connection retries.

MCPForUnity/Editor/Services/Transport · high confidence

Add test assembly for UnityEvent and custom component validation; Added PlayMode test suite for Unity coroutine and frame progression; Added automated tests for the GetTests and GetTestsForMode editor resources; Added characterization and regression tests for editor Windows; Added characterization tests for Editor Services; Added comprehensive EditMode tests for MCP tools; Added deterministic E2E smoke test for the Python-Unity bridge; Added edit-mode tests for client configuration and transport detection; Added edit-mode tests for helper utilities; Added edit-mode tests for server process management and command building; Added edit-mode tests for the Asset Gen subsystem; Added test assets and UI theme configuration; Added test helper scripts for Unity integration testing; Added test project structure for Edit, Editor, and Play modes; Added tests for asset generation tools and CLI; Expanded EditMode test coverage for editor services and utilities; Expanded integration test coverage for server components.

The project has been restructured to separate the Unity package, Python server, and documentation into distinct, well-defined locations. The Unity package is now defined in MCPForUnity/package.json, specifying version 10.1.3-beta.3 and its Unity module dependencies. The Python server configuration has been moved to Server/pyproject.toml, establishing the 'mcpforunityserver' package with updated dependencies like fastmcp, mcp, and pydantic. The old Python/ directory containing the previous pyproject.toml and requirements.txt has been removed. Additionally, the website's Docusaurus configuration has been added in the website/ directory, and the root package.json has been removed.

(dependencies) · high confidence

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

• CAI 64 → 61 (-3.3)
• Rubric changed (rubric-2026.08.18 → rubric-2026.08.19) — scores are not directly comparable.

• Code Health 97 → 97 (-0.0)
• Architecture 99 → 98 (-0.4)
• Maturity 69 → 68 (-0.6)
• Readiness 53 → 46 (-6.7)
• Security 66 → 66 (-0.1)

• Build action pinned to a mutable branch
• Duplicated block (10 lines × 2) (Server/src/services/tools/manage_prefabs.py)
• Duplicated block (10 lines × 2) (Server/src/services/tools/script_apply_edits.py)
• Duplicated block (10 lines × 2) (Server/src/services/tools/script_apply_edits.py)
• Duplicated block (11 lines × 2) (Server/src/cli/commands/batch.py)
• Duplicated block (11 lines × 2) (Server/src/services/tools/manage_prefabs.py)
• Duplicated block (11 lines × 2) (Server/src/services/tools/manage_script.py)
• Duplicated block (11 lines × 3) (Server/src/cli/commands/camera.py)
• Duplicated block (11 lines × 3) (Server/src/services/tools/manage_scene.py)
• Duplicated block (12 lines × 2) (Server/src/cli/commands/code.py)
• Duplicated block (12 lines × 2) (Server/src/services/tools/manage_texture.py)
• Duplicated block (12 lines × 3) (Server/src/cli/commands/camera.py)
• Duplicated block (12 lines × 4) (Server/src/cli/commands/animation.py)
• Duplicated block (13 lines × 2) (Server/src/cli/commands/texture.py)
• Duplicated block (13 lines × 2) (Server/src/core/telemetry_decorator.py)
• Duplicated block (14 lines × 2) (Server/src/services/tools/script_apply_edits.py)
• Duplicated block (15 lines × 2) (Server/src/core/telemetry_decorator.py)
• Duplicated block (15 lines × 2) (Server/src/services/tools/script_apply_edits.py)
• Duplicated block (15 lines × 2) (Server/src/transport/unity_instance_middleware.py)
• Duplicated block (16 lines × 2) (Server/src/cli/commands/code.py)
• …and 17 more

• Change coupling: debug_request_context.py ↔ set_active_instance.py (Server/src/services/tools/debug_request_context.py)
• Change coupling: manage_components.py ↔ manage_gameobject.py (Server/src/services/tools/manage_components.py)
• Duplicated block (10 lines × 2) (Server/src/services/tools/manage_prefabs.py)
• Duplicated block (10 lines × 2) (Server/src/services/tools/manage_script.py)
• Duplicated block (10 lines × 3) (Server/src/cli/commands/camera.py)
• Duplicated block (10 lines × 3) (Server/src/services/tools/manage_scene.py)
• Duplicated block (11 lines × 2) (Server/src/cli/commands/camera.py)
• Duplicated block (11 lines × 2) (Server/src/services/tools/manage_texture.py)
• Duplicated block (11 lines × 3) (Server/src/cli/commands/camera.py)
• Duplicated block (11 lines × 4) (Server/src/cli/commands/animation.py)
• Duplicated block (12 lines × 2) (Server/src/cli/commands/texture.py)
• Duplicated block (12 lines × 2) (Server/src/core/telemetry_decorator.py)
• Duplicated block (13 lines × 2) (Server/src/core/telemetry_decorator.py)
• Duplicated block (13 lines × 2) (Server/src/services/tools/script_apply_edits.py)
• Duplicated block (14 lines × 2) (Server/src/cli/commands/component.py)
• Duplicated block (14 lines × 2) (Server/src/core/telemetry_decorator.py)
• Duplicated block (14 lines × 2) (Server/src/services/tools/script_apply_edits.py)
• Duplicated block (14 lines × 2) (Server/src/transport/unity_instance_middleware.py)
• Duplicated block (15 lines × 2) (Server/src/cli/commands/code.py)
• Duplicated block (24 lines × 2) (Server/src/services/tools/manage_graphics.py)
• …and 20 more

• 34 commits — 25 feature/other, 9 fixes

• (repo) — 18 commits
• MCPForUnity/package.json — 7 commits
• (root) — 2 commits
• MCPForUnity/Editor — 2 commits
• Server/tests — 2 commits
• website/docs — 2 commits
• .github/workflows — 1 commit

• fix: Merge pull request #1250 from beast-ofcourse/fix/execute-code-bom-phantom-error
• fix: Merge pull request #1298 from asavs/fix/gameobject-create-component-properties
• fix: Merge pull request #1302 from KamilDev/fix/resource-uri-prose
• fix: Merge pull request #1304 from Scriptwonder/fix/1288-tool-annotations
• fix: Merge pull request #1305 from Scriptwonder/fix/1193-restore-codex-http
• fix: Merge pull request #1308 from Scriptwonder/fix/ci-fork-pr-signal
• fix: Merge pull request #1314 from Scriptwonder/fix/ci-compile-check
• fix: fix(server): address resources by URI in agent-facing prose
• fix: fix: deduplicate CodeDom assembly references
• change: Merge pull request #1300 from kpkhxlgy0/codex/codedom-assembly-dedup
• change: Merge pull request #1306 from CoplayDev/beta-version-10.1.1-beta.3-30753972755
• change: Merge pull request #1307 from CoplayDev/beta-version-10.1.1-beta.4-30755957460
• change: Merge pull request #1309 from CoplayDev/beta-version-10.1.1-beta.5-30756436245
• change: Merge pull request #1310 from CoplayDev/beta-version-10.1.1-beta.6-30765582021
• change: Merge pull request #1311 from Scriptwonder/docs/multi-agent-http-findings
• change: Merge pull request #1312 from CoplayDev/release/v10.1.2
• change: Merge pull request #1313 from CoplayDev/sync/main-v10.1.2-into-beta-30766000799
• change: Merge pull request #1315 from CoplayDev/beta-version-10.1.3-beta.2-30767776542
• change: Merge pull request #1317 from CoplayDev/beta-version-10.1.3-beta.3-30827275259
• change: chore: bump version to 10.1.2
• …and 14 more

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

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.