Table of Contents

How to Work on the Same Project in Unity on Two Computers: A Comprehensive Guide

Quick answer

This page answers How to work on the same project in Unity on two computers? quickly.

Fast answer first. Then use the tabs or video for more detail.

Watch the video explanation below for a faster overview.
Game mechanics may change with updates or patches.
Use this block to get the short answer without scrolling the whole page.

Read the FAQ section if the article has one.
Use the table of contents to jump straight to the detailed section you need.
Watch the video first, then skim the article for specifics.

▶

Working collaboratively on a Unity project is crucial for many game development teams. The ability for multiple developers to contribute simultaneously, share assets, and merge code streamlines the development process and accelerates project completion. So, the core question: How do you work on the same project in Unity on two computers? The answer boils down to using version control, primarily Git (often hosted on platforms like GitHub, GitLab, or Bitbucket) in conjunction with appropriate Unity settings. This allows you to track changes, manage conflicts, and maintain a consistent project state across multiple machines.

Here’s a breakdown of the process:

Choose a Version Control System (VCS): Git is the industry standard due to its robust features, wide adoption, and excellent tooling.
Create a Repository: Set up a new repository on a Git hosting platform like GitHub, GitLab, or Bitbucket. This repository will serve as the central location for your project.
Clone the Repository: On each computer, use the Git command git clone <repository_url> to download a local copy of the repository to your machine. This creates a working directory containing all the project files.
Configure Unity for Version Control: This is arguably the most critical step. Unity’s default settings aren’t ideal for Git.
- Edit > Project Settings > Editor: Set “Version Control” to “Visible Meta Files”. This forces Unity to generate .meta files for every asset. These .meta files are crucial because they store the asset’s unique ID, which is used to maintain references between scenes, scripts, and assets.
- Edit > Project Settings > Editor: Set “Asset Serialization” to “Force Text”. This stores asset data in a human-readable text format, making diffs and merges much easier to handle. Binary serialization can lead to unresolvable conflicts.
Create a .gitignore File: This file tells Git which files and folders to ignore. It’s vital to prevent large, automatically generated files (like temporary build files, library folders, and user settings) from being tracked. A properly configured .gitignore file keeps your repository clean and manageable. There are several online resources that provide good default .gitignore files for Unity projects, including those provided by GitHub and GitLab. Common entries include:
```
/Library/ /Temp/ /Obj/ /Build/ /Builds/ /*.csproj /*.sln /UserSettings/ !/Assets/ 
```
Workflow for Collaboration:
- Pull Before You Start: Before making any changes, always run git pull to fetch the latest changes from the remote repository and merge them into your local branch. This ensures you’re working with the most up-to-date version of the project.
- Make Changes and Commit: Work on your tasks, adding, modifying, and deleting files as needed. Stage your changes using git add . (or git add <specific_file>) to tell Git which changes you want to include in your commit. Then, commit your changes with a descriptive message using git commit -m "Your descriptive commit message".
- Push Your Changes: After committing your changes, push them to the remote repository using git push. This makes your changes available to other team members.
- Resolve Conflicts: If conflicts arise (when two or more developers modify the same lines of code or asset), Git will flag them. You’ll need to manually resolve these conflicts by editing the conflicting files, choosing which changes to keep, and then committing the resolved files. Communication is key here – talk to your team members to understand the nature of the conflicts and avoid introducing new issues.
Branching Strategy (Optional but Recommended): For larger teams or complex projects, consider using a branching strategy like Gitflow. This involves creating separate branches for features, bug fixes, and releases, allowing for parallel development and isolating potentially unstable code.
Version Control System Platform: Consider utilizing platforms like Plastic SCM which is specifically designed for game development and handles binary files more effectively. These platforms can be particularly useful for larger projects with a lot of art assets.

By following these steps, you can effectively collaborate on Unity projects across multiple computers, leveraging the power of version control to manage changes, prevent data loss, and ensure a smooth development workflow. This approach fosters team productivity and ultimately leads to better quality games. For more information about game development and related topics, visit the Games Learning Society at https://www.gameslearningsociety.org/. The GamesLearningSociety.org can offer valuable insights.

Frequently Asked Questions (FAQs)

How do I install Git?

Git installation varies depending on your operating system. For Windows, you can download an installer from the official Git website. For macOS, you can use Homebrew (brew install git). Linux distributions typically have Git available through their package managers (apt-get install git for Debian/Ubuntu, yum install git for CentOS/RHEL, etc.).

