Start Building

By now you have a project, a plan, and an art pipeline. The next step is version control and collaboration so you can iterate without fear, roll back when something breaks, and (when the time comes) work with others on the same Unreal Engine 5 FPS.

This lesson gets you to a working setup in about 30 minutes. You will choose a system, configure your repo, and learn the daily habits that keep your project safe and mergeable.

Why version control matters for your FPS

Without version control:

  • One bad save or deleted folder can cost hours or days.
  • You cannot safely try big changes (e.g. a new weapon or level) and revert if it does not work.
  • Adding a teammate later means chaos: overwritten files, unknown versions, no clear history.

With it:

  • Every meaningful change is a commit you can revert or compare.
  • You can branch for experiments (e.g. "multiplayer prototype") and merge only when ready.
  • Multiple people can work on different assets or levels and integrate in a controlled way.

Even if you are solo today, setting this up now makes adding collaborators or moving to a studio pipeline much easier.

Step 1: Choose Git or Perforce

For Unreal Engine 5, the two main options are Git and Perforce.

Git

  • Pros: Free, widely known, works with GitHub/GitLab/Bitbucket, good for code and many binary workflows with LFS.
  • Cons: Large binary assets (meshes, textures, maps) need Git LFS and discipline; very large teams often prefer Perforce.
  • Best for: Solo devs, small teams, and projects where you are comfortable with LFS and lock files (or Unreal’s built-in Git support).

Perforce (Helix Core)

  • Pros: Designed for large binaries and game teams, file locking, strong Unreal integration.
  • Cons: Heavier to host and maintain; free tier has user limits.
  • Best for: Teams that already use Perforce or plan to grow into a larger studio pipeline.

Recommendation for this course: Start with Git + Git LFS unless you already use or plan to adopt Perforce. The steps below focus on Git; the same principles (ignore lists, locking, and clear commit messages) apply to Perforce.

Step 2: Install Git and Git LFS

  1. Install Git

    • Windows: git-scm.com or install via your package manager.
    • Mac: brew install git or Xcode Command Line Tools.
    • Verify: git --version.

  2. Install Git LFS

    • git-lfs.com – install and run git lfs install once per machine.
    • This tracks large files (e.g. .uasset, .umap) with LFS so the main repo stays fast.

  3. Configure Git (if you have not already)

    • git config --global user.name "Your Name"
    • git config --global user.email "[email protected]"
    • Use the same email as your GitHub/GitLab account if you use one.

Step 3: Create a repository and add your Unreal project

  1. Create a new repository

    • On GitHub, GitLab, or Bitbucket: create a new repo (e.g. my-fps-project).
    • Do not initialize with a README if your project folder already exists locally.

  2. Open a terminal in your project root

    • Navigate to the folder that contains your .uproject file (e.g. MyFPSGame).

  3. Initialize Git and LFS

    • git init
    • git lfs install
    • git lfs track "*.uasset" "*.umap"
    • This tells LFS to handle Unreal’s main binary types. Add other patterns if you use them (e.g. *.png for large textures).
    • Commit the .gitattributes file LFS creates:
      • git add .gitattributes
      • git commit -m "Add Git LFS tracking for UE5 assets"

  4. Add a .gitignore for Unreal

    • Ignore build outputs, caches, and local-only files. Example minimal set:
      • /Saved/
      • /Intermediate/
      • /Binaries/
      • *.sln
      • *.suo
      • .vs/
    • You can copy a full Unreal .gitignore from GitHub’s Unreal .gitignore templates or the Unreal documentation.

  5. First commit

    • git add .
    • git status to confirm you are not adding huge temp or build folders.
    • git commit -m "Initial commit: UE5 FPS project and LFS setup"

  6. Connect to the remote

    • git remote add origin https://github.com/YourUser/my-fps-project.git (or your URL).
    • git branch -M main
    • git push -u origin main

Pro tip: Commit often with clear messages (e.g. "Add rifle mesh and material", "Fix player sprint input"). You will thank yourself when hunting a regression or merging a teammate’s work.

Step 4: Enable Unreal’s source control integration

  1. In Unreal Editor: Edit → Project Settings → Plugins.
  2. Search for Source Control and enable Git (or Perforce if you use it).
  3. Restart the editor if prompted.
  4. Edit → Source Control → Connect to Source Control.
  5. Choose Git and point to your repo (or use the same working folder).
  6. Optional: Under Source Control → Source Control Preferences, enable "Use Global Settings" if you want one identity for all projects.

Once connected, you can see file status (modified, added, locked) in the Content Browser and submit changes from the editor. Prefer committing from the editor for Blueprints and assets so Unreal can handle locking and references correctly.

Step 5: Define simple collaboration rules

Even with one person, habits matter. When you add teammates, these rules scale.

  • One feature or fix per branch (optional but useful): e.g. feature/weapon-rifle, fix/player-sliding. Merge to main when tested.
  • Commit messages: Short summary line (e.g. "Add SM_Weapon_Rifle and M_Rifle"). Add a line or two of detail if the change is non-obvious.
  • Do not commit: Saved/, Intermediate/, Binaries/, or local-only config. Keep these in .gitignore.
  • Locking (Perforce) or communication (Git): For binary assets, avoid two people editing the same asset at once. Use Perforce locks or agree who “owns” which asset so merges stay clean.

If you are solo, still commit at least at the end of each lesson or after each working feature. That gives you clear restore points.

Step 6: Restore a previous version (safety check)

Practice a rollback so you are not scared of it:

  1. Make a small change (e.g. rename a folder or edit a Blueprint).
  2. Commit it.
  3. In Git: git log --oneline to see the last commit hash.
  4. Revert: git revert HEAD --no-edit (creates a new commit that undoes the last one), or git checkout <previous-commit-hash> -- path/to/file to restore one file.
  5. Confirm in the editor that the state is back.

You do not need to do this every day, but doing it once builds confidence that version control has your back.

Common mistakes and fixes

  • Pushing huge files without LFS: If the repo gets slow or you see “large file” errors, ensure *.uasset and *.umap are in .gitattributes and tracked by LFS. Migrate existing history with git lfs migrate if needed (back up first).
  • Committing Saved/Intermediate/Binaries: Remove them from the repo (e.g. git rm -r --cached Saved), add them to .gitignore, and commit. Future commits will ignore them.
  • Merge conflicts in Blueprints: Unreal can merge some Blueprint changes; complex ones may require choosing one version and redoing the other. Reduce conflicts by not editing the same Blueprint in two branches at once.
  • Forgetting to pull before work: Get in the habit of git pull (or equivalent) at the start of a session so you are always building on the latest shared state.

Mini challenge

  • Initialize a Git repo (with LFS) for your FPS project, add a proper .gitignore, and push the first commit to a remote.
  • Make one small change (e.g. add a comment in a Blueprint or rename an asset), commit from the Unreal editor or command line, and push.
  • Optionally, create a branch, make a change, and merge it back to main.

Recap and next step

You now have:

  • Git (and optionally Git LFS) set up for your UE5 FPS.
  • A remote repository and a clean first commit.
  • Unreal’s source control integration enabled and simple collaboration habits in place.

Next up is Lesson 5: Player Controller & Movement Systems – where you implement first-person movement, input, and camera so your character actually runs, jumps, and aims. Your version-controlled project is the right place to build that without fear of losing progress.

If you run into lock files, LFS, or merge issues, check the Unreal version control documentation and your host’s (e.g. GitHub) LFS docs. Share your setup (e.g. “Git + GitHub + LFS”) in the community to compare notes with other learners.