How to Install Git on macOS: Xcode Tools, Homebrew and Setup

macOS makes Git available through Apple’s Xcode Command Line Tools, and many Macs already have it. The main decision is whether that version is enough, or whether you want a current upstream Git from Homebrew — and, if you install both, knowing which one you are actually running.

Before you start

• A Mac running a currently supported version of macOS.
• The Terminal app (in /Applications/Utilities) or another terminal emulator.
• Lesson 3 — How Git Actually Works for useful background, though not required.

Version-sensitive lesson

Apple’s bundled Git version and Homebrew’s install paths change over time. The commands here follow the official guidance at git-scm.com/install/mac and docs.brew.sh. Version numbers you see will differ from any shown here.

Step 1 — Check what you already have

Open Terminal and run:

git --version

What it doesPrints the version of Git currently on your PATH.

Why we run itMany Macs already have Git via the Xcode Command Line Tools. Checking first tells you whether you need to install anything at all.

Expected resultEither a version string, or a dialog offering to install the command line developer tools — see below.

Three outcomes are possible.

A version prints. Git is installed. Note the number; Apple’s build typically shows an Apple-specific suffix such as git version 2.39.5 (Apple Git-154).

A dialog appears saying the git command requires the command line developer tools. This is macOS offering to install them. Click Install, or cancel and use one of the methods below.

command not found. No Git and no developer tools. Continue to the next step.

Step 2 — Install Git

Two supported routes. Read both before choosing.

Xcode Command Line Tools

Apple’s developer tools package includes Git along with compilers and other build tooling.

xcode-select --install

A dialog appears; confirm it and wait for the download to finish. Then verify:

git --version

When to choose this: you want the simplest, Apple-supported route, or you need the other developer tools anyway. Many other tools — including Homebrew — require these tools, so installing them is rarely wasted.

The trade-off: Apple’s bundled Git lags upstream, sometimes by a year or more. It is a complete, working Git and everything in this curriculum works with it. Newer Git features simply will not be available.

Homebrew

Homebrew is the community package manager for macOS and tracks upstream Git closely.

If you do not already have Homebrew, install it using the command published on brew.sh — always take it from the official site rather than copying it from a tutorial, since it is a script that runs with your privileges.

Then:

brew install git

Verify:

git --version

To upgrade later:

brew update
brew upgrade git

When to choose this: you want current Git, or you already manage other developer tooling with Homebrew.

The trade-off: an extra tool to maintain, and the PATH question covered in the next section.

MacPorts

If you already use MacPorts rather than Homebrew:

sudo port install git

The same PATH considerations apply.

Which should you pick?

If you have no strong preference: run xcode-select --install and get on with learning Git. You can add Homebrew’s Git later at any time without uninstalling anything. Nothing in this curriculum needs a version newer than Apple ships.

Step 3 — Know which Git you are running

If you install Homebrew’s Git alongside Apple’s, both exist on disk and PATH order decides which one runs. This is the most common source of “I upgraded Git but the version did not change.”

which git

What it doesPrints the full path of the git executable your shell will actually run.

Why we run itIt resolves the ambiguity directly. git --version tells you what is running; which git tells you where it came from.

Expected resultA path. Apple's is /usr/bin/git. Homebrew's is /opt/homebrew/bin/git on Apple silicon, or /usr/local/bin/git on Intel Macs.

To see every git on your PATH, in the order the shell would try them:

which -a git

/opt/homebrew/bin/git
/usr/bin/git

The first line wins. If Homebrew’s Git is installed but /usr/bin/git appears first, Homebrew’s directory is not early enough on your PATH. Homebrew’s installer normally configures this; if it did not, add it to your shell profile:

zsh (default)

echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"

bash

echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.bash_profile
eval "$(/opt/homebrew/bin/brew shellenv)"

On Intel Macs substitute /usr/local/bin/brew. brew shellenv prints the correct settings for your installation, so it adapts automatically rather than hardcoding a path.

zsh is the default shell on modern macOS

macOS has used zsh as the default login shell since Catalina. If you are unsure which shell you are using, run echo $SHELL. Older tutorials that tell you to edit ~/.bash_profile were written for the bash era; on a current Mac, ~/.zprofile is usually the file you want.

