Is "detached HEAD state" an error?

No, it is not an error. It is a warning. Git is telling you that HEAD points directly to a commit instead of a branch. You can still look around, make changes, and commit. The risk is that those commits can be lost if you switch to a branch without saving them first.

Why does checking out a commit cause detached HEAD?

Branches are movable pointers to commits. When you check out a branch, HEAD points to the branch, and the branch points to a commit. When you check out a commit hash directly, there is no branch involved, so HEAD is "detached" from any branch.

Will I lose my commits in detached HEAD?

Not immediately. But if you switch to a branch without creating a new branch first, those commits become orphaned. They still exist in the repository and can be found with "git reflog" for about 30 days before Git garbage-collects them.

How do I avoid detached HEAD in the future?

Use "git switch" instead of "git checkout" for branch navigation. git switch will warn you more clearly and will not detach HEAD unless you explicitly use the --detach flag. When you need to inspect a tag or old commit, create a branch right away with "git switch -c branch-name ".

Does interactive rebase cause detached HEAD?

Yes. During an interactive rebase, Git temporarily enters detached HEAD state to replay commits one by one. This is normal. Once the rebase finishes, HEAD reattaches to your branch. If the rebase is interrupted, run "git rebase --abort" to return to your branch safely.

detached HEAD state — What it means in Git

This is not really an error but a warning that confuses many beginners. HEAD points to a commit instead of a branch. Here is what that means and how to handle it.

Learn Git step by step

Warning

What this warning means

In Git, HEAD is a pointer that tells Git which commit you are currently working on. Normally, HEAD points to a branch (like main), and the branch points to a commit.

When you are in detached HEAD state, HEAD points directly to a commit instead of a branch. You can still browse files, make changes, and create commits — but those commits don't belong to any branch.

The danger is that if you switch to a branch without saving your work, those orphaned commits can eventually be garbage-collected and lost. The fix is simple: create a branch before switching away.

terminal — detached HEAD

$git checkout a1b2c3d

Note: switching to 'a1b2c3d'.

You are in 'detached HEAD' state. You can look around, make experimental

changes and commit them, and you can discard any commits you make in this

state without impacting any branches by switching back to a branch.

Why it happens

Checking out a specific commit

Running git checkout a1b2c3d moves HEAD directly to that commit. Since you are not on a branch, Git enters detached HEAD state. This is the most common trigger.

Checking out a tag

Tags point to a specific commit, not a branch. Running git checkout v1.0.0 puts you in detached HEAD just like checking out a commit hash. To work from a tag, create a branch immediately.

During an interactive rebase

When you run git rebase -i, Git replays your commits one at a time in detached HEAD state. This is normal and temporary — HEAD reattaches to your branch once the rebase completes.

How to fix it

Two options: save your work to a new branch, or go back to an existing one.

1. Save work to a new branch

terminal — save branch

# Save your work by creating a new branch

$git switch -c my-new-branch

Switched to a new branch 'my-new-branch'

# All your commits are now safely on this branch

$git log --oneline -3

f8e9d0a Your latest commit in detached HEAD

a1b2c3d The commit you checked out

7c6d5e4 Previous commit

2. Return to a branch

terminal — switch back

# Go back to an existing branch (discard detached work)

$git switch main

Switched to branch 'main'

# If you made commits in detached HEAD and forgot to save:

$git reflog

f8e9d0a HEAD@{1}: commit: work done in detached HEAD

a1b2c3d HEAD@{2}: checkout: moving from main to a1b2c3d

# Recover lost commits with cherry-pick or branch

$git cherry-pick f8e9d0a

[main g7h8i9j] work done in detached HEAD

3. Work from a tag

terminal — tag branch

# Checking out a tag puts you in detached HEAD

$git checkout v1.0.0

You are in 'detached HEAD' state.

# To work from this tag, create a branch

$git switch -c hotfix-from-v1

Switched to a new branch 'hotfix-from-v1'

How to prevent it

Use git switch instead of git checkout

git switch is designed for branch navigation and refuses to detach HEAD unless you explicitly use --detach. This prevents accidental detached HEAD situations.

Create a branch when inspecting old commits

Instead of git checkout a1b2c3d, use git switch -c inspect-commit a1b2c3d. This gives you a branch right away, so any commits you make are safe.

Know when detached HEAD is normal

During git rebase -i or git bisect, detached HEAD is expected. Don't panic — just let the operation finish or abort it cleanly if something goes wrong.

Related commands

git switch

Modern way to change branches without detaching HEAD

git checkout

Switch branches, restore files, or detach HEAD

git branch

Create, list, and manage branches

GitQuest is created by Anaïs (nouvelle fenêtre), web developer and head of education, specializing in tech training and digital accessibility.

FAQ — detached HEAD state

Master Git branches with GitQuest

Practice branching, merging, and navigating commits through interactive investigations.

Start learning Git