Error merge is not possible because you have unmerged files

Merge Conflicts arise when multiple agents modify the same part of a file and push their changes to a remote branch. When you attempt to merge, pull from or push to these branches — there’s a conflict, and Git isn’t sure which set of changes to accept and which to reject, since there’s no objective measure of which change is right.

There are three ways you can deal with a Merge Conflict — you can continue with the merge, by updating your local file to match what already exists in a remote repository, you can abort a merge, which is typically done if there’s a major conflict that isn’t easily remedied or you can keep the local changes from the working directory and force them upon the remote repository.

In this guide, we’ll take a look at the three ways you can resolve a Merge Conflict with Git.

How do Merge Conflicts Happen?

Let’s quickly create a repository and a merge conflict so we can observe which changes caused it and how the files look like when we resolve it. We’ll emulate a remote-work environment by creating two folders and two Git repositories within them:

$ cd Jane
$ git init
$ git remote add origin https://github.com/DavidLandup0/solving-merge-conflicts.git
$ cd..
$ cd John
$ git init
$ git remote add origin https://github.com/DavidLandup0/solving-merge-conflicts.git

Jane and John are working on a project together, and share the same file — README.md. John wrote the file, accidentally leaving in a typo, and pushed it to the remote origin. Jane caught this, fixed the typo and pushed the file to the remote origin again.

Once John wanted to add a new line to the file, and merge his branch to the main branch — his README.md (which has the typo) was in conflict with the main‘s README.md, which had the typo fixed.

On John’s feature branch, he added a README.md file:

$ git branch feature_john
$ git checkout feature_john
Switched to branch 'feature_john'
$ echo 'Welcome to our READMW.md!' >> README.md
$ git add README.md
$ git commit -m "Added README.md"
[feature_john c44d65f] Added README.md
 1 file changed, 1 insertion(+)
 create mode 100644 README.md

$ git push origin feature_john
git push origin feature_john
Enumerating objects: 4, done.
Counting objects: 100% (4/4), done.
...
To https://github.com/DavidLandup0/solving-merge-conflicts.git
 * [new branch]      feature_john -> feature_john
 
$ git checkout main
Switched to branch 'main'

$ git merge feature_john
Updating 48f09c2..c44d65f
Fast-forward
 README.md | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 README.md
 
$ git push origin main
Total 0 (delta 0), reused 0 (delta 0), pack-reused 0
To https://github.com/DavidLandup0/solving-merge-conflicts.git
   48f09c2..c44d65f  main -> main

John added a new file to his branch and pushed it to his remote branch and then merged into main — no issues, there weren’t any files there before that.

Now, Jane wants to get up to date with the main branch by pulling the changes made there, notices the typo — fixes it, and pushes back to main to prevent others from pulling the erroneous piece:

$ cd Jane
$ git pull origin main
remote: Enumerating objects: 4, done.
remote: Counting objects: 100% (4/4), done.
...
Updating 48f09c2..c44d65f
Fast-forward
 README.md | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 README.md
 
$ git branch feature_jane
$ git checkout feature_jane

$ echo 'Welcome to our README.md!' > README.md

$ git add README.md

$ git commit -m "Fixed typo in README.md file"
[feature_jane 60f64fc] Fixed typo in README.md file
 1 file changed, 1 insertion(+), 1 deletion(-)

$ git push origin feature_jane
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Writing objects: 100% (3/3), 292 bytes | 292.00 KiB/s, done.
...
To https://github.com/DavidLandup0/solving-merge-conflicts.git
 * [new branch]      feature_jane -> feature_jane

$ git checkout main
Switched to branch 'main'

$ git merge feature_jane
Updating c44d65f..60f64fc
Fast-forward
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

$ git push origin main
Total 0 (delta 0), reused 0 (delta 0), pack-reused 0
To https://github.com/DavidLandup0/solving-merge-conflicts.git
   c44d65f..60f64fc  main -> main

Now main is clean — no typo in the README.md. Though, John’s file is now out of sync.

