Get MuseScore's source code

Summary

1. Create your src folder
2. Fork MuseScore's repository
3. Clone the repository
   • Working directory
4. Set the remotes

You must have Git installed on your computer. See Set up Developer Environment.

Create your src folder

Create a folder called src to store source code projects on your machine.

Tips for creating the src folder

We recommend calling it src to keep the name as short as possible. This helps when using the terminal. Also, it's essential on Windows due to the MAX_PATH limit (see below). Avoid spaces, special characters, and non-ASCII characters in the names of all parent directories. These characters can cause problems during compilation or when running terminal commands. Ensure you have read and write permission for the src folder and all its contents. Never use sudo or "Run as administrator" to compile source code. Locate it on a drive that's internal to your machine. Using an external or network drive reduces Git performance and slows down compilation. Locate it on a modern filesystem that's native to your operating system. Native filesystems: NTFS on Windows, APFS on macOS, EXT4 or BTRFS on Linux. Using a non-native filesystem reduces Git performance and slows down compilation. Don't share it between multiple operating systems (Windows, macOS, Linux, etc). Sharing between multiple operating systems reduces Git performance and can lead to corruptions. However, sharing with multiple versions of the same OS (e.g. Windows 10 & 11, or Ubuntu & Fedora) should be OK as long as a similar version of Git is used on each one. Don't use a location that's backed-up or synced by other software (e.g. iCloud, OneDrive, Dropbox, Syncthing, etc). Instead, make commits regularly and push them to a remote repository (your fork) to create a backup.

Windows

Create your src folder at the root of an NTFS-formatted drive, such as your C: drive:

# Change to the C: drive's root directory:
cd C:\              # PowerShell or CMD
cd /c               # Git Bash

# Create a new directory for code projects:
mkdir src

It must go near the root of the drive to avoid encountering the 260 character MAX_PATH limit Windows places on the length of file paths. (Code projects like MuseScore often contain files with long names and many layers of subdirectories, particularly inside the build folder.)

Linux and macOS

Normally, it's best to create your src folder inside your Home directory:

cd ~                # Change to your Home directory.
pwd                 # Print its full path. (See below to check it's OK.)
mkdir src           # If the path is OK, create a new directory for source projects.

However, paths with unusual characters can cause problems when you try to compile or run terminal commands.

/home/Francois-Pierre42     ✔️ OK
/Users/Francois_Pierre42    ✔️ OK
/@home/Francois+Pierre      ❔ Contains special characters ('@', '+') but probably still OK.
/home/Francois Pierre       ❌ BAD: Contains space.
/Users/FrançoisPierre       ❌ BAD: Contains non-ASCII character 'ç'.

If that affects you, move the src folder elsewhere and run sudo chown -R "${USER}" src to make yourself the owner. (Next time you set up a user account, try to use only ASCII letters, numbers, hyphen, and underscore in the Home path.)

Fork MuseScore's repository

A 'fork' is a remote (i.e. online) copy of a repository. It can be edited freely without affecting the original repository.

Tip: Only create a fork if you want to edit the code. If you just want to compile then you can skip creating the fork and move straight to Clone the repository.

To create a fork:

1. Sign-in to GitHub (create a free account if necessary).
2. Visit MuseScore's official repository page: https://github.com/musescore/MuseScore
3. Click the "Fork" button in the top right to create your personal fork.

Your fork exists at https://github.com/USERNAME/MuseScore where USERNAME is your GitHub username (e.g. shoogle's fork is here).

Clone the repository

A clone is a local (i.e. offline) copy of a repository. It's basically a folder on your computer that contains the code for you to edit and/or compile.

If you made a fork then you should clone it here, otherwise clone the official repository. Make the clone inside your src folder.

# Go to your src folder. For example:
cd ~/src            # Linux and macOS
cd C:\src           # Windows - PowerShell or CMD
cd /c/src           # Windows - Git Bash

# Clone your fork if you have one:
git clone https://github.com/USERNAME/MuseScore  # Replace USERNAME with your GitHub username.

# Otherwise clone the official repo:
git clone https://github.com/musescore/MuseScore

Tip: If you have a fork and you're on Linux or macOS, consider using its SSH URL git@github.com:USERNAME/MuseScore.git instead of the HTTPS URL with the git clone command. This requires additional setup, but it means that you don't have to enter your password every time you push code changes to GitHub. On Windows it's better to use the HTTPS URL if you want the password to be remembered.

Working directory

The git clone command put the code in a new folder called "MuseScore". You should change to it now:

cd MuseScore

This folder is used as the working directory for all subsequent commands, including on subsequent pages of this guide.

Set the remotes

Git is able to push (upload code to) and pull (download code from) remote repositories, known as "remotes".

Run these commands to set the remotes for your local repository:

# If you cloned your fork earlier:
git remote add upstream https://github.com/musescore/MuseScore.git
git remote set-url upstream --push disabled  # Prevent accidental push to official repo (team members only)
git pull upstream master                     # Get latest code from official repo.
git branch -u upstream/master                # Track the official master branch instead of your fork's master branch

# If you cloned the official repo:
git remote set-url origin --push disabled    # Prevent accidental push to official repo (team members only)

Explanation (click to show/hide)

Earlier, when you cloned the repository, a default remote called origin was automatically created. It points to the URL you used with git clone, which was either your fork or the official repository. When origin is a fork, the convention is to create another remote called upstream that points to the official repository. This is useful later when you want to pull new code from the official repository to keep your fork up to date. The official repository should only ever be used with pull commands, hence pushing must be disabled on whichever remote represents the official repository. However, it is only necessary for team members to disable it explicitly because GitHub will refuse pushes from users who are not team members anyway. Tracking the upstream master branch means that git status will show how many commits your local master branch is ahead or behind the upstream master branch.

Use this command to view names and URLs of all remote repositories that Git is aware of:

git remote -v

Hint: You can create additional remotes later on with git remote add [name] [url]. This is useful if you ever need to fetch code from another person's fork.

---

Previous	Current	Next
Install Qt and Qt Creator	Top of page	Install dependencies