Step 4 — Configure your identity

1. Set your name.

   git config --global user.name "Your Name"

2. Set your email.

   git config --global user.email "you@example.com"

3. Confirm both.

   git config --global --list

Commit identity is permanent

The author name and email become part of the commit object, and therefore part of the data its ID is computed from. Changing them later requires rewriting history into entirely new commits. Set them before your first commit.

Step 5 — Set the default branch name

git config --global init.defaultBranch main

Older Git versions — including some Apple builds — create master by default and print a hint about it. This setting makes new repositories use main, matching current convention everywhere.

Step 6 — Choose an editor

nano

git config --global core.editor "nano"

Included with macOS and easy to leave: Ctrl+O to save, Ctrl+X to exit.

VS Code

git config --global core.editor "code --wait"

Requires the code command, installed from VS Code via Command Palette → Shell Command: Install ‘code’ command in PATH. The --wait flag is required.

Vim

git config --global core.editor "vim"

Write and quit with :wq. Abort with :q!, which cancels the commit.

Step 7 — Credential handling

macOS provides an encrypted credential store — the Keychain — and Git integrates with it through the osxkeychain credential helper. Both Apple’s Git and Homebrew’s Git include it.

git config --global credential.helper osxkeychain

After this, the first HTTPS push prompts for credentials once and stores them in the Keychain. Subsequent operations retrieve them automatically.

Check what is configured:

git config --get credential.helper

Do not use the store helper

credential.helper store writes credentials to ~/.git-credentials in plain text. On macOS the Keychain is already available and encrypted, so there is no reason to accept that risk.

To remove a stored credential after rotating a token, open Keychain Access, search for the host name, and delete the entry. Or from the terminal:

git credential-osxkeychain erase

Then type host=github.com, press Enter twice.

SSH as an alternative

Rather than HTTPS and tokens, you can authenticate with an SSH key pair:

ssh-keygen -t ed25519 -C "you@example.com"

This writes ~/.ssh/id_ed25519 (private — never share it) and ~/.ssh/id_ed25519.pub (public — safe to upload to a hosting provider). macOS can store the key’s passphrase in the Keychain so you are not prompted repeatedly:

ssh-add --apple-use-keychain ~/.ssh/id_ed25519

SSH key management is a topic in its own right and will be covered properly in a future GitHub Engineering pillar. HTTPS with the Keychain helper is a perfectly good starting point.

Inspecting your configuration

git config --list --show-scope --show-origin

On macOS the scopes typically resolve to:

Scope	Typical location
System	/etc/gitconfig, or /opt/homebrew/etc/gitconfig for Homebrew’s Git
Global	~/.gitconfig
Local	.git/config inside the repository

Local overrides global, and global overrides system.

Two Git installations mean two system configs

Apple’s Git and Homebrew’s Git read different system-level config files. Your global config in ~/.gitconfig is shared by both, which is why identity and editor settings carry across. If a setting appears to apply under one Git and not the other, check whether it was written to a system scope.

Updating Git

Xcode Command Line Tools

Apple’s Git updates with macOS system updates. There is no separate command. To force a reinstall of the tools:

sudo rm -rf /Library/Developer/CommandLineTools
xcode-select --install

Homebrew

brew update
brew upgrade git

brew update refreshes Homebrew’s package definitions; brew upgrade git installs the newer version.

MacPorts

sudo port selfupdate
sudo port upgrade git

Troubleshooting

A dialog says the git command requires developer tools. Expected on a Mac without them. Click Install, or run xcode-select --install.

git --version shows an old version after brew install git. A PATH ordering problem. Run which -a git and confirm Homebrew’s directory comes first. See Step 3.

“The git command requires the command line developer tools.” The dialog macOS shows when git is run before any developer tools exist. It is not an error — it is the installer. Click Install, or run xcode-select --install from the terminal. Either way, Apple’s Git is what you get; see the next item.

git version 2.39.5 (Apple Git-154) — why does it say Apple Git? Because it is Apple’s build, shipped with the command line tools and versioned on Apple’s schedule rather than Git’s. It is a real, working Git. If you need a current upstream release, install one with Homebrew (brew install git) and make sure /opt/homebrew/bin precedes /usr/bin in your PATH; which git tells you which one is winning.

