Table of Contents Show
In this article, we will compare the version control systems of Maya and Unreal, explore the key differences in file handling, and walk through a Git-based example using Anchorpoint.
As more animation studios adopt the Unreal Engine for real-time production, one question keeps coming up: “How do we handle version control?”. If you’re transitioning from a Maya-based pipeline, you’ve likely used Flow (formerly Shotgun/ Shotgrid) together with a custom scripted pipeline, to manage versions and asset updates. However, Unreal isn’t Maya. Things work differently, especially when you throw a versioning system like Git or Perforce into the mix.
Version control with Maya vs with Unreal
In Maya pipelines, version control is often tied to large binary .ma or .mb files. You can use Flow to publish versions and track approvals while using file-based versioning, like scene_v001.ma or scene_v002.ma.
- File type – .ma, .mb (binary, single file)
- Collaboration – one person per file
- Version history – manual incremental saving or DCC custom-built tools
In Unreal, things are more modular. Instead of saving one big file, you save individual assets. Unlike Maya, each asset (mesh, animation, blueprint, etc.) has its own file within a structured content folder. This changes how you handle versioning. You can make changes to a single material or animation sequence, and it becomes more realistic to work on the same project at once.
- File type – .uasset, .umap (many modular files)
- Locking – branching or exclusive checkout systems
- Collaboration – multiple people can work simultaneously
- Version history – commits with full history
The workflow similarities
Despite their differences, Maya and Unreal pipelines have similar high-level workflows:
- Do your work – Animate, model, texture, whatever.
- Publish or commit your changes – Push your version to the system.
- Get feedback or review – Let your lead, TD, or director give notes.
- Iterate and repeat – Make changes based on feedback.
This “create → publish → review” loop is fundamental in both worlds. What changes is how your tools support it.
The need of file locking or exclusive checkouts
Binary files like 3D models, animations, and Unreal Engine assets can’t be merged, so it’s crucial to use an exclusive checkout or file locking system to prevent conflicts. With file locking, only one person can work on a specific file at a time, and other team members can’t make changes until the file is committed or unlocked manually.
File distribution
In Maya, a shared folder is usually used, like a NAS (network-attached storage), which gives multiple users or devices on a network access to storage. In Unreal, though, files are stored on Git/ Perforce servers that handle all the versioning and sharing.
Example using Git
Git comes from the software development world, and developing a game is pretty similar to developing software in terms of workflow. The basic concepts are the same as in Perforce or any other version control system. If you want to work on an Unreal Engine project using Git as a version control system, you’ll need:
- A central remote server for your files (something like GitHub).
- A desktop app keeps track of all the file changes on your Unreal Engine project and then uploads and downloads the modified files to the server. It’ll also handle locking (or checking out) files, so no one works on the same file at the same time. An app like that could be Anchorpoint.
Here’s what a typical Unreal + Anchorpoint workflow might look like:
Step 1: Set up a Git repository for your project.
Initialize a Git repository in your Unreal project folder. Anchorpoint provides a UI for managing this process; no command line is necessary.
You can add an existing Unreal project to Git. A ‘repository’ is essentially your project folder containing all your files. To upload the files, you will need to connect the repository to a server. GitHub is one example of such a server.
Step 2: Pull the latest version before you start.
Before you start working, sync the latest version of the project. Anchorpoint will then download all the latest files to your project folder. This ensures that you are always working with the most up-to-date files.
You should do this at the beginning of each working day. A version control system makes this step explicit, unlike Dropbox which constantly syncs files.
Step 3: Work in Unreal.
Maybe you’re animating a character or adding a new sequence. Each time you make a change, it modifies the individual .uasset files within the Content folder. Anchorpoint automatically tracks all changes and newly added files. You don’t need to specify which file you want to modify beforehand.
Step 4: Commit and push.
This is similar to the publishing process you are familiar with from traditional VFX pipelines. It is important to communicate what you have done and ensure that everyone on your team has access to your work.
Once you’re finished,
- Open Anchorpoint.
- Select the files you changed.
- Add a message (e.g., “Updated run cycle for Ninja character”).
- Sync your work to the remote repository. In Git terms this is called commit and push.
Step 5: Review and branching
Another person will download your work (this is called ‘pulling’ in Git terms) and review and approve it. If changes are required, the whole process starts again.
Use Git branches for features or experiments that you do. For example:
- main: latest approved build
- shot_015_animation: your working branch.
- When you’re finished, merge back to the main branch.
Additionally, Anchorpoint offers an Unreal version control plugin that allows you to commit changes directly from Unreal, which can help speed up your work.
The Anchorpoint plugin for Unreal Engine
Further version control features
Version control systems like Git, have further options to manage your workflow, that you might have heard already.
Branching
Game developers use branches when working on or testing major features. These are copies of the code that you can work on at the same time as the main branch, where the main project is stored. You can merge them with the main branch when needed.
For example, if the main branch is “main,” a developer can create a feature branch, “feature,” and work on it at the same time. He can make changes to the feature branch until he merges it with the main project, making it accessible to everyone or ready for testing or release. On animation projects, branching is not something that is required. Work will be split up by sequences in Unreal Engine, which helps to manage shots.
Reverting to previous states
One perk of using a solid version control system is that you can always go back to a previous version of a file or reset the project whenever you need to. This can be tough, and sometimes it’s not even possible, just with saving a little bit at regular intervals.
Submodules
If you need to reuse components such as plugins or asset libraries across projects, you can use “submodules” in Git. These allow you to import a folder containing the plugin or library content into your project. They also provide better access controls because you can determine who has access to the folder. However, submodules increase the complexity of your workflow, so only use them where necessary.
Final thoughts
Unreal is changing the way animation pipelines work, and version control is a big part of this change. Maya uses a file-based approach that’s already well-established, but Unreal’s modular, real-time system needs a more flexible solution.
Tools like Anchorpoint help bridge the gap between creative and technical by making Git accessible to artists. Once you get past the learning curve, you’ll wonder how you ever managed without it. So, whether you’re switching pipelines or starting from scratch, don’t be afraid of Git. With the right tools and mindset, version control in Unreal can be powerful, efficient, and artist-friendly.
