The error message “Your local changes to the following files will be overwritten by merge” occurs in Git version control mechanism. This error occurs if you have modified a file which also has modifications in the remote repository.
This error message is avoided IF there are no uncommitted files that also have modifications in the remote repository. When experiencing this message, it is best to consult your other team members and ask for their opinion. Whether you want to merge your local changes or keep the version present in the repository, it is best to keep everyone on board.
What are repositories? What are push and pull in Git?
A repository is a kind of storage for code which is constantly modified and obtained by team members through the GitHub version control mechanism. A ‘Pull’ means that you are pulling the latest version of the repository onto your local storage/IDE (Integrated Development Environment) such as Pycharm etc.
After a Pull, you make changes to the code or add more features. Once you are done, you ‘Push’ the code onto the repository so changes are saved and additions are made. The code gets accessible to other people as well.
If you are new to Github version control, it is recommended that you go through all the basics first. In this article, we assume that you already have basic knowledge and know all the ins and outs.
The resolution of this error message depends on what you want to do. You can discard your local changes and pull the ones in the repository or you can save your local changes into a stash and pull the version from the repository. It all depends on your preference.
Hence, we recommend that you consult with your team members and make sure that you all are on the same page before moving forward. If you commit wrongly or push the wrong version, it could affect the entire team.
Method 1: Forcing a pull to overwrite local changes
If you don’t care about the changes done locally and want to obtain the code from the repository, you can force a pull. This will overwrite all the local changes done on your computer a duplicate copy of the version in the repository will appear.
Execute the following commands in your IDE:
git reset -- hard git pull
This will instantly destroy all your local changes so make sure that you know what you are doing and don’t need your local changes.
Method 2: Keeping both changes (local and from the repo)
If you want to keep both changes (changes done locally and changes present in the repository), you can add and commit your changes. When you pull, there will obviously be a merge conflict. Here you can use the tools in your IDE (such as Difftool and mergetool) to compare the two pieces of code and determine which changes to keep and which to remove. This is the middle way; no changes will be lost until you manually remove them.
git add $the_file_under_error git commit git pull
When you get a merge conflict, pop those conflict resolving tools and check line by line.
Method 3: Keeping both changes BUT not committing
This situation happens from time to time where developers are not ready to commit because there is some partly broken code which you are debugging. Here we can stash the changes safely, pull the version from the repository, and then unstash your code.
git stash save --keep-index
or
git stash
git pull git stash pop
If there are some conflicts after you pop the stash, you should resolve them in the usual way. You can also use the command:
git stash apply
instead of pop if you are not ready to lose the stashed code due to conflicts.
If merge doesn’t seem like a viable option for you, consider doing a rebase. Rebasing is the process of moving or combining a sequence of commits to a new base commit. In the case of rebasing, change the code to:
git stash git pull --rebase origin master git stash pop
Method 4: Make changes to ‘specific’ parts of your code
If you want to make changes to specific parts of the code and don’t want to replace everything, you can commit everything that you don’t want to overwrite and then follow method 3. You can use the following command for the changes which you want to overwrite from the version present in the repository:
git checkout path/to/file/to/revert
or
git checkout HEAD^ path/to/file/to/revert
Also, you need to make sure that the file is not staged via:
git reset HEAD path/to/file/to/revert
Then proceed with the pull command:
git pull
This will then attempt at fetching the version from the repository.
Kevin Arrows
Kevin is a dynamic and self-motivated information technology professional, with a Thorough knowledge of all facets pertaining to network infrastructure design, implementation and administration. Superior record of delivering simultaneous large-scale mission critical projects on time and under budget.
-
MiniTool
-
MiniTool News Center
- Fix Git Error — Your Local Changes Would Be Overwritten by Merge
By Daisy | Follow |
Last Updated August 31, 2022
If you have modified files that also have modifications in the remote repository, you may receive the “your local changes to the following files would be overwritten by merge” error message. This post from MiniTool offers fixes.
What Is a Repository? What Is Push and Pull in Git?
What is a repository? A repository is a store of code that team members are constantly modifying and fetching through the GitHub version control mechanism.
«Pull» means that you pull the latest version of the repository to your local storage/IDE (Integrated Development Environment) such as Pycharm etc. After pulling, you can change the code or add more functionality. When you’re done, you «push» your code to the repository so your changes can be saved and added. Others can also access the code.
How to Fix “Your Local Changes to the Following Files Would Be Overwritten by Merge”
Fix 1: Force a Pull to Overwrite Local Changes
The first method for you is to force a pull to overwrite local changes. This will overwrite any local changes done on your computer and a copy of the version in the repository will appear. You need to run the following commands in IDE.
- git reset — hard
- git pull
Then, you can check if the “error: your local changes to the following files would be overwritten by merge:” message has gone.
Fix 2: Keep Both Changes
If you want to keep both of these changes (the one done locally and the one in the repository), you can add and commit your changes. You need to execute the following codes in IDE:
- git add $the_file_under_error
- git commit
- git pull
Fix 3: Keep Both Changes but Not Commit
It happens from time to time that the developer is not ready to commit because you are debugging some partially broken code. Here we can safely stash the changes, pull the version from the repository, and unstore your code.
- git stash save —keep-index
or
- git stash
- git pull
- git stash pop
If there are some conflicts after popping into the store, you should resolve them in the usual way. You can also use the following codes:
- git stash apply
If merging is not a viable option for you, consider rebasing In the case of rebasing, change the code to
- git stash
- git pull —rebase origin master
- git stash pop
Fix 4: Make Changes to Parts of Your Code
If you want to make changes to a specific part of the code and don’t want to replace everything, you can commit everything you don’t want to override and follow fix 3. You can use the following codes to make changes you want to override from the version that exists in the repository:
- git checkout path/to/file/to/revert
or
- git checkout HEAD^ path/to/file/to/revert
Also, you need to make sure that the file is not staged via:
- git reset HEAD path/to/file/to/revert
- git pull
Also see: Fix Git Error: You Need to Resolve Your Current Index First Now!
Final Words
These are common solutions to fix “your local changes would be overwritten by merge” in Git. If you have any other useful methods to remove this error, leave a comment below to let us know.
About The Author
Position: Columnist
She was graduated from the major in English. She has been the MiniTool editor since she was graduated from university. She specializes in writing articles about backing up data & systems, cloning disks, and syncing files, etc. She is also good at writing articles about computer knowledge and computer issues. In daily life, she likes running and going to the amusement park with friends to play some exciting items.
When working on a project with a team, you might stumble upon error messages like these when trying to perform a «git pull» in your repository:
error: Your local changes to the following files would be overwritten by merge: ...
-or-
error: Untracked working tree file 'images/icon.png' would be overwritten by mergeThe reason for error messages like these is rather simple: you have local changes that would be overwritten by the incoming new changes that a «git pull» would bring in.
For obvious safety reasons, Git will never simply overwrite your changes. This also means that there is no «force pull» feature in Git — but we can of course perform a couple of steps to emulate such a command.
Step 1: Cleaning Up the Working Copy
First, you’ll need to make sure your working copy doesn’t contain these conflicting changes anymore. There are two ways to achieve this:
a) Saving Local Changes on a Stash
If you want to preserve your local changes, you can safely store them on a Stash. They will be available in case you want them back at a later point.
$ git stash --include-untrackedb) Discarding Local Changes
If you are sure that you don’t need them anymore, you can discard your local changes completely:
$ git reset --hardIf you also have untracked / new files, you will have to use the «git clean» command to get rid of these, too:
$ git clean -fdPlease be careful with these commands: discarding local changes and untracked files cannot be undone!
Step 2: Pull Again
After you have cleaned up any local changes / untracked files that would have been overwritten, the pull will finally work:
$ git pullAuto-Stashing in Tower
If you’re using the Tower Git client, you’ll notice that it helps you avoid these situations: whenever you have uncommitted local changes present and want to perform an action like Pull, Checkout or Merge, Tower will automatically offer to store these changes safely on a Stash.
This way, you neither have to take any extra steps nor do you have to think about this anymore.
Learn More
- Check out the chapter Integrating Remote Changes in our free online book
- More frequently asked questions about Git & version control