• If he tries pulling the origin’s main — a Merge Conflict will occur.
• If he tries to push a change with a conflicting change on the remote branch — a Merge Conflict will occur.
• If he tries to run $ git merge on two branches that have conflicting changes — a Merge Conflict will occur.

Say John added a new line to the file, pulled from the main branch and then tried merging his new addition into main before pushing his :

$ echo 'New line!' >> README.md
$ git add README.md

$ git commit -m "Added new line to README.md"
[feature_john ba27684] Added new line to README.md
 1 file changed, 1 insertion(+)

$ git checkout main
Switched to branch 'main'

$ git pull origin main
From https://github.com/DavidLandup0/solving-merge-conflicts
 * branch            main       -> FETCH_HEAD
Updating c44d65f..60f64fc
Fast-forward
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

$ git merge feature_john
Auto-merging README.md
CONFLICT (content): Merge conflict in README.md
Automatic merge failed; fix conflicts and then commit the result.

There it is — Merge conflict in README.md. There are three things John can do to solve this conflict, as he is now in the MERGING phase. When Git encounters a conflict, it doesn’t abandon the merge — it allows you to attempt fixing the issue on the spot or abandon it if you’d like to.

Find Merge Conflict Source

The first step you need to take is find out why there’s a Merge Conflict in the first place. When in the MERGING phase, as we are, Git will annotate the file that’s causing the conflict. If we open the README.md file on John’s local machine, we’ll see:

<<<<<<< HEAD
Welcome to our README.md!
=======
'Welcome to our READMW.md!' 
New line!
>>>>>>> feature_john

The <<<<<<< denotes the cause of the conflict and the current reference follows it (HEAD). This is the change from main. Then, we’ve got the ======= line (just a separator) before John’s set of changes.

Finally, the >>>>>>> denotes that that’s the end of the conflict, with the branch name we’re trying to merge into the top side of =======.

Solve Merge Conflict with git merge —abort

A valid way to solve the conflict is to abort from it — and stop the MERGING phase. This is typically done when the solution isn’t to fix a single line — and when large changes need to be made. This usually necessitates a plan with a team member as well.

If we abort the merge, the added conflict lines will be removed and we’ll have John’s README.md file once again.

While we’re still in the merging phase, let’s abort the merge altogether:

$ git merge --abort

This simply aborts the merge and your file is returned to its state before you’ve encountered the conflict:

'Welcome to our READMW.md!' 
New line!

If you’re using Git’s Command-Line Editor (or other shells that support the feature), you’ll also be able to see which phase you’re in:

(main)
$ git merge feature_john
Auto-merging README.md
CONFLICT (content): Merge conflict in README.md
Automatic merge failed; fix conflicts and then commit the result.
(main|MERGING)
$ git merge --abort
(main)
$

Now, with your file out of harm’s way — phone your colleague and discuss your next steps. Alternatively, if you accept their changes, you can continue with the merge.

Solve Merge Conflict with git merge —continue

You can continue the merge with a conflict, but Git won’t overwrite the files automatically. If you try merging, encounter a conflict, and try to $ git merge --continue, you’ll face another error:

$ git merge feature_john
Auto-merging README.md
CONFLICT (content): Merge conflict in README.md
Automatic merge failed; fix conflicts and then commit the result.

$ git merge --continue
error: Committing is not possible because you have unmerged files.
hint: Fix them up in the work tree, and then use 'git add/rm <file>'
hint: as appropriate to mark resolution and make a commit.
fatal: Exiting because of an unresolved conflict.
U       README.md

If it were possible to continue, Git would’ve continued already. You’re still in the MERGING phase, so you can change your README.md to conform to main‘s version of it, mark the resolution by adding or removing the file again, and then run the $ git merge --continue command.

Let’s fix the file first. In our case, since the «Welcome…» line was causing an issue, but the «New line!» wasn’t — we can leave the new line in — John’s new feature — and fix the typo that’s in conflict:

Welcome to our README.md!
New line!

Now, we add the file once again and run the $ git merge --continue command:

Fix the file...
$ git add README.md

