Git is by far the most popular version control system used in the world of software development. And also in other industries such as game development, its footprint is still high. However, it does not have the best reputation, as you often hear devs and artists mention scalability issues and confusing UX. But with the latest contributions to core Git and to its ecosystem, it has become a powerful version control toolset that covers all the needs for game developers. Let’s take a look at how to use it specifically on an Unreal Engine project.

Why Use Git on an Unreal Engine Project?

We are in 2025, and things have changed over the last 5 years. There are plenty of reasons why Git is now a solid option for large Unreal projects.

It Has the Biggest Ecosystem

Git has existed for over twenty years now. It started as a content manager by Linus Torvalds and has evolved to be the most used version control system. That is due to its open-source nature and the popularity of platforms such as GitHub.

There are many ways to host Git repositories locally or in the cloud to cover every industry need. Assembla, for example, supports Git repositories for large binaries. Every CI/CD system and every developer IDE supports Git without any plugins. There are plenty of graphical Git clients, free and paid. Google works, and LLMs understand every Git command to help you out in case something goes wrong.

No Lock-In Effects

You are not bound to a particular vendor. You are bound to an open-source system. No issues with waiting for customer support or unpredictable costs in the future.

Developer Friendly

Coders will probably prefer Git over anything else. It’s what they learned at university. It’s local, and it’s fast. Especially if working on an Unreal Engine project, where you write logic in C++ (or think of the future where you would use the Verse programming language) instead of Blueprints, that advantage comes into play.

Fast Branching

That was one of the things that Git was always good at—and still is. Want to do some experiments? Create a new branch. Want to create some feature branches? You can do that easily. Want to do code reviews before merging? That’s what Pull Requests were designed for.

The way Git handles branches also enables proven workflows and stable releases.

No File Reconciliation Times

Even if you modified files outside of your repository, it’s easy to bring them in. git status and git add operate in fractions of a second.

How Scalable Is Git?

Next to UX concerns, this is one of the biggest doubts that leads teams to pick other solutions than Git to collaborate on Unreal Engine projects. And yes, Git had bad binary support and was not good at managing large amounts of files as a centralized version control solution, but things have changed over the years.

Git LFS Got Better

It does not come with hard file limitations anymore. Today, limitations are only set by the Git hosting provider, such as GitHub. Assembla, on the other hand, does not impose any file size limitations, so you are free to push everything to it.

There is no need for dedicated LFS commands or separate installs. Git LFS is bundled with the main Git for Windows installer and also part of most Git GUIs. It integrates via hooks into the core Git commands, so you can use any command like git push and git pull, and your binary files will be managed implicitly by LFS.

The only configuration work you need to do is to set up your .gitattributes file to tell Git which files should be handled by LFS and which should not. This is a similar process to configuring a type map when, e.g., using Perforce.

Regarding repository sizes, the LLM hosting provider Hugging Face used Git LFS to manage 29 petabytes (29,000 terabytes) of model data. We have managed repositories with over 1 TB of storage without compromising on speed limits.

Finally, Git LFS also supports file locking, even on text files.

Git Introduced Sparse Checkout

With Git 2.25.0, introduced in 2020, Git got the ability to selectively check out a specific folder instead of the whole repository. While this kind of feature was available before, in 2.25.0 Git sparse checkout got incredible performance benefits. It was mainly added to better manage monorepos.

For Unreal Engine projects, that is especially interesting when you have larger projects where you get and modify the Editor source code. In your repository, you can have multiple game projects next to the Editor code. Sparse checkout will allow you to only work on one selected game project, so you don’t need to download all the files and are able to save disk space.

The biggest benefit comes for art assets. There, you rarely need all the source assets on your local computer.

Git Can Check for Changes in the Background

A small file system monitor utility that runs in the background can speed up the detection of new files when you work on repositories with, e.g., 250k files, which is normal on projects that include the Unreal Editor source code. It will make commands like git status feel instant again.

To use this feature, enable the file system monitor on your project:

git config core.fsmonitor true

Persisting Limitations of Git

While requirements such as Unreal Engine integration, file locking, and simple-to-use GUIs have been contributed to the Git ecosystem, two downsides still exist:

No Per-File/Per-Folder Access Control

