Unity Version Control
Unity Version Control is a distributed version control system (VCS) and source code management tool optimized for game development and real-time 3D projects, enabling teams to track changes, collaborate efficiently, and handle large binary files such as assets and media with superior speed and scalability.[1][2] Previously known as Plastic SCM, it was developed by Codice Software and acquired by Unity Technologies in August 2020, after which it was rebranded and integrated deeply into the Unity ecosystem to support engine-agnostic workflows across disciplines like art, programming, and design.[3][1] The system supports both cloud-hosted and on-premises deployments, allowing flexibility for teams of varying sizes, from small indie developers to large studios, with a free tier available for up to three users and 5 GB of monthly storage before transitioning to a pay-as-you-go model based on active users and cloud usage.[1] Key features include Smart Locks, which reduce merge conflicts by enforcing exclusive checkouts on specific files or branches, and role-based workflows that separate artist and programmer pipelines to streamline collaboration without disrupting creative processes.[1][2] It integrates seamlessly with the Unity Editor via the Unity Hub for repository creation and management, as well as with external tools like IDEs (e.g., Rider), issue trackers (e.g., JIRA), and CI/CD pipelines (e.g., Jenkins, TeamCity), making it suitable for cross-platform development on Windows, macOS, and Linux.[1][2] Notable for its performance with massive repositories—often exceeding those of traditional VCS like Git for binary-heavy projects—Unity Version Control emphasizes distributed development, code reviews, and user/group permissions managed through the Unity Dashboard, ultimately boosting productivity in fast-paced game production environments.[1][2] By prioritizing intuitive interfaces and conflict minimization, it addresses common pain points in game dev teams, such as version conflicts from simultaneous asset edits, while supporting centralized or fully distributed models to fit diverse team structures.[1]Overview and History
Overview
Unity Version Control (UVCS) is a scalable, engine-agnostic distributed version control system (VCS) developed by Unity Technologies, optimized for handling large binary files common in game assets such as 3D models, textures, and audio.[1] Formerly known as Plastic SCM, it provides robust source code management capabilities tailored for collaborative development environments.[2] Following Unity Technologies' acquisition of Codice Software, the developer of Plastic SCM, in August 2020, the tool was rebranded to Unity Version Control, with full integration into Unity's ecosystem achieved by 2021.[3][2] This rebranding aligned the VCS more closely with Unity's DevOps offerings, enhancing its accessibility for game developers.[1] UVCS serves primary use cases in source code and asset management for collaborative teams in game studios, supporting artists, programmers, and designers through efficient versioning of project elements.[1] In enterprise setups, it supports unlimited users, handles large-scale repositories suitable for extensive game projects, and offers cross-platform clients for Windows, macOS (including Apple Silicon), and Linux.[2]Development History
Unity Version Control traces its origins to Plastic SCM, developed by the Spanish company Codice Software, which was founded in 2005.[4] The tool's initial release occurred in 2006, marking the debut of a distributed version control system designed for software development teams handling large repositories.[5] Key early milestones included the introduction of enhanced distributed capabilities in version 2.0 around 2008, followed by improved merging tools in version 4.0, released in late 2011.[6] Version 5.0, launched in 2013, added Gluon mode to simplify workflows for non-developers working with binary assets like art files.[7] In January 2017, version 6.0 debuted Jet storage as the default backend, optimizing performance for high-volume repositories through a custom, file-based system that outperformed traditional database approaches.[8] Version 7.0, released in March 2018, expanded support for cloud-hosted repositories, enabling seamless remote collaboration without on-premises infrastructure.[9] The pre-acquisition version 9.0 arrived in August 2020, incorporating refinements to GUI usability and integration tools. On August 17, 2020, Unity Technologies acquired Codice Software, integrating Plastic SCM into its ecosystem to bolster version control for game developers.[3] Following the acquisition, the tool was rebranded as Unity Version Control in 2021 and tightly integrated with Unity Hub for streamlined project management.[2] Versions 10.x, spanning 2022 to 2023, focused on enhancing cloud scalability to handle growing data volumes in collaborative environments.[10] The 11.x series, developed from 2022 to 2025, introduced native ARM support for macOS installers, enabling efficient operation on Apple Silicon hardware, alongside updates to SemanticMerge for compatibility with C# 12 features.[11][12] The latest release, 11.0.16.9772, was issued on November 13, 2025 (as of November 18, 2025).[13] Over time, the platform evolved from a general-purpose version control system to one optimized for game development, exemplified by the 2024 Unity 6 Edition, which deepened integration with the Unity Editor for handling large binary files and multiplayer workflows.[14] This shift emphasized artist-programmer collaboration and real-time 3D asset management.[1]Core Design and Architecture
System Architecture
Unity Version Control operates on a client-server architecture, with a central server managing repositories that can be hosted in the cloud via Unity Cloud or deployed on-premises for self-managed environments. This setup enables scalable collaboration across teams, supporting repositories that handle large-scale game assets and codebases without inherent size limitations beyond hardware constraints. Clients connect to the server to perform version control operations, ensuring centralized oversight while allowing flexible deployment options tailored to organizational needs.[15] Clients encompass a range of interfaces for diverse workflows, including a command-line interface (CLI) for scripting and automation, graphical user interfaces (GUIs) such as the GUI for developer-focused tasks and Gluon for artist-friendly interactions, and dedicated plugins for integrated development environments (IDEs) like Visual Studio and JetBrains Rider. These components facilitate direct interaction with the server, enabling users to clone repositories, commit changes, and resolve conflicts efficiently. The architecture supports full repository clones on the client side, embodying distributed version control system (DVCS) principles that permit offline development and subsequent synchronization via push and pull mechanisms to the central server.[15][2][1] Security and access controls are implemented through access control lists (ACLs), which provide granular permissions for users and groups on repositories and operations. Personal access tokens (PATs) were introduced in version 11.0.16.9637 (September 2025) to enable secure, token-based authentication specifically for CI/CD integrations, enhancing automation without exposing credentials; the system also accommodates self-signed certificates for secure on-premises connections.[15][11] At the integration layer, Unity Version Control features deep hooks into the Unity Editor, allowing automatic asset versioning, change detection, and workflow automation directly within the development environment. API support extends to DevOps tools, including plugins for Jenkins to automate builds and deployments, and Jira for issue tracking and task-driven branching; these capabilities were bolstered by an enhanced REST API in version 11.0.16.9656 (October 2025). Storage backends like Jet underpin data management for optimized performance.[2][16][17][11]Data Storage and Management
Unity Version Control employs the Jet backend as its default storage mechanism, introduced in version 6.0 in 2017. This proprietary, NoSQL-like system utilizes a filesystem-based approach for efficient data and metadata handling, particularly excelling in fast indexing and management of large binary files common in game development.[18] It outperforms traditional SQL databases by factors of 10-40x in metadata operations, enabling 3-5x faster server performance for substantial check-ins.[18] For smaller-scale deployments, alternative relational database backends such as MySQL, SQL Server, and SQLite are available, allowing flexibility based on setup size and requirements.[18] The system's versioning model centers on atomic commits organized into changesets, where all modifications in a single check-in are applied indivisibly to maintain repository consistency. Each file and directory functions as a distinct item assigned a unique identifier (item ID) for accurate tracking throughout its revision history.[19] Directory versioning treats folders as versionable entities, preserving tree structure and enabling precise reconstruction of project hierarchies across changes. To mitigate conflicts with non-mergeable assets, large file locking provides exclusive access, ensuring collaborative integrity for binaries like textures and models. Performance optimizations enhance data handling efficiency, including asynchronous Virtual File System (VFS) processing in version 11.0.16.9692 (October 2025), which offloads filesystem change detection to avoid blocking the main thread and boosts integrated development environment (IDE) speed.[20] The command-line interface (CLI) purge tool facilitates storage management by removing unused old revisions, as demonstrated by deleting 77 revisions totaling 290 MB via commands likecm purge register ".png" "2023-Jun-21 13:40".[21] Additionally, partial workspaces support shelvesets through CLI options such as cm shelveset apply --dontcheckout (introduced in 11.0.16.9579), allowing application of pending changes without a complete workspace checkout.[20]
Data scalability supports repositories up to petabyte levels, accommodating the expansive needs of enterprise game studios with massive asset libraries.[22] Full Unicode support for double-byte languages and emojis was implemented in version 11.x via updates to the Avalonia UI framework, ensuring compatibility with diverse international content.[20] Checkout operations for large file sets have been significantly accelerated, with version 11.0.16.9546 (July 2025) reducing time for 15,000 files from 46 seconds to 10 seconds—a roughly 4.6x improvement—via CLI optimizations.[20]
Key Features
Branching and Merging Capabilities
Unity Version Control supports unlimited branching to facilitate parallel development streams without restrictions on the number of branches. The Visual Branch Explorer provides a graphical visualization of branch and merge history, allowing users to view repository evolution through an interactive diagram that displays changesets, branches, and merges. This tool includes filters for date, branch, and user to streamline navigation, along with features like branch hiding and manual relayout for customized views. Introduced and enhanced in version 11.x, the quick branch switching menu enables rapid transitions between branches via a top-level interface with case-insensitive filtering, preserving context and supporting options like "Shelve & Switch" to handle pending changes during switches.[11][23] Advanced merging capabilities in Unity Version Control are powered by the SemanticMerge tool, which performs code-aware merges by analyzing syntax and semantics rather than line-based comparisons. SemanticMerge supports C# 12 syntax and is enabled by default starting in version 11.0.16.7935, with cross-platform availability on Windows, macOS, and Linux. It effectively handles complex scenarios, such as directory moves and refactoring operations, by preserving structural intent during integration. Server-side improvements in 11.x further optimize merge performance, achieving up to 500 times faster resolution for ChangeDelete conflicts—for instance, reducing processing time from two hours to 15 seconds for datasets with 2 million items—through enhanced conflict detection and handling algorithms.[11][23] Conflict resolution is bolstered by Smart Locks, which enable sequential editing of assets across branches by automatically verifying the latest version before granting exclusive access, thereby minimizing overwrite risks and merge disputes. Replacing legacy file-locking mechanisms, Smart Locks travel with changes during merges and support rules for non-mergeable files like binaries, preventing concurrent modifications that could lead to data loss. These features are detailed in the 2024 documentation updates, emphasizing their role in collaborative workflows. For binary files specifically, file-locking ensures atomic updates without requiring manual intervention.[24][11] Additional tools enhance branching and merging efficiency, including the Shelves view in GluonX, which allows users to create, view, and apply shelvesets for pending changes directly from the GUI, with advanced filters for branches and users introduced in 11.x. The mvbranch trigger, added in version 11.0.16.7978, supports automation of branch moves via command-line scripts, providing environment variables likePLASTIC_BRANCH_NEW_NAME and PLASTIC_FULL_BRANCH_NEW_NAME for precise control in custom workflows.[11][25]
Specialized Tools for Game Development
Unity Version Control provides specialized tools tailored for game development teams, particularly emphasizing workflows for artists and designers who handle large binary assets like 3D models and audio files. Central to this is Gluon mode, a simplified graphical user interface (GUI) designed for non-programmers, enabling them to select, edit, and submit files on a single branch without needing to manage merges, branching, or the full repository.[26] This partial workspace approach allows users to work on specific assets without downloading the entire repository, conserving disk space and reducing complexity for team members focused on creative tasks rather than code management; it supports file locking to prevent conflicts during collaborative edits on binary files such as images, animations, and documents.[26] In version 11.x, GluonX introduces enhanced shelveset support, including a dedicated shelves view for creating and viewing shelves directly in the GUI, integration of shelve diffs within the Pending Changes view, and an attributes view for editing shelve properties, streamlining temporary storage of changes for artists.[11] Deep integration with the Unity Editor further supports asset-centric workflows by enabling direct versioning of game assets through the plugin, where users can view and manage pending changes in a dedicated tab. The Pending Changes view includes a toggleable tree mode, allowing hierarchical visualization of modified, added, or deleted items for easier navigation of complex project structures. On Windows, the 11.x release enables auto-upgrade for the DVCS Edition, previously limited to Enterprise Edition, ensuring seamless updates without manual intervention during Editor sessions.[11] Handling large binary files is optimized for game development's demands, with version 11.x delivering significant performance boosts: undo operations are 25% faster due to refined processing adjustments, while deletes for large volumes of files are up to 6x faster through block-based handling and progress indicators.[11] These enhancements reduce wait times for operations common in asset-heavy pipelines, such as reverting 3D models or audio revisions. Code review tools in 11.x include enhancements for collaborative feedback, supporting multiple reviewers via a conversation panel where users or groups can be added or removed dynamically. The Code Reviews view now features auto-refresh for real-time updates and advanced filters to sort by criteria like status or assignee, improving efficiency in team reviews. Additionally, semantic visual differences in diff tools provide syntax-aware comparisons for .NET and Java files, highlighting changes at the level of classes and methods rather than line-by-line text.[11]Operational Modes and Workflows
Centralized and Distributed Modes
Unity Version Control operates in two primary modes—centralized and distributed—that determine how clients interact with the repository server and manage synchronization, enabling flexible team workflows tailored to project needs.[27] The centralized mode follows an SVN-like workflow, where client workspaces connect directly to a single central server for all version control operations, such as check-ins and updates, without maintaining a full local repository clone. This approach provides strict control over access and changes, making it suitable for large teams where centralized oversight is essential to maintain consistency and enforce policies. It utilizes atomic commits to ensure that entire changesets are applied successfully or rolled back entirely on the server, and supports server-side locking to manage concurrent edits on files, reducing conflicts in shared environments.[27][28][22][11] In contrast, the distributed mode emulates a Git-like structure, where clients maintain full clones of the repository locally, facilitating offline work and independent development. Users perform local commits and then synchronize changes via push and pull operations with the remote server, allowing seamless integration of updates when connectivity is restored. This mode has been available since version 2.0, released in 2008, with enhancements including automatic upgrades to distributed setups introduced in version 11.x for improved compatibility and ease of adoption.[27][28][29][11] Switching between modes is configurable on a per-repository basis, with hybrid support enabling mixed workflows where different team members or branches can operate in centralized or distributed paradigms as needed. Storage backends, such as those detailed in the system's architecture, remain compatible across both modes to ensure consistent data management. In distributed mode, performance optimizations include up to 10x faster workspace tree updates for large-scale repositories, such as those with 7 million items, as implemented in version 11.0.16.7957 through configuration flags like EnableNewWorkspaceTreeFormat, reducing update times from approximately 6 seconds to 600 milliseconds.[27][11]User Workflows and Integration
Unity Version Control supports core workflows centered on check-in and check-out processes, particularly optimized for partial workspaces that allow users to manage only specific subsets of a repository for efficient handling of large binary files common in game development. In partial workspaces, users can check out individual files or directories using commands likecm partial checkout <file>, enabling targeted edits without downloading the entire repository, which is ideal for distributed teams working on massive assets. Check-in follows a similar granular approach with cm partial checkin <file1> <file2>, ensuring changes are committed selectively after review, reducing overhead in environments with terabyte-scale projects. These processes integrate seamlessly with the centralized and distributed modes, where check-outs enforce locking to prevent conflicts in shared assets.[30]
Undo operations provide a safety net for workflow mishaps, with improved behavior introduced in version 11.0.16.7995, where a dialog now prompts users before shelving changes, allowing cancellation or preference setting to avoid unintended undos. Post-shelve, users can choose to undo or retain changes via an enhanced interface, configurable in preferences for repeated tasks. The incoming changes view further streamlines workflows by displaying pending updates from the repository, with conflict resolution optimized for speed—merge calculations for large-scale conflicts, such as those involving 2 million items with change-delete scenarios, were accelerated from over 2 hours to under 15 seconds, representing up to 500x faster performance in complex resolutions. This view includes details like path, size, author, and resolution method, enabling quick updates or manual interventions without full repository pulls.[31][11]
Integrations with development tools enhance daily workflows, including plugins for Visual Studio and JetBrains Rider that embed version control actions directly into the IDE. The Visual Studio plugin, updated in 11.0.x releases, fixed issues with pending changes display and toolbar controls after Visual Studio 2022 updates to version 17.2.0 or higher, ensuring reliable check-in/out from within the editor. Rider integration supports similar operations like status checks and diffs, with the plugin bundled in the Unity Version Control client for seamless setup. Jira enhancements in 11.0.16.9656 introduced intelligent endpoint detection for the REST API, automatically using the search/jql endpoint when available or falling back to legacy search?jql for compatibility, streamlining issue-linked branch creation and task tracking without manual reconfiguration. For automation, the command-line interface (CLI) enables scripting of workflows, with comprehensive documentation released in 11.0.16.7978 covering commands like cm partial update and triggers for events such as branch moves, including examples for environment variables like PLASTIC_BRANCH_NEW_NAME.[32][1][33][34]
User interface elements facilitate efficient management, such as the workspaces view in PlasticX (the desktop client), which supports filtering by branch or user for multiple repositories and drag-and-drop reorganization introduced in 11.0.16.8673 across macOS and Windows. This view allows renaming, deleting (even active workspaces), and reconnecting, with cross-platform drag-and-drop for files between changelists in the pending changes tab. In GluonX, the lightweight client for artists, the recent check-in comments UI was refined in 11.0.16.9213 with the button moved inside the textbox for better accessibility, alongside improved notification labeling and a new list format in the shelves view from 11.0.16.7935. Application zoom functionality, added in 11.0.16.7608, supports scaling via the menu or Ctrl + Plus/Minus in both PlasticX and GluonX, aiding visibility for detailed reviews.[11][11][19]
Error handling has been bolstered to support concurrent operations, with fixes in 11.0.16.7608 addressing deadlocks in long-running merge processes on the Cloud Server by preventing redundant calculations during simultaneous check-ins. The sign-in dialog received layout improvements in 11.0.16.7995 for clearer authentication flows, reducing user friction in multi-organization setups. These updates ensure stable performance in team environments, minimizing disruptions from race conditions or UI blocks.[19][31]
Comparisons with Other Systems
Key Differences from Git
Unity Version Control (UVCS), formerly known as Plastic SCM, diverges from Git in its optimizations tailored for game development, particularly in handling large-scale projects with binary assets. Like Git, UVCS is a distributed version control system (DVCS) designed for source code management, but it includes features such as efficient delta compression and item-level tracking to manage repositories containing gigabytes of assets without performance degradation.[35][1] In binary file handling, UVCS natively supports large binary assets—common in game development such as textures, models, and audio files—through built-in mechanisms like efficient delta storage and exclusive file locking, eliminating the need for extensions like Git Large File Storage (LFS). Git struggles with binaries due to its text-oriented diffing, often resulting in full file replacements rather than incremental changes, which inflates repository size and slows operations for projects exceeding 10 GB. UVCS's Smart Locks feature further enhances this by allowing locks to "travel" across branches, preventing concurrent edits on non-mergeable binaries and reducing conflicts, a capability absent in Git's branching model where parallel work on binaries frequently leads to overwrites.[1][36][35] UVCS excels in merging through tools like SemanticMerge, a code-aware merger that understands syntax and semantics for languages including C#, enabling intelligent resolution of code conflicts beyond Git's line-based textual diffs. For instance, SemanticMerge automates 16–30% of merges that would otherwise require manual intervention in Git, particularly beneficial for C# scripts in Unity projects. Additionally, UVCS's Visual Branch Explorer provides a graphical interface for tracking unlimited branches without the performance penalties seen in Git's text-based logs, where large histories can hinder navigation and merging complex changesets. This contrasts with Git's reliance on command-line tools or third-party GUIs, which often rewrite history during rebases—a practice restricted in UVCS to preserve immutable merge tracking.[23][35] User accessibility in UVCS prioritizes non-technical team members, such as artists, via intuitive graphical user interfaces like Gluon, which simplifies workflows by allowing selective file checkouts and automatic locking to avoid conflicts on shared assets. In contrast, Git's command-line focus demands scripting or external tools for similar functionality, making it less approachable for collaborative environments involving diverse roles in game studios. UVCS's file-locking prevents overwrites on assets like 3D models, fostering smoother teamwork without the merge hell often experienced in Git-based pipelines.[37][38] The repository model in UVCS utilizes directory-based versioning with unique item IDs to track changes at a granular level, enabling precise handling of renames, moves, and deletions across large directory structures without the snapshot bloat inherent in Git's content-addressable storage. This item-centric approach, not based on Git's protocols, supports scalable repositories for game assets while avoiding the exponential growth in Git repos as branches proliferate. UVCS thus maintains efficiency in distributed setups with features like Xlinks for repository linking, offering more flexibility than Git's submodules for managing interconnected project components.[35][1]Interoperability with Git, Perforce, and Others
Unity Version Control (UVCS) provides GitSync as a core feature for bidirectional synchronization between UVCS repositories and Git repositories, enabling seamless mirroring of commits, branches, merge tracking, and conflict resolution across the two systems.[35] This synchronization supports Git network protocols such as HTTPS and Git://, allowing UVCS to push and pull changes directly to remote Git servers like GitHub or Bitbucket without intermediate scripts.[35] GitSync converts Git submodules to UVCS Xlinks during operations and handles file additions, deletions, and moves on both sides, though it restricts Git rebases and fast-forward merges to preserve UVCS's change history integrity.[35] For accessing UVCS repositories with Git clients, GitServer enables Git-compatible push and pull operations by configuring UVCS to expose repositories over Git protocols on specified ports, such as TCP 9418 for the default Git protocol or HTTP 8080.[39] Configuration occurs via agitserver.conf file in the UVCS server directory, defining repository mappings, authentication (including HTTP basic auth), and sync intervals, which defaults to five minutes for propagating changes.[39] Import and export processes leverage Git's fast-import and fast-export formats through UVCS CLI commands like cm sync, facilitating migrations from Git to UVCS by pulling entire histories and mapping branches for visualization in UVCS's Branch Explorer.[35]
UVCS offers dedicated compatibility with Perforce through the P4Sync tool and CLI-based syncing, supporting direct import of metadata, file data, and changelists into UVCS repositories.[40] The cm sync command enables bidirectional synchronization, initially importing full Perforce history into an empty UVCS repository and subsequently propagating changes, with options like --branchesfolder to handle Perforce streams and branches in hybrid environments.[40] This setup allows only one Perforce stream to sync at a time per UVCS repository, aiding gradual transitions while maintaining case sensitivity and user mappings via parameters such as --user and --caseinsensitive.[40]
Integration with other version control systems includes plugins and triggers for tools like Polarion, where UVCS changesets and branches can link to work items using prefixes (e.g., "task004" for task ID 4) or desktop app selections, with configurable filters for work item statuses to populate pending task lists.[41] The UVCS CLI (cm) supports automation in CI/CD pipelines, such as Jenkins, through a dedicated Jenkins plugin that handles repository checkouts and builds, enabling scripted workflows for deployment.[16] While UVCS lacks native support for Subversion (SVN), interoperability is achievable via custom scripts leveraging the CLI for import/export operations, similar to general external VCS handling in Unity projects.[42]
Sync operations in UVCS handle branching effectively but require specific configurations, such as enabling parallel downloads for large files exceeding 2 GB, to avoid failures during GitHub repository synchronization as addressed in version 11.x updates.[11] Best practices include using Personal Access Tokens (PATs) for secure Git integrations to authenticate API calls without exposing credentials, particularly in automated syncs, and avoiding history-rewriting commands to maintain bidirectional consistency.[35] In hybrid Perforce setups, limit syncs to single streams and enable logging (cm log) for debugging mixed changelist issues or empty directory persistence.[40]