How do I force "git pull" to overwrite local files?

Created 14.07.2009 14:58
Viewed 5.7M times
7960 votes

How do I force an overwrite of local files on a git pull?

The scenario is the following:

  • A team member is modifying the templates for a website we are working on
  • They are adding some images to the images directory (but forgets to add them under source control)
  • They are sending the images by mail, later, to me
  • I'm adding the images under the source control and pushing them to GitHub together with other changes
  • They cannot pull updates from GitHub because Git doesn't want to overwrite their files.

This is the error I'm getting:

error: Untracked working tree file 'public/images/icon.gif' would be overwritten by merge

How do I force Git to overwrite them? The person is a designer - usually, I resolve all the conflicts by hand, so the server has the most recent version that they just need to update on their computer.

anyone reading this who thinks they might lose files, I've been in this position and found Sublime Text's buffer has saved me - if I'm working on something, then accidentally delete everything by trying to solve a similar problem to this or by using an answer on this question and have had the files open in Sublime (which there's a good chance of) then the files will still be there is Sublime, either just there, or in the undo history by Toni Leigh, 20.01.2016 08:51
git reset --hard origin/branch_to_overwrite by Andrew Atkinson, 22.03.2016 08:37
basically, only do a pull from develop after the initial checkout -b. do your work, then push back in. by ldgorman, 22.08.2018 09:09
Short answer: delete and re-create branch. 1. Delete branch: git branch <branch> -D 2. Reset to a commit before the conflict: git reset <commit> --hard 3. Re-create the branch: git branch <branch> 4. Set tracking to the server: git --set-upstream-to=origin/<branch> <branch> 5. Pull:git pull` by Nino Filiu, 24.09.2018 08:54
To change all CRLF to LF endings, (start clean) git config core.autocrlf false; git ls-files -z | xargs -0 rm; git checkout . by Chloe, 17.01.2019 02:46
You may be looking for this question instead: instead "Reset local repository branch to be just like remote repository HEAD" For example if the remote has been force pushed and you want pull it and discard the previous incarnation of the branch that you have. (Some other questions point to this question as their duplicate, but I think they should point to this other question.) by Peter Lamberg, 31.03.2020 08:05
Manually delete all files and folders from the local repository. Then run git checkout <branch> && git add -A . && git reset --hard origin/<branch> && git pull. See by Henke, 08.01.2021 17:54
There is definitely an answer to this because I did it by accident. Now many weeks of work is gone :( by Ben Alan, 10.01.2021 00:17
Show remaining 3 comments
Answers 50

⚠ Important: If you have any local changes, they will be lost. With or without --hard option, any local commits that haven't been pushed will be lost.[*]

If you have any files that are not tracked by Git (e.g. uploaded user content), these files will not be affected.

First, run a fetch to update all origin/<branch> refs to latest:

git fetch --all

Backup your current branch:

git branch backup-master

Then, you have two options:

git reset --hard origin/master

OR If you are on some other branch:

git reset --hard origin/<branch_name>


git fetch downloads the latest from remote without trying to merge or rebase anything.

Then the git reset resets the master branch to what you just fetched. The --hard option changes all the files in your working tree to match the files in origin/master

Maintain current local commits

[*]: It's worth noting that it is possible to maintain current local commits by creating a branch from master before resetting:

git checkout master
git branch new-branch-to-save-current-commits
git fetch --all
git reset --hard origin/master

After this, all of the old commits will be kept in new-branch-to-save-current-commits.

Uncommitted changes

Uncommitted changes, however (even staged), will be lost. Make sure to stash and commit anything you need. For that you can run the following:

git stash

And then to reapply these uncommitted changes:

git stash pop
17.01.2012 00:02
Watch out! If you have local unpushed commits this will remove them from your branch! This solution keeps untracked files not in the repository intact, but overwrites everything else. by Matthijs P, 17.05.2012 08:18
It's a popular question, so I'd like to clarify on the top comment here. I just executed commands as described in this answer and it hasn't removed ALL the local files. Only the remotely tracked files were overwritten, and every local file that has been here was left untouched. by Red, 22.11.2012 10:38
I lost all local commits that weren't in the origin/master tree after a rebase. It's very possible to shoot yourself in the foot, here. by Cuadue, 22.11.2013 22:22
You can also do this for a tracking branch if you have the same branch in origin and locally, just change git reset --hard origin/master to git reset --hard origin/(branch) by Joshua Kolden, 14.12.2013 05:59
in case you're pulling from a repo that has its remote branch name different from "master", use git reset --hard origin/branch-name by Abbas Gadhia, 17.12.2013 11:17
This should be the accepted answer. Works fine for me. I guess the assumption here though is that you do not have local commits, which in my case is good as the "local" only possesses a deployment key. by Ardee Aram, 07.04.2014 04:02
Won't this also throw away my local commits? I want to keep my commits, and only overwrite untracked/uncommitted changes. by mcv, 02.05.2014 15:15
I just use "git fetch" to get the upstream branch and then reset when I need to fix a bunch of files. You can get the upstream branch with "git branch -vv" by Natus Drew, 17.08.2014 23:32
@mcv To keep your local commits you want git reset --hard HEAD which you could then follow by git merge origin/master. by joeytwiddle, 19.08.2014 03:47
Given the amount of upvotes to this question and answer, I think that git should incorporate a command like git pull -f by Sophivorus, 26.08.2014 01:33
Commits that weren't pushes before the hard reset can be recovered using git reflog, which list all commits, also those without a base. Until you cleanup your local copy using git gc, then all is lost by Koen., 10.02.2015 22:24
Will this delete files that I have .gitignore'd? by user3817250, 01.04.2015 14:27
@FelipeSchenone There actually is git pull -f, but it doesn't do what we all want it to do. by sudo, 01.05.2015 07:49
To be correct, the uncommited changes are lost but old commits are dangling, waiting for garbage collection. You can still see them in git reflog and move your HEAD back with git reset --hard HEAD@{1}. by Florian Fida, 29.05.2015 03:01
Want to point out here that it will also remove any changes made in any other branch which is not tracked remotely. I lost mine, hope others be careful. by Devesh Khandelwal, 27.06.2015 16:35
Backup the Folder with your local files including the .git folder in it. Now you can't 'loose' anything if this fix doesn't work for you; you can make another copy and try something else. Do not operate out of a single folder and trust git as if it were a 100% reliable backup tool. One typo, especially in branch-land, can be a nightmare. I suggest one backup old-school to tar.gz folders, and then run git out of the latest copy. by JosephK, 13.08.2015 18:44
@Red Yep, if you want to remove everything untracked, even ignored, use git clean -dxf after resetting hard. by IceGlow, 31.12.2015 08:52
I did this and my local changes were NOT discarded - which is unfortunate because I was hoping they would be! Does anyone know how to do this, but also force git to discard any locale changes that don't exist in the remote branch? I essentially want an EXACT, 1-to-1 correspondence with the remote branch. by Gershy, 04.01.2016 15:53
Little known fact - you can actually back up your whole git repo with good old fashioned tar -czf myrepodir.tar.gz myrepodir/.. If your repo gets all messed up due to git weirdness, delete it and restore from the tar.gz file to ACTUALLY get back to where you were before you tried this ill-fated experiment. Just make sure you have the . after myrepodir/ or your .git and other hidden files won't be saved! by Buttle Butkus, 06.02.2016 08:19
can this technique work for individual files? for example -- index.php helpers.js ect. in place of --all ? by Steve C, 09.09.2016 15:47
didnt work for me. tried this solution, tried git clean -dfx. tried git pull -f. still have the same error message. by InsOp, 04.10.2016 09:47
Note that you can abbreviate the branch name by @{u}, which is much shorter. by Antimony, 06.06.2017 17:56
@GershomMaes git clean -dfx after hard reset, as mentioned above by IceGlow? by Franklin Yu, 23.03.2018 19:40
isn't it easier just to rm -rf /folder and do git clone again, if you want to discard all your local changes? by JonB, 04.10.2018 14:24
When using git clean -dffx, be sure to run it from the git project's top-level directory. It's a good idea to run git clean -ndffx first to list the files before they are deleted, since the -x deletes files that are .gitignored and not shown by git status by Josiah Yoder, 22.04.2019 15:26
@JonB: "isn't it easier just to rm -rf /folder and do git clone again...?" A (not even overly) big repo + low bandwidth brought me here. I'd love to just clone again, but it was painful enough the first time, so I'm one of those looking for a quicker solution. by Sz., 11.07.2019 17:46
worked for me when source branch contained updates like file renames from "general" to "General". On Windows it doesn't matter what the case is, so this approach unblocked me. by Someone Somewhere, 08.08.2019 19:20
Mecurial has hg update yet there is no equivalent in git... by Jack, 11.03.2020 15:42
It would be more consistent if you could do git pull --force and it would just overwrite your local branch. Seeing as you can do the opposite, overwriting the remote by git push --force by Jonny, 12.03.2020 03:34
Lost all my local commits with your suggested commands. by Sylvain Rodrigue, 16.08.2020 21:37
Note that the master branch is now called main branch by default so pay attention copy-pasters, as these command may not work any more. by Matt, 27.10.2020 13:21
sorry. Too complicated. Just remove and clone again instead... by Niclas, 05.12.2020 13:46
If you run git checkout -b backup-master, you should go back to your branch (master in the example) before running the git reset. Otherwise, you can use git branch backup-master instead to create the backup branch but stay in master. by Karim Sonbol, 11.12.2020 12:19
After doing this I've got a "fatal: Couldn't find remote ref master" when I do git pull origin master by G M, 14.04.2021 06:22
Show remaining 29 comments

Try this:

git reset --hard HEAD
git pull

It should do what you want.

09.05.2010 19:45
I've done this and some local files that were no longer in repo were left on the disk. by Piotr Owsiak, 08.04.2011 16:00
I do not think that this is correct. the above will perform a merge, not overwrite which was requested in the question: "How to force git to overwrite them?" I do not have the answer, I am currently looking for it.. at the moment I switch to the branch with with the code that I want to keep "git checkout BranchWithCodeToKeep", then do "git branch -D BranchToOverwrite" and then finally "git checkout -b BranchToOverwrite". you will now have the exact code from BranchWithCodeToKeep on the branch BranchToOverwrite without having to perform a merge. by felbus, 13.07.2011 10:11
instead of merging using 'git pull', try git fetch --all followed by 'git reset --hard origin/master' by Lloyd Moore, 21.02.2012 14:56
Lloyd Moore's suggestion is correct, but beware that it can remove local unpushed commits from your branch. by Matthijs P, 17.05.2012 08:23
yep, the @lloydmoore solution worked for me. Could do with being an answer rather than just a comment. by Max Williams, 19.11.2012 09:54
This will reset the current changes back to the last branch commit pulled. Then git pull merges the changes from the latest branch. This did exactly what I wanted it to do.. Thanks! by Codeversed, 05.12.2014 17:42
Will this mess the remote? by user1767754, 30.09.2015 18:33
Good answer, but please add more detail, I mean some people may don't know anything about the reset and lose their files... by Mohammad Kermani, 17.01.2017 12:54
@Travis R could you please explain the purpose of git rest --hard HEAD ? by Imanez, 06.03.2017 15:03
git reset --hard HEAD doesn't really reset all in some cases by Finesse, 06.03.2018 02:19
This is mostly what I think of when I think of forcing the pull. Mostly after I tried some settings by Mianala Loharano, 04.07.2018 09:17
can you explain what your code is doing please? (its only 2 lines) by Charlie Parker, 31.03.2021 19:56
Show remaining 7 comments

WARNING: git clean deletes all your untracked files/directories and can't be undone.

Sometimes just clean -f does not help. In case you have untracked DIRECTORIES, -d option also needed:

# WARNING: this can't be undone!

git reset --hard HEAD
git clean -f -d
git pull

WARNING: git clean deletes all your untracked files/directories and can't be undone.

Consider using -n (--dry-run) flag first. This will show you what will be deleted without actually deleting anything:

git clean -n -f -d

Example output:

Would remove untracked-file-1.txt
Would remove untracked-file-2.txt
Would remove untracked/folder
19.03.2011 09:10
You can give git clean a path argument to be more specific and avoid deleting untracked files that aren't conflicting. by joachim, 18.10.2011 10:08
I think the scenario description makes it clear that he doesn't really want to throw away the content. Rather what he wants is to stop git baulking at overwriting the files. @Lauri, this should not have happened to you. Unfortunately people seem to have misread the essence of scenario description - see my suggestion. by Hedgehog, 11.02.2012 23:05
FINALLY. git clean -f -d is handy when make clean fails to clean everything. by earthmeLon, 23.06.2012 04:32
If you want to sync the whole directory with the remote repo, this is the way to go. by Johannes Ewald, 11.02.2013 12:04
@crizCraig unless they are added in .gitignore by Bleeding Fingers, 13.06.2013 06:58
@BleedingFingers Then add -x. But existing files that are covered by .gitignore shouldn't be a problem: assuming the other contributors to that repo use the same .gitignore file, a pull won't receive any commits that add conflicting files. by User, 07.06.2015 00:18
@earthmeLon, for that you might want git clean -dfx. The -x ignores .gitignore. Typically your build products will be in .gitignore. by Paul Draper, 12.08.2015 18:28
It can be good to run git clean -nfd first, which only shows, what would be removed before it's actually done, that is before you run into troubles. :-) by Velda, 16.08.2018 14:26
Show remaining 3 comments

Like Hedgehog I think the answers are terrible. But though Hedgehog's answer might be better, I don't think it is as elegant as it could be. The way I found to do this is by using fetch and merge with a defined strategy. Which should make it so that your local changes are preserved as long as they are not one of the files that you are trying to force an overwrite with.

First do a commit of your changes

 git add *
 git commit -a -m "local file server commit message"

Then fetch the changes and overwrite if there is a conflict

 git fetch origin master
 git merge -s recursive -X theirs origin/master

-X is an option name, and theirs is the value for that option. You're choosing to use their changes (the other option is ours changes) if there is a conflict.

11.04.2012 20:13
This is the best answer I've seen so far. I haven't tried it, but unlike other answers, this doesn't attempt to nuke all your untracked files, which is very dangerous for obvious reasons. by huyz, 07.05.2012 09:36
Ditto - this worked for me when doing a very large merge (GitHub pull request) where I just wanted to accept it all on top of what I had. Good answer! In my case the last two commands were: 1) get fetch other-repo; 2) git merge -s recursive -X theirs other-repo/master by quux00, 27.07.2012 01:44
This will overwrite any conflicts with the repositories files and not your local ones, correct? by Nathan F., 05.12.2014 11:40
Best answer. The highest accepted answer left me in my case on detached head. I switched back to local master branch and ran git merge -X theirs origin/master by petergus, 11.03.2016 12:46
Tried this - then add/commit my new changed files, but still said my branch was behind remote when I tried to push. Massive wasted time because "git pull" doesn't ask "Overwrite local? y/n/all". by JosephK, 26.07.2016 03:57
Hang on...doesn't have git add * and git commit -a <more-options-here> have the same effect? Why would you need both? by Marcel Stör, 25.04.2017 20:41
@MarcelStör you don't need both but they also don't do the same thing. git commit -a only has that affect on files that are already tracked; git add * will add files that are not tracked. So if you do git commit -a it won't catch new files, then you might need to do a git add afterward, but it you do git add * you won't need -a on the commit. by briantist, 04.04.2018 20:47
The problem with this (excellent) answer, is it adds the all the local files, which sometimes may not be what you want. You may just want to add the specific files that were omitted. But the best thing about it is, it gets him to do what he should have done -- add them locally. You probably won't need the -X theirs strategy, since they're the same image. In fact, I'd suggest leaving it off at first, just to find out if there are any anomalies, and add it in if there are, after reviewing that 'theirs' is always the correct choice. But then, I'm paranoid. by Bob Kerns, 28.06.2018 20:27
i just wanted freaking git to overwrite everything and shut up about it. after all im just using it between my work pc and some raspberry pi systems. Whishing for a force overwrite option, at least for project leader by clockw0rk, 05.06.2019 14:39
after trying this command I still get the same error " untracked working tree files would be overwritten by merge " and a long yet incomplete list of the files I can't simply force it to overwrite. by Patrick Parker, 02.10.2020 15:48
hmmm... maybe try git add . first by Richard Kersey, 05.10.2020 13:17
Show remaining 6 comments

Instead of doing:

git fetch --all
git reset --hard origin/master

I'd advise doing the following:

git fetch origin master
git reset --hard origin/master

No need to fetch all remotes and branches if you're going to reset to the origin/master branch right?

26.04.2013 13:48
Your answer is just what you needed for your rep. I must ask, does this also remove all untracked files? by Nicolas De Jay, 07.01.2014 06:38
Yeah, most of my rep is coming from here :) This will also remove all untracked files. Something I had forgotten and was painfully reminded of just 2 days ago... by Johanneke, 09.01.2014 12:01
See the comments on this other answer: by Johanneke, 09.01.2014 12:02
This did not remove my untracked files; which is actually what I'd expect. Is there a reason it might for some people and not for others? by arichards, 19.04.2016 15:27
Untracked files are not affect4ed by git reset. If you want them to be removed as well, do git add . first, before git reset --hard by Johanneke, 15.08.2017 09:12
This is exactly what I needed: something that overwrites untracked files that exist in the remote, and leaves everything else intact. by Ledazinha, 20.12.2017 22:37
Show remaining 1 comments

It looks like the best way is to first do:

git clean

To delete all untracked files and then continue with the usual git pull...

14.07.2009 15:16
I tried using "git clean" to solve the same issue, but it did not resolve it. git status says "Your branch and 'origin/master' have diverged, # and have 2 and 9 different commit(s) each, respectively." and git pull says something similar to what you have above. by slacy, 24.09.2009 04:25
would he not need to change to the master branch and then do git clean for it to work? Then he can flip back to whatever development branch he was working from. by suitedupgeek, 25.01.2010 21:38
@slacy: Then you need to merge the two branches. by Xiong Chiamiov, 05.02.2010 00:07
git clean is a rather blunt instrument, and could throw away a lot of things that you may want to keep. Better to remove or rename the files that git is complaining about until the pull succeeds. by Neil Mayhew, 02.07.2010 13:21
I do not think this works in general. Isn't there a way to do basically a git clone remote via a forced git pull? by mathtick, 29.11.2010 18:30
@mathick: git fetch origin && git reset --hard origin/master by Arrowmaster, 23.02.2011 04:24
I needed to add a -x to that git clean to get it to work for me, for some reason (-d wasn't deleting a .ideas directory for some reason), but this fixed my problem, certainly. by Owen Blacker, 19.12.2011 12:29
avoid sudden cardiac arrest: use git clean -n first by doub1ejack, 30.07.2013 14:19
Is git clean the best answer here? Seems like removing files isn't necessarily what the OP wants. They asked for 'an overwrite of local files' not deletion. by JohnAllen, 04.03.2014 08:28
git clean by itself doesn't seem to help, @Arrowmaster 's solution is closer, but a better one by Lloyd Moore is in the next answer. by Neil Monroe, 10.06.2015 21:12
Don't ever do anything 'git' (or even have a .git folder) except in a copy of your actual work folder, and avoid all cardiac stress. Don't give git and its obtuse syntax/methods the opportunity to wreck you in the first place. by JosephK, 26.07.2016 04:12
Show remaining 6 comments

Warning, doing this will permanently delete your files if you have any directory/* entries in your gitignore file.

Some answers seem to be terrible. Terrible in the sense of what happened to @Lauri by following David Avsajanishvili suggestion.

Rather (git > v1.7.6):

git stash --include-untracked
git pull

Later you can clean the stash history.

Manually, one-by-one:

$ git stash list
stash@{0}: WIP on <branch>: ...
stash@{1}: WIP on <branch>: ...

$ git stash drop stash@{0}
$ git stash drop stash@{1}

Brutally, all-at-once:

$ git stash clear

Of course if you want to go back to what you stashed:

$ git stash list
$ git stash apply stash@{5}
11.02.2012 23:00
Aren't you assuming that a commit has never been performed? In my case I made several commits to my local branch, but wanted to "reset" everything back to the remote branch by Lee Francis, 20.03.2012 10:55
No I don't think so. Stashing just moves uncommitted files out of the way. The above also moves (stashes) files that git does not track. This prevents files that have been added to the remote, which have not yet pulled down to your machine - but which you have created (!) - to be pulled down. All without destroying the uncommitted work. Hope that makes sense? by Hedgehog, 20.03.2012 23:54
If you don't have 1.7.6, you can mimic --include-untracked simply by temporarily git add-ing your entire repo, then immediately stashing it. by nategood, 01.05.2012 22:48
I agree with Hedgehog. If you do the popular answers here, you are more than likely going to find you've inadvertently killed a lot of stuff that you didn't really want to lose. by Guardius, 31.01.2013 21:28
I had other untracked files--besides the one the merge/pull wanted to overwrite, so this solution worked best. git stash apply brought back all my untracked files with the exception (rightly) of the ones that the merge had already created: "already exists, no checkout." Worked perfectly. by BigBlueHat, 25.04.2013 04:55
This can be the easiest way to hose a repo unintentionally, just like what happened to @Lauri, but worse because you think you're protecting files from deletion. If you have one .gitignore rule that has a wildcard in it, kiss them goodbye. Explanation. by Walf, 30.11.2016 07:05
This is the cleanest answer, and should be the accepted one. To save some typing you can use the short form: git stash -u. by ccpizza, 23.03.2017 08:30
The link about git stash --include-untracked destroying folders that are gitignored is dead - let's find a replacement. In the meantime, the @Waif comment about how this answer can destroy gitignore'd folders should be upvoted, and preferably converted into a new answer. The GitLab issue you linked has details. I use git stash a lot and was very surprised to hear it can destroy files. by RichVel, 15.04.2019 20:09
Show remaining 3 comments

You might find this command helpful to throw away local changes:

git checkout <your-branch> -f

And then do a cleanup (removes untracked files from the working tree):

git clean -f

If you want to remove untracked directories in addition to untracked files:

git clean -fd
05.08.2010 18:06
I think the scenario description makes it clear that he doesn't really want to throw away the content. Rather what he wants is to stop git baulking at overwriting the files. See my suggestion. by Hedgehog, 11.02.2012 23:03
Though that answer might not fit exactly the description, it still saved me from the frustration of git twiddling with the carriage returns (event with autocrlf false). When git reset --hard HEAD does not leave you with "no" modified files, these "-f" flags are quite helpful. Thanks a bunch. by Kellindil, 16.01.2013 10:28

Instead of merging with git pull, try this:

git fetch --all

followed by:

git reset --hard origin/master.

22.11.2012 10:56

The only thing that worked for me was:

git reset --hard HEAD~5

This will take you back five commits and then with

git pull

I found that by looking up how to undo a Git merge.

05.05.2011 21:53
This was what ultimately worked for me as I had force pushed my branch to the origin repo and kept getting merge conflicts when trying to pull it to my remote repo.. by jwfrench, 07.05.2014 05:16
Hi, actually this is a trick for a work around but really effective. Because some conflicts may happen just in few commits then reverting 5 commits will make sure no conflicts with remote code. by Hoang Le, 21.11.2014 10:03

First of all, try the standard way:

git reset HEAD --hard # To remove all not committed changes!
git clean -fd         # To remove all untracked (non-git) files and folders!

Warning: Above commands can results in data/files loss only if you don't have them committed! If you're not sure, make the backup first of your whole repository folder.

Then pull it again.

If above won't help and you don't care about your untracked files/directories (make the backup first just in case), try the following simple steps:

cd your_git_repo  # where 'your_git_repo' is your git repository folder
rm -rfv *         # WARNING: only run inside your git repository!
git pull          # pull the sources again

This will REMOVE all git files (excempt .git/ dir, where you have all commits) and pull it again.

Why git reset HEAD --hard could fail in some cases?

  1. Custom rules in .gitattributes file

    Having eol=lf rule in .gitattributes could cause git to modify some file changes by converting CRLF line-endings into LF in some text files.

    If that's the case, you've to commit these CRLF/LF changes (by reviewing them in git status), or try: git config core.autcrlf false to temporary ignore them.

  2. File system incompability

    When you're using file-system which doesn't support permission attributes. In example you have two repositories, one on Linux/Mac (ext3/hfs+) and another one on FAT32/NTFS based file-system.

    As you notice, there are two different kind of file systems, so the one which doesn't support Unix permissions basically can't reset file permissions on system which doesn't support that kind of permissions, so no matter how --hard you try, git always detect some "changes".

26.10.2012 09:17

The problem with all these solutions is that they are all either too complex, or, an even bigger problem, is that they remove all untracked files from the web server, which we don't want since there are always needed configuration files which are on the server and not in the Git repository.

Here is the cleanest solution which we are using:

# Fetch the newest code
git fetch

# Delete all files which are being added, so there
# are no conflicts with untracked files
for file in `git diff HEAD..origin/master --name-status | awk '/^A/ {print $2}'`
    rm -f -- "$file"

# Checkout all files which were locally modified
for file in `git diff --name-status | awk '/^[CDMRTUX]/ {print $2}'`
    git checkout -- "$file"

# Finally pull all the changes
# (you could merge as well e.g. 'merge origin/master')
git pull
  • The first command fetches newest data.

  • The second command checks if there are any files which are being added to the repository and deletes those untracked files from the local repository which would cause conflicts.

  • The third command checks-out all the files which were locally modified.

  • Finally we do a pull to update to the newest version, but this time without any conflicts, since untracked files which are in the repo don't exist anymore and all the locally modified files are already the same as in the repository.

05.11.2012 23:32
Using "git merge origin/master" as the last line (like you say in your note) instead of "git pull" will be faster as you've already pulled down any changes from the git repo. by Josh, 06.05.2013 06:21
Yeah of course, git merge origin/master will be faster and probably even safer. Since if someone pushed new changes during the removal of of files of this script (which is not likely to happen, but possible), the whole pull could fail. The only reason I put pull in there is because someone might not be working on the master branch, but some other branch and I wanted the script to be universal. by Strahinja Kustudic, 01.09.2013 22:25
If you have locally created files like option files, put them in .gitignore. by Sebi, 21.11.2017 11:41

I had the same problem. No one gave me this solution, but it worked for me.

I solved it by:

  1. Delete all the files. Leave just the .git directory.
  2. git reset --hard HEAD
  3. git pull
  4. git push

Now it works.

12.01.2011 23:58
Same here. Sometimes only the very hard solution works, it happens often that only reset and clean are not enough somehow... by jdehaan, 15.12.2011 11:28


In speaking of pull/fetch/merge in the previous answers, I would like to share an interesting and productive trick,

git pull --rebase

This above command is the most useful command in my Git life which saved a lot of time.

Before pushing your newly commit to server, try this command and it will automatically synchronise the latest server changes (with a fetch + merge) and will place your commit at the top in the Git log. There isn't any need to worry about manual pull/merge.

Find details in What does "git pull --rebase" do?.

23.12.2015 15:41
In short: git pull -r. by kenorb, 15.10.2019 09:29
In my case, before doing that, I had to 1) git add -A, 2) git commit -m 3) and finally git pull rebase. Thank you. by Pathros, 03.02.2021 20:10

I had a similar problem. I had to do this:

git reset --hard HEAD
git clean -f
git pull
14.01.2011 15:18
use git clean with caution by nategood, 30.03.2012 16:39

I summarized other answers. You can execute git pull without errors:

git fetch --all
git reset --hard origin/master
git reset --hard HEAD
git clean -f -d
git pull

Warning: This script is very powerful, so you could lose your changes.

07.08.2015 03:03
This will overwrite modified files (files that were previously checked in) and it will remove untracked files (files that have never been checked in). Exactly what I was looking for, thanks! by styfle, 03.03.2016 16:01
I suspect the third line git reset --hard HEAD may be redundant; my local man page (2.6.3) say that reset in the second line git reset --hard origin/master "defaults to HEAD in all forms." by arichards, 19.04.2016 15:40
@arichards I think your suspect is right but if second line will not work(by any reason) third line work well to reset. This solution doesn't need to be optimized. I just summarized other answers. That's all. Thank you for your comment. :) by Robert Moon, 20.04.2016 02:12
Thanks for the summary. These steps are indeed powerful :) by Glorian, 10.12.2020 17:28

Based on my own similar experiences, the solution offered by Strahinja Kustudic above is by far the best. As others have pointed out, simply doing hard reset will remove all the untracked files which could include lots of things that you don't want removed, such as config files. What is safer, is to remove only the files that are about to be added, and for that matter, you'd likely also want to checkout any locally-modified files that are about to be updated.

That in mind, I updated Kustudic's script to do just that. I also fixed a typo (a missing ' in the original).


# Fetch the newest code
git fetch

# Delete all files which are being added,
# so there are no conflicts with untracked files
for file in `git diff HEAD..origin/master --name-status | awk '/^A/ {print $2}'`
    echo "Deleting untracked file $file..."
    rm -vf "$file"

# Checkout all files which have been locally modified
for file in `git diff HEAD..origin/master --name-status | awk '/^M/ {print $2}'`
    echo "Checking out modified file $file..."
    git checkout $file

# Finally merge all the changes (you could use merge here as well)
git pull
27.02.2013 14:43
Using "git merge origin/master" as the last line (like you say in your note) instead of "git pull" will be faster as you've already pulled down any changes from the git repo. by Josh, 06.05.2013 06:20
The checkout of modified files is needed, so this works 100% of times. I updated my script with that a long time ago, but forgot to update here as well. I also use it a little differently than you. I checkout files which have any type of modification, not just M, so it works all the time. by Strahinja Kustudic, 01.09.2013 22:48

I believe there are two possible causes of conflict, which must be solved separately, and as far as I can tell none of the above answers deals with both:

  • Local files that are untracked need to be deleted, either manually (safer) or as suggested in other answers, by git clean -f -d

  • Local commits that are not on the remote branch need to be deleted as well. IMO the easiest way to achieve this is with: git reset --hard origin/master (replace 'master' by whatever branch you are working on, and run a git fetch origin first)

12.12.2011 19:54

I had the same problem and for some reason, even a git clean -f -d would not do it. Here is why: For some reason, if your file is ignored by Git (via a .gitignore entry, I assume), it still bothers about overwriting this with a later pull, but a clean will not remove it, unless you add -x.

03.08.2011 09:23

git fetch --all && git reset --hard origin/master && git pull

12.05.2019 15:47

It seems like most answers here are focused on the master branch; however, there are times when I'm working on the same feature branch in two different places and I want a rebase in one to be reflected in the other without a lot of jumping through hoops.

Based on a combination of RNA's answer and torek's answer to a similar question, I've come up with this which works splendidly:

git fetch
git reset --hard @{u}

Run this from a branch and it'll only reset your local branch to the upstream version.

This can be nicely put into a git alias (git forcepull) as well:

git config alias.forcepull "!git fetch ; git reset --hard @{u}"

Or, in your .gitconfig file:

  forcepull = "!git fetch ; git reset --hard @{u}"


25.02.2014 17:19
This answer is also nice because it works regardless of which branch you are on! by leafmeal, 11.09.2018 20:14

An easier way would be to:

git checkout --theirs /path/to/file.extension
git pull origin master

This will override your local file with the file on git

05.05.2015 08:03

I just solved this myself by:

git checkout -b tmp # "tmp" or pick a better name for your local changes branch
git add -A
git commit -m 'tmp'
git pull
git checkout master # Or whatever branch you were on originally
git pull
git diff tmp

where the last command gives a list of what your local changes were. Keep modifying the "tmp" branch until it is acceptable and then merge back onto master with:

git checkout master && git merge tmp

For next time, you can probably handle this in a cleaner way by looking up "git stash branch" though stash is likely to cause you trouble on the first few tries, so do first experiment on a non-critical project...

03.12.2010 15:00

I have a strange situation that neither git clean or git reset works. I have to remove the conflicting file from git index by using the following script on every untracked file:

git rm [file]

Then I am able to pull just fine.

19.09.2011 14:18

I know of a much easier and less painful method:

$ git branch -m [branch_to_force_pull] tmp
$ git fetch
$ git checkout [branch_to_force_pull]
$ git branch -D tmp

That's it!

05.09.2015 18:23
I tried doing as suggested in this answer. NO FILES AT ALL were pulled down from the remote repository. Actually not very surprising when you think about it - after all there is no reference at all to origin/<branch_to_force_pull>. by Henke, 10.12.2020 11:58
git fetch --all

then if you are on the master branch

git reset --hard origin/master


git reset --hard origin/master<branch_name>
15.08.2019 06:10
The last snippet should be origin/<branch_name> not origin/master<branch_name>. by Adrian, 13.11.2020 10:40

Despite the original question, the top answers can cause problems for people who have a similar problem, but don't want to lose their local files. For example, see Al-Punk and crizCraig's comments.

The following version commits your local changes to a temporary branch (tmp), checks out the original branch (which I'm assuming is master) and merges the updates. You could do this with stash, but I've found it's usually easier to simply use the branch / merge approach.

git checkout -b tmp
git add *; git commit -am "my temporary files"
git checkout master

git fetch origin master
git merge -s recursive -X theirs origin master

where we assume the other repository is origin master.

22.10.2014 17:31

These four commands work for me.

git reset --hard HEAD
git checkout origin/master
git branch -D master
git checkout -b master

To check/pull after executing these commands

git pull origin master

I tried a lot but finally got success with these commands.

20.03.2014 04:24
"git branch -D master" delete the branch. so be careful with it. I prefer to use "git checkout origin/master -b <new branch name>" which create a new branch with a new name and you done need 3,4 lines. Also recommended to use "git clean -f" as well. by Chand Priyankara, 05.04.2014 11:49


  1. Track local changes so no-one here ever loses them.
  2. Make the local repository match the remote origin repository.


  1. Stash the local changes.
  2. Fetch with a clean of files and directories ignoring .gitignore and hard reset to origin.

    git stash --include-untracked
    git fetch --all
    git clean -fdx
    git reset --hard origin/master
01.09.2015 23:00

Just do

git fetch origin branchname
git checkout -f origin/branchname // This will overwrite ONLY new included files
git checkout branchname
git merge origin/branchname

So you avoid all unwanted side effects, like deleting files or directories you wanted to keep, etc.

19.10.2015 09:54
Nice. By first using checkout -f into the branch I wanted to merge from, that got rid of all the problematic untracked files. Then I could checkout again my destination, and finally merge without issues. by Patrick Parker, 02.10.2020 17:06

Reset the index and the head to origin/master, but do not reset the working tree:

git reset origin/master
15.02.2013 13:41
I personally found this to be most useful. It then keeps your working tree so you can check it in again. For my issue, I had the same files deleted as being added so it was stuck. Weird, I know. by King Friday, 04.01.2014 21:03

I read through all the answers but I was looking for a single command to do this. Here is what I did. Added a git alias to .gitconfig

      fp = "!f(){ git fetch ${1} ${2} && git reset --hard ${1}/${2};};f"

Run your command as

git fp origin master

equivalent to

git fetch origin master
git reset --hard origin/master
08.07.2016 13:11

Don't use git reset --hard. That will wipe their changes which may well be completely undesirable. Instead:

git pull
git reset origin/master
git checkout <file1> <file2> ...

You can of course use git fetch instead of git pull since it clearly isn't going to merge, but if you usually pull it makes sense to continue to pull here.

So what happens here is that git pull updates your origin/master reference; git reset updates your local branch reference on to be the same as origin/master without updating any files, so your checked-out state is unchanged; then git checkout reverts files to your local branch index state as needed. In cases where exactly the same file has been added on live and on upstream master, the index already matches the file following the reset, so in the common case you don't need to do git checkout at all.

If the upstream branch also contains commits which you want to apply automatically, you can follow a subtle variation on the process:

git pull
git merge <commit before problem commit>
git reset <problem commit>
git checkout <file1> <file2> ...
git pull
28.11.2017 11:19

This is the best practice for reverting changes:

  • git commit Commit your staged changes so they will be saved in the reflog ( see below )
  • git fetch Fetch the latest upstream changes
  • git reset --hard origin/master Hard reset to the origin master branch

The reflog records branches and other references being updated in the local repository. Or simply put - the reflog is the history of your changes.

So it's always a great practice to commit. Commits are appended to the reflog which ensures you will always have a way to retrieve the deleted code.

12.08.2016 15:56

You could ignore that file with a file in your project base folder:



Then pull the changes and then remove that line from your gitignore file.

09.11.2010 16:57

I was trying to use the Material2 branch on the Angular2-Webpack-Starter and had a heck of a time. This was the only way I could download and use that branch.

git clone --depth 1

cd angular2-webpack-starter/

git checkout -b material2

Open the project folder and delete all non-hidden files and folders. Leave all the hidden ones.

git add .

git commit -m "pokemon go"

git reset --hard

git pull origin material2

(When the editor pops up, hit ':wq', and then press Enter)

Now you are ready.

27.07.2016 16:17

if you want to reset to the remote tracking branch in a generic way use:

git fetch
git reset --keep origin/$(git rev-parse --abbrev-ref HEAD)

if you want to reset your local changes too:

git fetch
git reset --hard origin/$(git rev-parse --abbrev-ref HEAD)
25.05.2018 06:31
If you find yourself using this frequently add a bash shortcut alias gplf='git fetch && echo "HEAD was at $(git rev-parse --short HEAD)" && git reset --hard origin/$(git rev-parse --abbrev-ref HEAD)' by Paul Odeon, 13.11.2019 09:43
Brilliant. Thanks! People do not consider automated scripts when answering. This is very elegant when you just can't pass the branch name along. by Zeno Popovici, 24.09.2020 16:24

I used this command to get rid of the local files preventing me from doing a pull/merge. But be careful! Run git merge … first to see whether there are only those files you really want to remove.

git merge origin/master 2>&1 >/dev/null | grep ^[[:space:]] | sed s/^[[:space:]]//g | xargs -L1 rm
  • git merge lists among other things all those files. They are prepended by some white-space.
  • 2>&1 >/dev/null redirects the error output to the standard one so it is picked up by grep.
  • grep ^[[:space:]] filters only the lines with file names.
  • sed s/^[[:space:]]//g trims the white-space from the beginning.
  • xargs -L1 rm calls rm on each of those files, deleting them.

Handle with care: Whatever git merge outputs, the rm will be called for every line beginning with a white-space.

07.10.2015 09:03

You can try:

$ git fetch --all
$ git reset --hard origin/master 
$ git pull
17.01.2021 08:10

On Windows, do this single command:

git fetch --all & git reset --hard origin/master
10.04.2018 07:22
Why would it be different than on, e.g., Linux? Which particular implementation/package of git do you use? And/or which environment (e.g. MinGW)? by Peter Mortensen, 27.04.2018 12:57
I am not sure, only sure that works in windows. In linux what is the separator to concatenate two commands in a single line? (not the pipe, somply concatenate without passing the outoput) by Luca C., 29.04.2018 08:53

you could try git pull --force or maybe stash your commits by using git stash then running git pull

22.08.2019 16:34
This doesn't work. fatal: refusing to merge unrelated histories by Wyck, 23.08.2019 15:49
Automatic merge failed; fix conflicts and then commit the result. by Mutoh, 10.01.2020 16:32
No: error: The following untracked working tree files would be overwritten by merge: - i don't care about those files. If it where only two or three I would just delete them. But there are so many. by Martin, 20.08.2020 06:40

This worked for me very well!

git fetch --all
git reset --hard origin/master
05.02.2021 12:43

I did this to get it to work:

On computer where I created the new branch:

git push --all

On computer where I wanted the new branch to show:

git fetch --all
30.08.2019 08:53

Despite the fact that this question has already many answers, the original question is to solve this question

error: Untracked working tree file 'public/images/icon.gif' would be overwritten by merge

As binary files can't be merged a simple answer is

git checkout public/images/icon.gif

With that the file will recover the previous state it had in this branch.

I usually do git stash if I don't want to lose my changes or something like git checkout . if I don't care about locally modified files. IMO much more simple than reset --hard, clean... and all this stuff more suited to leave the branch as in remote, including commits, untracked files, rather than just solving a locally modified file.

24.07.2020 11:23

1: Reset to a previous commit

git reset --hard HEAD

2: Delete Untracked Files

git clean -f

3: Pull the commits

git pull


10.11.2018 02:27

Once you do git pull, you will get list of files that are not matching. If the number of files is not very large then you can checkout those files, this action will overwrite those files.

git checkout -- <filename>

I usually do it if for quick check I modify local files on server (no recommended and probabaly reason behind you getting this issue :D ), I checkout the changed files after finding solution.

12.07.2020 14:25

As I often need a fast way to reset current branch on windows through command prompt, here's a fast way:

for /f "tokens=1* delims= " %a in ('git branch^|findstr /b "*"') do @git reset --hard origin/%b
14.04.2020 11:06

I think you can also force by git push -f / git push --force

19.10.2020 07:46
question is about Pulling, not Pushing. by Daemon Painter, 19.10.2020 08:16

I’ve tried most of what I could find here, none worked in my case.

What worked was git merge -X theirs

01.12.2020 18:20

Step 1. (optional)
From the root of your local repository, save a backup and empty the current folder:

mkdir -p ../<branch>-bkp && mv --backup=t * ../<branch>-bkp

Step 2. Download all files and folders of the branch from the remote repository:

git checkout <branch> && git add -A . && git reset --hard origin/<branch> && git pull

where you should replace <branch> with the name of the branch you want to overwrite.


  • You may prefer to manually backup and remove the current files and folders instead of step 1.
    In fact, I recommend doing this with a file-handler in the GUI of your operating system.
  • If you skip step 1, beware: you will lose all work in the local repository!
  • Important: if you leave out git pull in step 2,
    you risk not getting the latest version from the remote repository!
    According to the second reference below, git reset --hard will
    reset the staging area and the working directory to match the most recent commit.
    My experience contradicts this claim!
  • If you run git reset --hard origin/<branch_to_overwrite> without first deleting all files and folders from your local repository, beware that any junk files still laying around may sneak into the remote repository at a later git push even if that was not your intention.
    The extra git add -A . in step 2 prevents this from happening if you choose to leave out step 1.


10.12.2020 17:24