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:

1. Do your work – Animate, model, texture, whatever.
2. Publish or commit your changes – Push your version to the system.
3. Get feedback or review – Let your lead, TD, or director give notes.
4. 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.

Want to know more about Anchorpoint?

Working in a team with Unreal Engine 5

The post Using Unreal Engine in animation pipelines: How to use version control first appeared on DIGITAL PRODUCTION and was written by Matthäus Niedoba.

Adobe has rolled out version 3.1 of its Substance 3D Stager software, aimed at improving workflows for scene composition, material editing, and real-time rendering. While the updates won’t rebuild your workflow overnight, they might save you a few hours of head-scratching on a deadline. Here’s what’s new, with all features as listed directly in Adobe’s release notes.

Material Editing Gains New Flexibility

Version 3.1 brings enhanced material-editing options. The new material manager lets users edit the properties of multiple materials simultaneously—great for those moments when you’ve accidentally duplicated a less-than-stellar texture across an entire scene. Materials can now be grouped and organized by layers, making complex scene compositions slightly less chaotic.

Improved Asset Management

Stager 3.1 introduces an updated asset manager that promises better efficiency in handling complex 3D projects. Assets can now be tagged, sorted, and searched with more granularity. For large projects, where every file feels like an identical OBJ, this feature could be a lifesaver.

Real-Time Rendering Enhancements

The rendering pipeline has received some attention too, with updates to real-time ray tracing. Version 3.1 delivers faster preview renders and improved handling of scene lighting. This translates to a smoother experience when juggling last-minute tweaks in virtual production or prototyping workflows.

Scene Composition Improvements

Users working in virtual production or visualization will benefit from new tools for managing complex scenes. Scene hierarchies can now be adjusted with drag-and-drop simplicity, allowing for quicker organization of props, cameras, and lights. While this might not seem groundbreaking, it’s one less reason to yell at your screen during crunch time.

Price & Availability
Adobe Substance 3D Stager 3.1 is available through the Adobe Substance 3D Collection. For pricing, refer to Adobe’s official pricing page.

Final Thoughts
While the updates in Substance 3D Stager 3.1 improve usability, production artists should verify the stability of these new features before integrating them into demanding pipelines. The focus remains on iterative improvements rather than revolutionary changes, ensuring that tools remain simple and stable for professionals in post-production, VFX, and beyond.

The post Adobe Substance 3D Stager 3.1 Beta first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

by Matthäus Niedoba

Why Dropbox, Google Drive or a NAS don’t work with game engines is quite simple: because they synchronise changes immediately and because a game engine doesn’t have a single file that can be saved incrementally. For example, Blender saves everything in a *.blend file, Photoshop in a *.psd file, etc. However, an Unreal project consists of several files that are linked to each other. There is not “the” one Unreal file. For example, if you import an FBX into Unreal, this FBX is converted into a *.uasset file in its own structure. Each time a newer version of the FBX file is imported, the *.uasset file is simply overwritten. Unreal will not create a _v002.uasset. This is the opposite of Blender, where you have full control over the linked *.blend files.

This means that a game engine only understands one version of a file. The file on your hard drive (the *.uasset) is basically the only version that exists. Here comes the problem with Dropbox. Two artists can only work on the latest version of a map. Since the Dropbox synchronises continuously, they overwrite each other. In addition, Unreal “locks” files, i.e. makes them read-only when they are imported into a level. This also blocks the Dropbox synchronisation process. The whole project ends up in total chaos.

What is version control?

Version control comes from software development. Writing software is similar to developing a game. A compiler (exactly the same thing that generates the builds in a game engine) only understands one version of a file. And it’s no surprise that software has versions such as 1.3.4 and so on. These versions are managed by version control. Version control can organise files (it replaces incremental saving _v001, _v002) and synchronise files via a server. It therefore replaces the Dropbox. It is the basis for teamwork.

GitHub vs. Dropbox

Everyone has probably heard of GitHub and downloaded scripts or small tools there. It is the platform for open source projects and is only possible thanks to version control. The word “Git” from GitHub is also the name of the version control system “Git”, which we will look at in more detail in a moment. You can also use GitHub as a server for your Unreal project, where everyone in your team uploads and downloads their files. It serves as an alternative to Dropbox.

Unlike Dropbox, GitHub supports version control, which you need for your Unreal project. What you still need is a desktop application that uploads data to GitHub. Dropbox has its own application for this, while GitHub offers you a choice of many applications that are compatible with the “Git” version control system. We have collected a few well-known representatives in the box on the side.

How does version control work?

First of all, there is a central server on which all files are stored. In most cases, this is located in the cloud. Everyone has a local copy of the Unreal Engine files on their computer. It’s not like working from a NAS where everyone works directly on the server. A workflow with 2 artists can look like this:

Artist A (“you”)

• You work in Unreal – and import new assets, change shaders and edit the map. You save and overwrite existing files. The end result is a series of modified files (usually a list of .uasset and .umap files)
• The version control system recognises all these modified files and displays them in a list.
• You upload these files – and so far Artist B hasn’t seen any of your work. That changes now. It is customary to attach a short comment to each upload, e.g. “I changed the light to make it look warmer”. Then you press the upload button and your work is uploaded to the server (e.g. GitHub).

Artist B (“Your team member”)