$ git merge --continue
[main fea8fbb] Merge branch 'feature_john'

You’ve accepted the changes from main and adapted your local file to reflect it, and adding it back.

Solve Merge Conflict By Forcing Local Changes to Remote

Instead of aborting, or yielding to changes — if you’re certain that the changes made in your working directory are certainly the ones to keep, you can keep the local changes instead of adapting to the remote ones.

When a Merge Conflict occurs, you can $ git checkout the file from feature_john, and then add it to the main branch.

When updating — you can keep the changes made on a different branch and apply it to this branch. On the main branch, into which we wish to merge feature_john, let’s update the README.md file to contain the changes from the feature_john branch.

In the context of main, these changes are referred to as theirs, while the changes on main are referred to as ours. If you wish to keep changes from main, switch the --theirs flag with --ours:

$ git checkout --theirs README.md
Updated 1 path from the index
$ git add README.md

$ git commit -m "Accepting changes from feature_john"
[main 5541f29] Accepting changes from feature_john

Now, you can merge the rest of the changes that are not in conflict cleanly, since we’ve only created a roundabout merge for the one file that caused a conflict this way.

Conclusion

In this guide, we’ve taken a look at how to resolve Merge Conflicts in Git. We’ve explored the three ways you can bump into this common error, and how they arise.

Then, we’ve explored three solutions to the issue, with the dummy two local repositories and a remote repository we’ve created in the examples.

Do you get the error message, «Pulling is not possible because you have unmerged files,» when you try to git pull changes? Worry no more.

This tutorial explains the origin of the error message and how to solve it.

Let’s do this!

Understand the basics

Git pull

Let’s start by understanding what git pull entails.

Think of the code tracking environment as a two-part architecture: local and remote environment. In a local environment, we create the project files in a working directory. Next, we stage the changes. We can fall back to untracked files or safely store the files in a repository.

In simple terms, a repository is the version control system’s database. Here, Git refers to the new changes as commits and assigns them unique numbers called commit hashes.

Although the changes are safely stored and can be retrieved, they are local. That means a loss of the computer results in a loss of our files. So, we send the changes to a remote repository through git push.

ALSO READ: git show explained in-depth [Practical Examples]

We can then collaborate with more remote developers, working on the same or separate git branches.  A developer does their part and pushes the changes to the specified branch. To get the other developer’s changes, you do the opposite of git push: git pull.

git pull is the process of updating a local repository with its updated remote version.

Some articles related to this topic:
git pull force Explained
git pull command examples
git pull vs git pull —rebase explained with examples

Git merge

A typical repository has multiple branches: the main branch and its subbranches.

After creating commits in the subbranch, we unite them with the main branch. This process is called git merge. Git merge enables collaboration in a project. Git is intelligent enough to notice the merge timestamps per branch.

Some articles related to this topic:
git merge explained
Git merge vs rebase and the problems they solve

However, here is a catch.

Merge Conflicts

Sometimes Git gets confused when it cannot determine the logical hierarchy of code portions resulting from commits of separate branches. Such a scenario is called a merge conflict.

A merge conflict needs to be resolved. Otherwise, your subsequent pull requests will fail. You can correct the pull error by resolving the merge conflict through a hard reset or manually accepting the new commit’s changes in the script file.

Now that you know the origin and the solution to the typical error, «Pulling is not possible because you have unmerged files,» let’s set up a lab environment and do it practically.

ALSO READ: Git create repository

Lab environment setup

Log into your GitHub account and create a new repo with a README.md file. I am creating one called lab.

Copy the repo URL.

Return to your local machine’s terminal, clone the repo, and cd into it.

Now let’s generate the error: Pulling is not possible because you have unmerged files.

Generate the error: Pulling is not possible because you have unmerged files

Make a commit in the main branch

Let’s create index.html with a title and a description paragraph.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Pulling is not possible because you have unmerged files</title>
</head>
<body>
    <h2>Let's create the error</h2>
    <p>You are about encounter the error: pulling is not possible because you have unmerged files</p>
</body>
</html>

Stage and commit the changes.