What is a `.meta` file and why is it important?

A .meta file is a small text file that Unity automatically generates for every asset in your project. It contains a globally unique identifier (GUID) for the asset. This GUID is used to track references between assets, scenes, and scripts. Without .meta files, Unity wouldn’t be able to maintain these references correctly when sharing the project across different computers, leading to broken scenes and lost data.

Why is “Force Text” serialization important?

“Force Text” serialization instructs Unity to store asset data in a human-readable text format instead of a binary format. This makes it easier to see the changes made to assets using Git’s diff tools. Text-based files are also much easier to merge when conflicts arise. Binary files, on the other hand, are difficult to merge and often lead to data loss.

How do I create a `.gitignore` file?

Create a new text file in the root directory of your Unity project and name it .gitignore. Then, add the file paths or patterns of files and folders you want Git to ignore (e.g., /Library/, /Temp/, *.csproj).

How do I resolve merge conflicts in Unity?

Merge conflicts occur when Git cannot automatically merge changes made by different developers to the same file. To resolve a conflict:

Open the conflicting file in a text editor or a Git merge tool.
Look for the conflict markers (usually <<<<<<<, =======, and >>>>>>>).
Carefully examine the changes and decide which changes to keep or combine.
Remove the conflict markers and save the file.
Stage the resolved file using git add <file> and commit the changes.

What if I forget to pull before making changes?

If you forget to pull before making changes and someone else has pushed changes in the meantime, you’ll likely encounter merge conflicts when you try to push your changes. You’ll need to pull the latest changes, resolve any conflicts, and then push your changes.

Can I use other version control systems besides Git?

Yes, while Git is the most popular and recommended option, other version control systems can be used such as Plastic SCM, Perforce, and Subversion. However, Git offers the widest range of features, tooling, and community support, making it the preferred choice for most Unity developers. Plastic SCM is designed for the needs of Game Development more specifically than git.

How do I handle large binary files (e.g., textures, audio files)?

Git is not ideal for handling extremely large binary files. Consider using Git LFS (Large File Storage), which is an extension to Git that allows you to track large files without storing their actual content in the Git repository. Alternatively, explore Plastic SCM.

What is Git LFS?

Git LFS (Large File Storage) is a Git extension that allows you to store large files (e.g., textures, audio files, videos) outside of the main Git repository. Instead of storing the file content directly, Git LFS stores a pointer to the file, which is stored on a separate LFS server. This keeps your Git repository small and fast, while still allowing you to track changes to large files.

How do I set up Git LFS for my Unity project?

Install Git LFS: Follow the instructions on the Git LFS website.
Initialize Git LFS in your repository: git lfs install
Track the file types you want to store with Git LFS: git lfs track "*.png" (replace *.png with the appropriate file patterns).
Commit the changes to your .gitattributes file: git add .gitattributes and git commit -m "Track large files with Git LFS"
Push your changes to the remote repository.

Should I commit the `Packages` folder?

The general recommendation is that the Packages folder should be committed to version control.

Is there a way to lock assets to prevent conflicts?

Git itself does not provide asset locking functionality. Some version control systems like Perforce do. However, you can implement a basic asset locking system within your team by communicating clearly about who is working on which assets.

What is the best Git client to use?

There are several Git clients available, both GUI-based and command-line based. Popular options include:

Command Line: The standard Git command-line interface is powerful and flexible.
GitKraken: A cross-platform GUI client with a visual interface.
SourceTree: A free Git and Mercurial client for Windows and macOS.
GitHub Desktop: A simple and user-friendly Git client developed by GitHub.

The best client for you depends on your personal preferences and workflow.

How do I revert changes if something goes wrong?

Git provides several ways to revert changes:

git checkout <file>: Discards changes to a specific file and reverts it to the last committed version.
git revert <commit>: Creates a new commit that undoes the changes introduced by a specific commit. This is a safe way to undo changes because it preserves the history of your repository.
git reset --hard <commit>: Resets your branch to a specific commit, discarding all subsequent commits. This is a more drastic option and should be used with caution.

How can I contribute to the Games Learning Society?

The Games Learning Society welcomes contributions from educators, researchers, and game developers. Visit their website at https://www.gameslearningsociety.org/ to learn more about their mission, projects, and how you can get involved. The website, GamesLearningSociety.org, offers opportunities to participate in research, share resources, and connect with a vibrant community of game-based learning enthusiasts.