Git is distributed and lacks centralized access control features. The only way to control access is by managing multiple repositories and using submodules, which is inferior to the solutions that centralized version control systems provide.

The Requirement to Be at the Latest State

Because Git maintains a linear history, you have to be at the latest state before pushing files to the central server. This means that when you want to submit your work, Git will need to sync all changes first, which takes time, especially on larger teams with many contributors. Keep that in mind when using Git on larger projects.

How to Set Up Git on Unreal Engine Projects

We will use Assembla’s Git repositories to host our files and Anchorpoint to push and pull them to Assembla. Anchorpoint extends Git’s core functionality with a metadata system for file locking, centralized Git configurations, and other features such as asset tagging that we will need on an Unreal Engine project.

Prerequisites

Creating a Git Repository in Assembla

First, you need to create a space with a repository. Then, you can create your Git repository.

Then, you need to access the repository URL via HTTPS and copy it to the clipboard.

Push Your Unreal Project to Assembla

We will use the Dark Ruins Megascans Sample project from FAB for this tutorial. First, make sure that you are using External Actors in your Unreal Engine level. They will split the level into smaller actor files and allow multiple people to work on the same level simultaneously.

Create an Anchorpoint Project

Download and install Anchorpoint. Then launch the application and create an account. This account is required for managing the metadata that lives next to the production files.

Browse to the folder that contains your Unreal Engine project, and pick “Connect existing Repository via HTTPS” in the Remote Settings dropdown. Make sure the template for .gitignore is set to “UnrealEngine”.

After that follow the wizard to create the project. You can skip inviting new members at this point. Once the project is created, you’ll end up here:

Click on Timeline, then on Changed Files. Enter a message in the text field and press Sync. This will stage, commit, and push the files to Assembla. It will also check if files are binary upfront, so that all binary files are handled with Git LFS.

Adding Team Members

You’ll need to add team members on Assembla (for accessing the Git repository) and on Anchorpoint (for accessing the metadata). Once you’ve done it, they should be notified via email.

  1. On Assembla, click on “Space Team” to access the team settings.
  2. On Anchorpoint, click “Project Settings” in the left sidebar, then “Members”.

Using the Unreal Engine Plugin

To better control what files you want to submit and to see locked files directly in Unreal Engine, you can use the Anchorpoint plugin for Unreal Engine.

  1. Download the plugin from FAB and install it in your Engine
  2. Activate it under Plugins in Unreal
  3. Go to Revision Control Settings (bottom-right corner) and pick Anchorpoint

Using the plugin, has additional benefits:

  • Use explicit checkout workflows on assets you modify intentionally. Checking out an asset in Unreal Engine will use Anchorpoint’s locking feature, making it read-only for other team members to avoid file conflicts.
  • No need to close Unreal when pulling new files.
  • Submit changes from within the Unreal Editor.
  • View diffs of Blueprints.

Going Further

These are the basics to get a project up and running with your team. If you work on larger teams and want to bring your workflow to the next level take a look at trunk based development, a solid CI/CD pipeline and distributing editor binaries, when building the Unreal Editor form source.

Trunk-Based Development

This is a development approach that relies on working on the main branch (the trunk) as much as possible. Branches with subbranches (common in Git Flow) add complexity. In trunk-based development, you branch out from main and merge back quickly — typically daily.

In our Unreal Project, content creators (the ones that don’t modify any source code) will submit their changes directly on main. The benefit is that we don’t need to explain them the concept of branches at all.

Coders or technical artists, that develop logic, will work on feature branches, which are merged via Pull Requests. The great thing here, is that you can perform code reviews and tests before changes get merged. This makes sure that only stable code is on main. If you are a small team, you can skip the Pull Request workflow and just merge directly into main.

Binary distribution

When building the Editor from source, you need Visual Studio and all of it’s components. Furthermore, building takes time. To avoid installing all these components and forcing everyone to waste time on building the editor, you can distribute precompiled binaries to your content creators. When working with Perforce, you would use Unreal Game Sync, which does exactly that.

Anchorpoint also has the option to distribute precompiled binaries connected to a particular Git commit. These binaries are distributed either via S3 storage or a shared folder on Dropbox or Google Drive.