git add index.html
git commit -m "Add index.html"

Now we have two commits in the main branch.

git log --oneline

Make a commit in the feature branch

Create a feature branch.

git switch -c feature_branch

And modify the index.html file by adding a paragraph: First, create the feature branch. We use Visual Studio Code to ease the development and manual error correction. Stage the changes and make a commit.

Now the feature branch is ahead of the main branch with a commit.

ALSO READ: git detached HEAD Explained [Easy Examples]

Switch to the main branch, and modify the index.html with a paragraph: Generating the error.

Next, stage the changes and create a commit.

What happens when we attempt to merge the feature branch?

Let’s find out.

Create a merge conflict

Now let’s attempt merging the feature branch’s changes.

Input

git merge feature_branch

Output

user@hostname:~/lab$ git merge feature_branch 
Auto-merging index.html
CONFLICT (content): Merge conflict in index.html
Automatic merge failed; fix conflicts and then commit the result.

Git tells us it found a conflict in the index.html file and recommends that we correct the error before proceeding.

Okay, let’s inspect the file.

Input

cat index.html

Output

user@hostname:~/lab$ cat index.html 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Pulling is not possible because you have unmerged files</title>
</head>
<body>
    <h2>Let's create the error</h2>
    <p>You are about encounter the error: pulling is not possible because you have unmerged files</p>
<<<<<<< HEAD
    <p>Generating the error</p>
=======
    <p>First, create the feature branch</p>
>>>>>>> feature_branch
</body>

Git is stranded on whether the paragraph from the latest commit (HEAD) from the main branch should come first or the feature branch’s paragraph.

<<<<<<< HEAD
    <p>Generating the error</p>
=======
    <p>First, create the feature branch</p>
>>>>>>> feature_branch

We could edit the file to capture our intention before merging the feature branch. However, let’s ignore the call to resolve the conflict. Nor merge the feature branch.

ALSO READ: First Time Git Setup | Git Config Global

Instead, let’s return to the GitHub repository and update the README.md file

Getting error

Now attempt to pull the remote changes.

Input

git pull

Output

user@hostname:~/lab$ git pull
error: Pulling is not possible because you have unmerged files.
hint: Fix them up in the work tree, and then use 'git add/rm <file>'
hint: as appropriate to mark resolution and make a commit.
fatal: Exiting because of an unresolved conflict.

Git says we have an error: Pulling is not possible because you have unmerged files.

Resolving the error: Pulling is not possible because you have unmerged files

Although we could reset one of the commits, we will retain the changes by accepting both paragraphs in the index.html.

from

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Pulling is not possible because you have unmerged files</title>
</head>
<body>
    <h2>Let's create the error</h2>
    <p>You are about encounter the error: pulling is not possible because you have unmerged files</p>
<<<<<<< HEAD
    <p>Generating the error</p>
=======
    <p>First, create the feature branch</p>
>>>>>>> feature_branch
</body>
</html>

to

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Pulling is not possible because you have unmerged files</title>
</head>
<body>
    <h2>Let's create the error</h2>
    <p>You are about encounter the error: pulling is not possible because you have unmerged files</p>
    <p>Generating the error</p>
    <p>First, create the feature branch</p>
</body>
</html>

Then, stage and commit the changes.

ALSO READ: Git merge vs rebase and the problems they solve

Input

git add .
git commit -m "Accept both paragraphs"

Output

user@hostname:~/lab$ git add .
user@hostname:~/lab$ git commit -m "Accept both paragraphs"
[main 308f222] Accept both paragraphs

Now git pulling does not produce the primary error.

Input

git pull

Output

user@hostname:~/lab$ git pull
remote: Enumerating objects: 5, done.
remote: Counting objects: 100% (5/5), done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
Unpacking objects: 100% (3/3), 779 bytes | 194.00 KiB/s, done.
From github.com:Stevealila/lab
   634d087..4685287  main       -> origin/main