• Works in Unreal, just like you.
• Version control sees that there are new changes on the server (coming from you) and sends a notification to your team member
• Your team member presses a “Download” button and has downloaded your files.
• Your team member uploads their files, just like you.

That’s the workflow. It may sound exaggerated, but it’s not. Commenting and uploading quickly becomes a habit and creates transparency. You can see who did what at what time. To prevent two people from working on the same file, a version control system has a file locking feature. This allows you to make files read-only for all team members (except yourself) to prevent multiple people from working on the same file. DCCs (Blender, Maya and C4D) can also be managed within the version control system. This means that the file versions are no longer saved incrementally, such as character_v001, _v002, _v003, etc.. So you overwrite each file and publish my new version with a comment. This is then uploaded to the server, just like in the Unreal project. This can feel a bit strange when you have incremental saving in your fingers. If you prefer to stick with the usual incremental saving method, you can also do this and only version the Unreal project. This means that a new version is only created after the assets have been imported into Unreal.

Implementing version control in an existing Unreal project

In this example, we use the version control system “Git”. For this you need: A cloud storage provider. In this case, this could be GitHub A desktop application that uploads and downloads data to GitHub. In this case we use Anchorpoint. Your existing Unreal project, which is stored on your hard drive.

GitHub

First create an account on GitHub and create a repository. GitHub is primarily intended for software developers, so the interface can be a little confusing. You must first create a repository. A repository is similar to a file folder that contains your Unreal project. The repository will be the place where your files will be uploaded and downloaded later. Once you have created the repository, you need to invite your team members (everyone needs an account on GitHub). Finally, you need to copy the URL to the clipboard. You will later paste it into Anchorpoint to tell Anchorpoint where to upload the Unreal project.

About the costs

GitHub is very generous when it comes to pricing. The free plan gets you a long way, and the Team plan ($3.67 per person, per month) offers additional options for security and automation. Unfortunately, the generosity ends with storage space. You have to buy so-called “Data Packs”, a kind of prepaid credit for storage space. These cost 5 dollars for 50 GB per month. If you don’t want this, you can fall back on alternatives from GitHub such as Microsoft Azure DevOps, which are much more generous in terms of storage.

Anchorpoint

Download Anchorpoint and create an account there too. The next step is to create a project of the type “Git Repository”. There you have to tell Anchorpoint where your Unreal project is located and enter the URL of the GitHub repository (which you have copied to the clipboard).
Finally, you need to add your team members via email and upload your project files to GitHub. Here you have to leave a short comment (e.g. “Have initially uploaded project to GitHub”) and press the blue “Push” button.

Unreal Engine

Unreal has the option to switch on Revision Control (or Source Control if you are using version 5.1 or older) at the bottom right. We deliberately leave this off, as the Git plug-in slows down Unreal Engine and we have a better overview with Anchorpoint. In any case, use World Partition, which has been available since Unreal Engine 5.0. World Partition splits a level into many small files so that several team members can work on the same level. Without World Partition, each team member has to wait until you have edited and uploaded the level, otherwise you will be working on the same file. If you’re thinking that you’re inviting chaos: World Partition is made for the layout or world building process. The customisation of materials, rigs and assets in general is excluded here.
Once you have finished working on your asset or level, you can open Anchorpoint. Anchorpoint scans all your files in the project folder and lists the modified files. Now you can enter a comment again and upload your work to GitHub via “Push”.

Conclusion

The first steps with version control feel unfamiliar at first. You have to write comments and manually press the upload and download button to exchange files. It’s different to Dropbox, where synchronisation is continuous. Once you have done a project with it, you appreciate the advantages of this system. The workflow is transparent, the security is higher (you can always jump back to a status in the project) and you have more control over the project.

Alternative version control systems

There are basically four version control systems for the Unreal Engine to mention. Unreal has a plugin for all of these systems.

• Perforce: Mostly used in AAA game studios. Perforce is a well-established version control system that works well in huge projects.
• Git: The most popular version control system for software developers. Git is open source and has the richest ecosystem in terms of community, tools and cloud providers. Anchorpoint is based on Git.
• Subversion: A fairly old but solid and simple version control system.
• Plastik SCM (Unity Version Control): The newest system on the market. It has been owned by Unity since 2021 and is also well suited for game development for Unreal Engine.

Matthäus Niedoba is the founder of Anchorpoint, a version control software for Unreal and Unity. Anchorpoint simplifies remote team projects and works with any storage solution.

The post Working in a team with Unreal Engine 5 first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

New procedural tools for designing large worlds

With the new in-editor and runtime procedural Content Generation Framework (PCG), you can set rules and parameters to quickly and efficiently populate large scenes with Unreal Engine assets of your choice. This means that the process of creating large worlds is faster and easier.

The introduction of the new Substrate system

The new Substrate system offers a new way to create materials and gives you, as an Unreal Engine user, more control over the look and feel of objects used in real-time applications such as games and linear content creation.

Improvements for virtual production workflows

The new version also brings several improvements for virtual production workflows. New shot creation and scene control tools help to make virtual productions faster and more efficient.

Caution: preview versions are unstable

Please note, however, that preview versions are not fully tested and should therefore be considered unstable until the final version is released. You can find all information here in the forum.

The post Unreal Engine 5.2 Preview is now available! first appeared on DIGITAL PRODUCTION and was written by Bela Beier.