Back
GitoryxGitoryx
Beginner9 min read

Git Checkout: Switch Branches, Files, and Commits

git checkout is one of Git's most versatile commands. This guide covers switching branches, checking out specific commits (detached HEAD), restoring individual files, and how the newer git switch and git restore commands relate to it.

The Problem

You run git checkout to switch branches and it works — but then you use it to look at an old commit and Git tells you you're in a 'detached HEAD state'. What does that even mean?

git checkout is one of Git's oldest and most overloaded commands. It can switch branches, restore files, and navigate to specific commits. Understanding what it does in each case — and when to use the newer git switch and git restore instead — will save you from confusing mistakes.

Common mistakes developers make with this:

  • Ending up in a detached HEAD state and making commits that get lost
  • Using git checkout <file> to discard changes and permanently losing work
  • Forgetting to create a branch after checking out a specific commit
  • Confusion between git checkout branch and git checkout -- file

Gitoryx: In Gitoryx, double-clicking a branch or commit in the graph checks it out instantly — with a clear visual indicator when you're in detached HEAD state.

What is Checkout: Switch Branches, Files, and Commits?

git checkout switches branches, restores files, or navigates to a specific commit. Modern Git (2.23+) splits this into two focused commands: git switch for branches and git restore for files.

Step-by-Step Guide

1

git checkout vs git switch vs git restore — what's the difference?

Git 2.23 (2019) introduced git switch and git restore to split git checkout into two focused commands. All three still work today, but the newer commands are clearer and harder to misuse.

bash
# git checkout does THREE different things (confusing):
git checkout feature/login       # switches branch
git checkout -b new-branch       # creates + switches branch
git checkout -- src/app.ts       # discards file changes (DANGEROUS, easy to mistype)

# git switch — branch operations only (clear intent):
git switch feature/login         # switches branch
git switch -c new-branch         # creates + switches branch

# git restore — file operations only (clear intent):
git restore src/app.ts           # discards file changes in working dir
git restore --staged src/app.ts  # unstages a file (keeps changes in working dir)
git restore --source HEAD~2 src/app.ts  # restore file from 2 commits ago

Use git switch and git restore for new work — they make intent explicit and prevent the accidental file-destruction bug of git checkout -- file. The old git checkout still works and won't be removed.

2

Switch to an existing branch

The most common use. Both syntaxes work; git switch is clearer.

bash
# Modern (recommended)
git switch feature/login

# Classic
git checkout feature/login
3

Create and switch to a new branch

Create a branch and check it out in one step.

bash
# Modern
git switch -c feature/new-thing

# Classic
git checkout -b feature/new-thing
4

Check out a specific commit (detached HEAD)

You can navigate to any commit by its SHA. Git enters 'detached HEAD' mode — you're not on any branch.

bash
git checkout a3f2c1d

# Git warns you:
# HEAD is now at a3f2c1d add login form
# You are in 'detached HEAD' state.

In detached HEAD state, any commits you make won't belong to a branch. If you switch away, those commits become unreachable. Create a branch immediately if you want to keep them: git switch -c my-branch.

See this workflow in Gitoryx. Double-click any branch or commit in the graph to check it out

Free download
5

Check out a remote branch locally

To start working on a branch that exists only on the remote, create a local tracking branch.

bash
git switch -c feature/remote-work origin/feature/remote-work
# or shorthand:
git checkout --track origin/feature/remote-work
6

Restore a file to its last committed state

Discard all changes to a specific file and revert it to the last commit. git restore is the clear, modern way to do this.

bash
# Modern (recommended — explicit, no ambiguity)
git restore src/app.ts

# Unstage a file (keep changes in working dir, just remove from staging)
git restore --staged src/app.ts

# Classic (still works but ambiguous syntax — easy to accidentally destroy work)
git checkout -- src/app.ts

This permanently discards your uncommitted changes to that file. There is no undo.

7

Restore a file from a specific commit

Pull a specific version of a file from any commit into your working directory.

bash
git restore --source a3f2c1d src/app.ts
# or classic:
git checkout a3f2c1d -- src/app.ts

This doesn't change your branch — it just replaces the file content with the version from that commit.

Common Mistakes to Avoid

Making commits in detached HEAD state

Commits made in detached HEAD are not reachable by any branch. When you switch branches, Git warns you they'll be lost.

Fix: As soon as you realize you're in detached HEAD and want to keep your work, run git switch -c <new-branch> to attach your commits to a real branch.

Using `git checkout -- <file>` accidentally

It looks similar to other checkout commands but discards all your uncommitted file changes permanently.

Fix: Prefer git restore <file> — it's explicit about restoring files and harder to mistype. Always run git status before restoring to confirm you're targeting the right file.

Not knowing the difference between `git switch` and `git checkout`

git checkout does too many things; git switch and git restore were introduced in Git 2.23 to make the intent clear.

Fix: Use git switch for branch operations and git restore for file operations going forward.

Gitoryx — visual Git client for macOS & Windows
GitoryxGitoryx — macOS & Windows

Navigate commits and branches visually in Gitoryx

  • Double-click any branch or commit in the graph to check it out
  • Detached HEAD state is clearly indicated with a special icon
  • Create a branch from a detached HEAD in one click
  • Restore individual files with right-click → Discard changes
Download Gitoryx — FreemacOS · Windows · No subscription

Frequently Asked Questions

What is the difference between git checkout, git switch, and git restore?

git checkout does three things at once: switch branches, create branches, and restore files — which makes it error-prone. Git 2.23 split it into two focused commands: git switch for branch operations (switch, create) and git restore for file operations (discard changes, unstage). All three still work, but git switch and git restore are clearer and safer for new work.

What is detached HEAD in Git?

Detached HEAD means your HEAD pointer points directly to a commit instead of a branch. You can browse and even commit, but those commits won't belong to any branch and will be lost if you check out another branch without creating a new one first.

How do I get out of detached HEAD state?

Run git switch <branch-name> to return to a named branch. If you made commits you want to keep, first run git switch -c <new-branch> to save them on a new branch before switching away.

How do I unstage a file in Git?

Use git restore --staged <file> to unstage a file. This removes it from the staging area but keeps your changes in the working directory. The classic equivalent is git reset HEAD <file>.

Can I restore a deleted file with git checkout?

Yes. Use git restore <file> if the file was deleted since the last commit, or git restore --source <sha> <file> to restore a file from a specific commit in history.

What is the difference between `git checkout` and `git switch`?

git switch was introduced in Git 2.23 as a focused replacement for the branch-switching part of git checkout. Similarly, git restore handles file restoration. The old git checkout still works but does too many different things.

Can I check out a file without switching branches?

Yes. git restore <file> restores a file to its last committed state without changing your current branch. Use git restore --source <sha> <file> to restore from a specific commit.

Related Tutorials

Git Branch: Create, Switch, and Manage Branches

9 min

How to Undo a Commit in Git (The Right Way)

10 min

Git Reset: Undo Changes at Any Stage

10 min

See it in action with Gitoryx

Everything in this tutorial is faster and clearer with a visual Git client. Gitoryx is free, runs natively on macOS and Windows, and built for developers who want to move fast without breaking things.

Download Gitoryx — FreeBrowse all tutorialsCompare Git clients