Welcome to your comprehensive guide on building bulletproof Unreal Engine 5 project foundations. This session is the first in a three-part series on code, collaboration, and shipping with Assembla and Visual Assist. The goal here is straightforward: to walk you through the practical decisions and workflows that take you from solo prototyping to full team production without the problems that derail most projects.
This guide draws directly from the experiences of industry veterans with 35 years of combined game development expertise, including 20 years shipping with Unreal Engine. If you apply what we cover, you’ll avoid the broken builds, asset conflicts, and infrastructure headaches that plague underprepared teams.
Watch the webinar replay here if you want to see live demos.
Table of Contents
Your First Critical Decision: Binary or Source
When you start an Unreal Engine 5 project, you face a fundamental choice that affects everything downstream. Do you install the binary version of the engine, or do you compile from source?
For most teams, the answer is binary installation. You download it, install it, and you’re done. Iteration is fast. Upgrades are straightforward. Epic Games maintains excellent backward compatibility with existing assets, so when a new engine version releases, you simply load your project with the new version and continue working.
Compiling from source is the other path, but it’s significantly heavier. You only choose this if you need to modify the engine itself. And when I say modify, I mean fundamental changes like building a custom landscape system or making deep architectural changes. Here’s what source compilation actually requires: either a very powerful desktop or, more realistically, a build farm to compile the millions of lines of C++ code in reasonable timeframes. If you have multiple programmers and artists, you’ll need a small build farm for continuous integration to distribute your engine changes to the team. You’ll also need deep familiarity with Perforce branching strategies and confidence merging changes across engine versions.
Most teams should stick with binary installation, but if you identify the need to compile from source then ensure first that you can deal with the performance and power necessary.
Setting Up Your Development Environment
Before you create anything, you need three tools installed. For the purposes of this webinar, this isn’t optional. Each one serves a specific purpose in the workflow.
Visual Studio 2022 Community Edition is your IDE. Download and install Visual Studio and Unreal Engine from the official link and make sure to enable the C++ and C workloads. There are additional features required by Unreal, but you can install those on demand when you load the solution. Unreal’s built-in integration checker will alert you if anything is missing.
The Perforce Client comes in multiple pieces, but you only need specific components. Download P4V, the visual client, along with the command-line tools P4 and P4 Admin. You don’t need the server component. There’s also a P4VS plugin for Visual Studio that lets you check files in and out without leaving the IDE.
Visual Assist is the Visual Studio extension we’ll cover in depth in the third webinar of this series. Install it now so you have it ready.
For reference on hardware: if you’re compiling code locally, compile times are primarily limited by disk access speed. An NVME drive is critical. A modest GPU like a GeForce 970 might not have enough memory just to run the Unreal Engine editor. A more capable GPU and sufficient RAM (we recommend 64 GB) make a real difference in daily iteration.
Creating Your First Project
Download the Unreal Engine binary from the Epic Games launcher. Create an Epic Games account, sign in, navigate to Unreal Engine, and click install engine. When the installation completes, it will launch automatically.
Create a new project. Select your preferred template (first-person works well for prototyping), then make one critical decision about location. Do not place your project in your Documents folder or any other deeply nested directory. Windows has path length limits that cause real problems. Place it at the root level of a drive, something like C:/Projects/. Call it something identifiable. We’re using “Sample Game” for this walkthrough.
Select C++ as your language, not Blueprints, unless you’re specifically making a Blueprint-only game. After several minutes, the Unreal Editor will launch alongside a new Visual Studio instance with your project loaded.
On first run, Visual Studio displays an integration check window. Run through it. Make sure everything installed correctly. When the solution first loads, it may indicate missing packages. Manage those NuGet packages to ensure the environment is properly configured.
Why Perforce Instead of Git
Two major reasons distinguish Perforce as the right choice for game development.
Exclusive checkout means when you open a file for editing, you take ownership of it. No one else can edit it simultaneously. When you’re done, you check it back in. This is essential for binary files, which cannot be merged.
Optimized handling of large binary files and poor network connections is built into Perforce’s architecture. Git’s recommended repository size limit is 1 gigabyte. A single high-resolution texture in Unreal Engine 5 can exceed that. Perforce handles tens of terabytes of data across distributed teams with intermittent connectivity.
Here’s the distinction: when editing text files like C++ code, two developers can make different changes simultaneously, then the second person merges the other’s changes. This is valid and expected workflow. Binary files, like PNG images or Unreal assets, cannot be merged. Two different versions of a PNG file cannot be combined. Exclusive checkout prevents this problem entirely.
Git stores a complete history of the entire repository locally. A 100 GB repository becomes a storage nightmare. Perforce’s architecture doesn’t have this limitation.
There are alternatives to Perforce—Plastic SCM and Perforce’s own Hangar are options—but Assembla doesn’t currently support them. Perforce remains the industry standard for game development at scale.
Setting Up Assembla and Perforce
Navigate to getassembla.com and sign up for a free account. Select your local region and complete the form with your username, email, and password. You’ll set up an organizational domain, which Assembla calls a “portfolio.” A portfolio is a container for all your projects. Within a portfolio, you create spaces, each representing a single project.
After account creation, modify your trial plan. Helix Core (Perforce) doesn’t come by default with the free trial. Add it as an add-on. Specify the number of users who need Perforce access.
Now create a new space. Name it after your project and give it a prefix that will appear on all tickets and documentation. Initialize it with repository, ticketing, and wiki tools.
Create a new Perforce repository. Assembla will provision and host your Perforce server in the cloud, so you don’t manage infrastructure or pay for DevOps overhead.
Configuring Perforce Type Maps
This step is critical and often skipped to great regret. Perforce needs explicit configuration to determine which files can be checked out by multiple people and which require exclusive checkout.
Set type maps before adding files to your repository. If you set them after files are already committed, you’ll need to correct the locking behavior on every file individually.
Text files like C++ code (.cpp, .h files) should be configured as “text” without exclusive checkout. This allows multiple developers to edit them and merge changes.
Binary files like Unreal assets (.uasset files) and images (.png files) should be “binary” with exclusive checkout (the “+L” flag in Perforce). Only one person can edit them at a time.
Generated and temporary files should be excluded entirely. This includes intermediate build files, the derived data cache (which Unreal regenerates automatically), Visual Studio temporary folders, and saved games. Use stream specifications to exclude these directories before syncing.
Configure this in Assembla’s UI or via the command line using P4 type map commands. The documentation provides sample type map configurations for Unreal Engine projects.
Connecting to Perforce from the Command Line
Use a P4 config file to manage connection settings. This is especially useful if you work with multiple Perforce servers.
Create a file called P4 config with these settings:
P4CLIENT=machine_username_projectname P4PORT=your_assembla_server_address:port P4USER=your_assembla_username
When you first connect, Perforce will ask you to trust the server’s fingerprint. Accept it, and verify your connection with the p4 info command.
Creating Your Perforce Workspace
Use the P4V visual client to create a workspace. Use a consistent naming convention: machine name, username, and project name. This clarity becomes invaluable when debugging issues across a team.
Point the workspace to your local Unreal project folder. Set the stream to “mainline” or your main development branch. Once created, you’ll see all project files available for addition to source control.
Configuring Stream Specifications
Not all files in your Unreal project should be version controlled. Set up stream specifications to exclude directories that contain temporary or generated content.
Exclude these directories:
- .vs/ – Visual Studio temporary files
- Intermediate/ – Compiled object files and generated project files
- Binaries/ – Compiled executables
- Derived Data Cache/ – Unreal Engine’s processed asset cache, which regenerates automatically
- Saved/ – Save games, logs, crash dumps
The syntax uses … to mean “all files recursively under this directory.”
After configuring stream specs, add all remaining files to Perforce. Submit with a detailed comment like “Added initial code and assets for Sample Game.” Assembla tracks these submissions, and you can link them to tickets in the UI.
Client Configuration Best Practices
Character Encoding
Set character encoding to UTF-8. Everything on the Perforce server is stored as UTF-8. Using UTF-8 locally eliminates translation errors, provides a slight performance improvement, and reduces the chance of corruption. This is especially important for multinational teams. Other encodings like UTF-16 are rarely handled correctly and are difficult to autodetect.
Workspace Settings
Navigate to workspace properties and examine the advanced settings:
AllWrite: By default, synced files are read-only. This prevents accidental modifications without explicit checkout. Keep it disabled.
Clobber: This syncs files even if Perforce detects local changes. It’s useful on build machines but dangerous in development. Avoid it.
Compress: Server compression creates significant server load and requires more powerful hardware to maintain speed. Not recommended for development.
ModTime: This sets synced file timestamps to server submission time rather than the current time. Avoid this unless you’re syncing binary builds without source and need to prevent unnecessary recompilation.
RmDir: This removes empty folders after syncing. Enable it to keep your workspace clean.
RevertUnchanged: This reverts files that you opened but didn’t actually modify. It keeps your change history clean and manageable.
Integrating Perforce with Unreal Engine
Open your Unreal Engine project and go to Tools > Connect to Revision Control. Select Perforce. Copy your server address from the Assembla dashboard, enter your Assembla username, and select the workspace you created in P4V. Accept the settings.
Now you can check files in and out directly from the Unreal Editor. Make changes to your project, and the revision control panel shows exactly what you’ve modified. Submit changes with detailed comments linking to Assembla tickets.
When you enable new plugins or make source-level changes, update your project files and restart the editor.
Recommended Branching Strategy
Align your branching strategy with how actual game teams develop. Use this approach:
Mainline Branch: The stable branch where builds are generated and released. Artists and QA work against this branch.
Development Branch: A shared integration branch where completed features are merged from personal branches.
Personal Branches: Each developer works in isolation on their own branch. When a feature is complete, they merge down to development, then the work gets copied up to mainline for the team.
This “merge down, copy up” strategy minimizes conflicts and keeps the mainline stable.
Assembla’s Additional Tools
Beyond Perforce, Assembla provides integrated project management:
Ticketing System: Agile sprint management with Kanban-style card walls. Track progress, assign work, and see metrics across your portfolio.
Wiki Pages: Collaborative documentation to replace tools like Confluence. Version-controlled, searchable, and organized.
Activity Metrics: Dashboards showing commits, ticket status, and team activity for data-driven decisions.
These tools centralize your workflow. You don’t context switch between separate tools for source control, tickets, and documentation.
Syncing Existing Repositories
If you’re joining a project that’s already in Perforce, use p4 sync to pull down the repository. Assembla provides scripts that automate the initial setup, discovering project files and regenerating workspace configurations.
Once synced, open the project in Unreal Engine. The revision control panel shows all files tracked by the mainline branch, and you can review changes directly in the editor.
Addressing Common Challenges
Large Binary Files
Unreal Engine projects are asset-heavy. Exclusive checkout policies prevent conflicts. Perforce’s type map configuration ensures that assets like textures and models are locked during editing.
Optimizing Sync Speeds
Enable parallel sync if your server setup is reliable. It significantly improves syncing performance for large projects. Local or regional caching also helps. Network tuning and optimized workspace configurations contribute to faster syncing.
Upgrading Engine Versions
If you’re using the binary version, upgrades are trivial. Epic ensures backward compatibility. Load your project with the new engine version and continue working.
If you compiled from source, upgrades are complex. You need to carefully merge engine changes into your modifications, which is resource-intensive.
Frequently Asked Questions
Q: Do I need to compile Unreal Engine from source?
A: Only if you need to modify the engine itself. Most teams should use the binary installation.
Q: Can Assembla replace Jira and Confluence?
A: Yes. Assembla provides integrated ticketing and wiki systems designed to replace both, streamlining project management within one platform.
Q: How does Perforce handle merge conflicts on binary files?
A: Binary files cannot be merged. Perforce uses exclusive checkout to lock these files, so only one user can edit them at a time.
Q: Is there a Git blame equivalent in Visual Studio?
A: Yes. The P4VS plugin includes a “time-lapse view” that shows file history and individual changes directly in Visual Studio.
Q: How do I exclude temporary and generated files?
A: Use stream specifications or P4 ignore files to exclude directories like intermediate builds, derived data cache, and Visual Studio temporary folders.
Q: What branching strategy works best with Assembla’s sprint workflow?
A: Use the “merge down, copy up” strategy. Developers work in personal branches, merge completed work to a development branch, then the work gets copied to mainline for team use.
Conclusion
Setting up Unreal Engine 5 properly with Assembla and Perforce provides the foundation for teams to scale efficiently, collaborate seamlessly, and maintain clean project architecture. By making the right decisions early—binary installation over source compilation, proper type map configuration, direct integration with the editor, and a disciplined branching strategy—you focus on developing your game rather than fighting broken builds and asset conflicts.
This is the first session in a three-part series. The second session covers collaborative source control and branching strategies in greater depth. The third session focuses on boosting C++ productivity with Visual Assist. These tools and practices, applied from day one, create production-ready workflows that survive the chaos of real game development.