hint: You have divergent branches and need to specify how to reconcile them.
hint: You can do so by running one of the following commands sometime before
hint: your next pull:
hint: 
hint:   git config pull.rebase false  # merge
hint:   git config pull.rebase true   # rebase
hint:   git config pull.ff only       # fast-forward only
hint: 
hint: You can replace "git config" with "git config --global" to set a default
hint: preference for all repositories. You can also pass --rebase, --no-rebase,
hint: or --ff-only on the command line to override the configured default per
hint: invocation.
fatal: Need to specify how to reconcile divergent branches.

Although the pull process goes through, we get some warnings. The relieving part is that Git gives us some hints on how to get rid of the warnings.

Summary

The error, «Pulling is not possible because you have unmerged files,» often results from attempting to git pull changes without resolving local merge conflicts. As shown in this tutorial, you can correct the conflicts before proceeding with git pull.

ALSO READ: git fetch vs git pull Explained [With Examples]

Are you finding yourself in a middle of a git merge conflict in VSCode?

A merge conflict typically occurs when there are changes to the same file locally and remotely. In other words, merge conflicts means you’re having changes in the repository (which you didn’t pulled) in the exact file you’re editing.

Git can merge the changes automatically only if the commits are on different lines or branches. If there’s competing line change or competing file change (e.g. a person deletes a file in one branch and another person edits the same file), you would have to deal with them yourself.

In this article, we will show you how to handle merge conflicts quickly and easily in VSCode without touching the command line.

Git merge conflict error

How do you tell you’re encountering a merge conflict? Simple, by looking at the error message. Users should see the following error messages every time they try to push a commit into the repository:

To [email protected]:myrepo.git
 ! [rejected]        development -> development (non-fast-forward)
error: failed to push some refs to '[email protected]:myrepo.git'
To prevent you from losing history, non-fast-forward updates were rejected
Merge the remote changes (e.g. 'git pull') before pushing again.  See the
'Note about fast-forwards' section of 'git push --help' for details.
Code language: JavaScript (javascript)

Alternatively, if you’re trying to merge two branches and faces the following error message, it also indicates that you’re having merge conflicts.

$ git merge branch1
Auto-merging index.html
CONFLICT (content): Merge conflict in index.html
Automatic merge failed; fix conflicts and then commit the result.
JohnDoe (Master *+|MERGING) new-git-project1
Code language: JavaScript (javascript)

$ git merge branch1
error: Merging is not possible because you have unmerged files.
hint: Fix them up in the work tree, and then use 'git add/rm <file>'
hint: as appropriate to mark resolution and make a commit.
fatal: Exiting because of an unresolved conflict.
Code language: JavaScript (javascript)

Merge line changes/resolve conflicts in VSCode

Suppose you’ve performed a git push in VSCode and end up with the merge conflicts, following the steps below to properly handle them.

Review merge conflicts side-by-side

A beginner may have 3 or 5 line conflicts, but developers need a more comprehensive way to compare differences before deciding which changes to keep. Current inline diffs are not practical for conflicts with over 20 lines even we have 2K and 4K monitors.

IDEs like Visual Studio have already incorporated comprehensive merge editor which even supports a three-way merge. Unfortunately, VSCode haven’t been able to catch up to the others. However, there is a workaround to achieve a “side-by-side” experience from VSCode.

By default, you see all conflicts “top down”, but for each one, clicking on Compare Changes would open a tab with a side-by-side diff.

Accept all merge conflicts

If you have a huge list of merge conflicts (think 50+), manually going through each and every of them would be an unproductive task.

Fortunatelly, VSCode have a way to batch accept incoming or current changes. We find it far easier than manually accept incoming/current changes in Git using command line interface.

All you need to do is opening Command Palette and search for “merge”, you can see the Accept all current changes along with all other possible options. Choose the one which suits your specific scenario.

We hope that the short article gave you useful information on how to handle merge conflicts in VSCode and further improve your programming workflow. You may want to check out our other guides on Automate your workflow with VSCode Tasks , Format JSON in VSCode or Fix IntelliSense in VSCode. All our VSCode tutorials can be found at VSCode Tutorials. If you have any question, don’t hesitate to let us know in the comments section below.