xcode-select: error: command line tools are already installed. They are present. Run git --version to confirm Git works. To reinstall, remove /Library/Developer/CommandLineTools first.

Author identity unknown when committing.

*** Please tell me who you are.
fatal: unable to auto-detect email address

user.name and user.email are unset in an applicable scope. Return to Step 4 and use --global.

brew: command not found. Homebrew is installed but not on your PATH. Run the brew shellenv commands from Step 3.

Credentials prompted on every push. No credential helper is configured. Run git config --global credential.helper osxkeychain.

fatal: detected dubious ownership in repository. Git refuses to operate on a repository owned by a different user — a safety check. If the ownership is legitimate:

git config --global --add safe.directory /path/to/repo

Add specific paths rather than disabling the check.

Case-sensitivity surprises. The default macOS filesystem is case-insensitive but case-preserving. Renaming Readme.md to README.md may not register as a change. Force it explicitly:

git mv --force Readme.md README.md

This matters when collaborating with Linux users, whose filesystems treat those as two distinct files.

Uninstalling Git

Xcode Command Line Tools

Apple’s Git is part of the developer tools and is not separately removable. To remove the whole package:

sudo rm -rf /Library/Developer/CommandLineTools

Note that this removes compilers and other tooling that other software may depend on.

Homebrew

brew uninstall git

If Apple’s Git is also installed, git continues to work afterwards — it falls back to /usr/bin/git.

MacPorts

sudo port uninstall git

Uninstalling does not delete repositories

Removing Git leaves your project folders and their .git directories intact. Conversely, deleting a project’s .git directory destroys that project’s entire history irreversibly, whether or not Git is installed.

What You Learned

• macOS offers Git through Xcode Command Line Tools (xcode-select --install) or Homebrew (brew install git).
• Apple’s Git lags upstream but is complete and sufficient for this curriculum.
• With both installed, PATH order decides which runs — which -a git shows the resolution.
• Homebrew lives at /opt/homebrew on Apple silicon and /usr/local on Intel; brew shellenv configures the right one.
• credential.helper osxkeychain stores credentials in the encrypted macOS Keychain.
• The default macOS filesystem is case-insensitive, which affects case-only renames.

Try It Yourself

1. Run which -a git. If more than one path appears, you have multiple installations — identify which one wins.
2. Run git --version and note whether the output includes an (Apple Git-…) suffix.
3. Set your identity with --global, then confirm with git config --global --list.
4. Create a scratch directory, run git init, and confirm the branch is named main.

Your first ten minutes with Git

Git is installed. Three things now, in Terminal, and you will have made your first commit before you close this tab.

1. Tell Git who you are — every commit records this, and it is the one thing the installer cannot guess.

   git config --global user.name "Your Name"
   git config --global user.email "you@example.com"
   git config --global init.defaultBranch main
   git config --global --list

   user.name=Your Name
   user.email=you@example.com
   init.defaultbranch=main

2. Make a repository and a first commit — a folder, one file, one snapshot.

   mkdir hello && cd hello
   git init
   echo "# Hello" > README.md
   git add README.md
   git commit -m "First commit"
   git log --oneline

   Initialized empty Git repository in …/hello/.git/
   [main (root-commit) 89ee335] First commit
    1 file changed, 1 insertion(+)
    create mode 100644 README.md
   89ee335 First commit

   That seven-character id is a hash of the snapshot. Yours will differ — it includes your name and the time.

3. Learn what you just did. Day 1 of the 7-Day Git Challenge is What a commit is: Explain why a commit is a snapshot, not a diff, and why every clone is complete. One lesson a day for a week, tracked in My Academy on this device — no account.

   Start Day 1 → What a commit isSee all seven days

Next Lesson

Your environment is ready. The next lesson is a full hands-on tutorial: you will build a repository from nothing, make two commits, and understand exactly what each command did.

Lesson 7 — Your First Git RepositoryA complete guided walkthrough from empty directory to readable history.

Lesson 3 — How Git Actually WorksRevisit the model behind the commands before you run them.