How did I end up with a detached HEAD?

Question

I checked out a commit/branch from master, and then checked out back to master and wrote something. After that, I committed it, but I ended up with a detached HEAD. Why? Here is what I did: - Create a new project and create git repository. - git add - git commit - type some words - git commit - checkout to previous commit checkout back type some word try to commit; it prompts there is a detached head. IntelliJ IDEA's console shows: ``` 17:08:58.143: cd C:\Users\jiahao\IdeaProjects	esttt\src 17:08:58.143: git init Initialized empty Git repository in C:/Users/jiahao/IdeaProjects/testtt/src/.git/ 17:09:16.331: cd C:\Users\jiahao\IdeaProjects	esttt\src 17:09:16.331: git -c core.quotepath=false add --ignore-errors -- C.java 17:09:24.407: cd C:\Users\jiahao\IdeaProjects	esttt\src 17:09:24.407: git -c core.quotepath=false commit --only -F C:\Users\jiahao\AppData\Local\Temp\git-commit-msg-0.txt -- C.java [master (root-commit) 22d1c79] first commit 1 file changed, 6 insertions(+) create mod…

Accepted Answer

Problem and solution

Close inspection of the IntelliJ-IDEA log reveals the nature of the problem. After creating your first two commits, you were in the following situation:

Somehow, you checked out your first commit, which put you in detached-HEAD state:

Then, similarly, you checked out your second commit (which happened to be the tip of your `master` branch). This still left you in detached-HEAD state:

You write:

I checked out a commit/branch from `master` [...]

Be careful. Checking out a commit that happens to be the tip of a branch is not equivalent to checking out that branch!

Note that `HEAD` is now pointing directly to a commit, not to a branch. That is the definition of "detached HEAD". The fact that `HEAD` points to the same commit as `master` changes nothing about the fact that your HEAD is detached.

Some IDEs may not give you a clear indication that you are in fact in detached-HEAD state. Even `git log --decorate`, for a long time, gave you no clue as to whether `HEAD` was pointing to `master`, or detached and pointing directly at `master`'s tip.

You then made a third commit, which, as expected, still left you with a detached HEAD; your `master` branch still points to the second commit.

To get out of detached HEAD-state, you need to reattach `HEAD` to a branch (`master`, here). How depends on what you want to do. In the following, I'm assuming you have access to the Git CLI:

If you want to discard your third commit, simply run

```
git checkout master
```

and you'll end up back in this situation:

If you want to keep your third commit and make `master` point to it, run

```
git branch -f master HEAD
```

and then

```
 git checkout master
```

Parting tip

Learning Git in an IDE is a recipe for disaster. I recommend you build your understanding at the command line first, and only then start using Git from within a GUI, if you feel that doing so would improve your workflow.

How did I end up with a detached HEAD?

Solution

Problem

Related problems