Installing Unity & Unity Hub

Follow these steps to get set up with the recommended Unity version for this course:

  1. Download Unity Hub:
    Go to the official Unity download page (https://unity.com/download).
    Click on the download button (e.g. Download for Windows).
    This will download the installer file for your operating system (e.g., UnityHubSetup-x64.exe on Windows).
  2. Install Unity Hub:
    Run the downloaded installer file.
    Follow the on-screen instructions, agree to the terms, and choose your install location.
    Once installed, open the Unity Hub application.
  3. Create a Unity ID and Get a License:
    In the Unity Hub, sign in to your Unity account. If you don't have one, click "Create one" and follow the steps.
    After signing in, you will need a license. Navigate to Settings -> Licenses.
    Click "Add" and choose the "Unity Personal" license (it is free for students and individuals under a revenue threshold). Accept the terms.
  4. Install the Unity Editor:
    Go to the Installs tab in the Unity Hub.
    Click the "Install Editor" button.
    You will be asked to choose a Unity Editor version. While we use Unity 6.2 on tutorials, it is recommend to use a Long-Term Support (LTS) version from the Unity 6 cycle, such as Unity 6 LTS or Unity 6.3 LTS, for optimal stability. If the Unity Hub suggests a newer version by default, you may need to click "Install a specific version" or check the Archive section to find the recommended LTS release. You can learn more about how Unity 6 releases are supported and what LTS means here: https://unity.com/releases/unity-6/support

Render Pipelines

A Render Pipeline is a set of procedures that takes the scenes and assets you create and displays them as rendered images on a screen. Essentially, it determines how the graphics are drawn, handling everything from lighting, shadows, materials, and post-processing effects.

Unity 6 offers different Render Pipelines, allowing you to choose one that best fits the graphical fidelity, performance needs, and target platform of your project.

Main options:

  • Universal Render Pipeline (URP) - It is optimized for performance and scalability across the widest range of platforms, from mobile devices and consoles to high-end PCs. It is ideal for 2D, 3D, and AR/VR projects where performance and broad compatibility are key.
  • High Definition Render Pipeline (HDRP) - This is a high-fidelity pipeline designed to create cutting-edge, realistic visuals for high-end platforms where graphical quality is the top priority (e.g. modern consoles and powerful PCs). It uses advanced rendering techniques like ray tracing and complex lighting models.

A major advantage of URP and HDRP is that both are Scriptable Render Pipelines (SRPs). This means you have the ability to customize and extend their rendering features using C#, allowing you to tailor the graphics output precisely to your project's unique needs.

You may encounter references to the Built-In Render Pipeline (BIRP) in older Unity tutorials. This was the default rendering method used in versions of Unity prior to Unity 6. It is important to note that the Built-In Render Pipeline is deprecated and not supported in Unity 6. All new Unity 6 projects must choose between URP or HDRP.

Further Reading on Render Pipelines

Render Pipelines Overview (How it works): https://docs.unity3d.com/6000.2/Documentation/Manual/render-pipelines-overview.html
Main Render Pipelines Documentation: https://docs.unity3d.com/6000.2/Documentation/Manual/render-pipelines.html


Universal Render Pipeline cross-platform rendering example.

 

Version Control (Git) for Unity Projects

As your projects grow, managing changes becomes essential. This is where a Version Control System (VCS) comes in. A VCS allows you to track history, revert changes, do branching and more.

While Unity offers its own solution, Unity Version Control (UVCS) (formerly Plastic SCM), we will use Git since it is free and open-source.

Essential Files

Unity projects contain many temporary files and large binary assets (3D models, textures, scenes). Git is optimized for tracking changes in plain text (like C# scripts), which presents two challenges:

  • Large Binary Assets: Committing huge binary files (like textures and models) directly to Git makes the repository size quickly explode and slows down cloning for everyone.

  • Generated Files: Unity generates many local files (Library, Temp, etc.) that are unique to each user's machine or build, and should never be committed as they cause conflicts.

Because of that it is necessary to use:

  • Git LFS is a Git extension that replaces large binary files (e.g. .fbx, .wav, large .unity Scene files) with small text pointers in your repository. The actual file content is stored on a separate remote server. This keeps your Git repository fast and compact.
  • The .gitignore file in the root of your project to tell Git which files and folders to not track. Such files are those which are stored in Library/, Temp/, Obj/ and Builds/ directories. On the other hand files from Assets/ and ProjectSettings/ directories and all .meta files must be tracked. 
    You can copy the latest version of .gitignore for you project at https://github.com/github/gitignore/blob/main/Unity.gitignore.

Editor Settings for Version Control

Configuring these specific settings under Edit > Project Settings > Editor is the required step to ensure that Unity saves your project data in a format that is compatible with, and easily tracked by, version control systems like Git.

  • Version Control Mode > Visible Meta Files

  • Asset Serialization > Force Text

Git Command‑Line

  • Add the official Unity .gitignore (keeps Library/, Temp/, Obj/, Build/ out).
  • Enable Git LFS for large binaries (e.g., textures, audio, video).
    e.g. git lfs track "*.psd" "*.png" "*.jpg" "*.mp4" "*.wav" "*.fbx" "*.zip"
  • Keep .meta files tracked, since they’re required for Unity assets.
  • Commit small, logical chunks (feature branches, frequent pushes).
  • When cloning a repo that uses LFS, run:
    git clone <repo‑url>
    git lfs pull 

If you are interested in using Unity Version Control, this page could help: https://unity.com/solutions/git .