5766

How do I reset my local branch to be just like the branch on the remote repository?

I tried:

git reset --hard HEAD

But git status claims I have modified files:

On branch master
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)
      modified:   java/com/mycompany/TestContacts.java
      modified:   java/com/mycompany/TestParser.java
6
  • 18
    According to the output of git status your second command git reset --hard HEAD failed. You didn’t paste it’s output, though. → Incomplete question. Commented Jan 8, 2016 at 11:06
  • 5
    You are mixing two issues here: 1) how to reset a local branch to the point where the remote is and 2) how to clear your staging area (and possibly the working directory), so that git status says nothing to commit, working directory clean. – Please specify! Commented Jan 8, 2016 at 11:09
  • 3
    Does this answer your question? How do I force "git pull" to overwrite local files? Commented Dec 28, 2020 at 15:51
  • Obviously not an answer if the repo is large, but for small repos you can hit it with a hammer and avoid git entirely: rm -fr ./repo; git clone repo. best way i've found Commented Jun 8, 2021 at 17:08
  • I hit the same; I was trying git reset --hard origin/master when it should have been git reset --hard origin/main. Commented Aug 15, 2022 at 10:31

27 Answers 27

9896

Setting your branch to exactly match the remote branch can be done in two steps:

git fetch origin
git reset --hard origin/master

If you want to save your current branch's state before doing this (just in case), you can do:

git commit -a -m "Saving my work, just in case"
git branch my-saved-work

Now your work is saved on the branch "my-saved-work" in case you decide you want it back (or want to look at it later or diff it against your updated branch).

Note that the first example assumes that the remote repo's name is "origin" and that the branch named "master" in the remote repo matches the currently checked-out branch in your local repo.

BTW, this situation that you're in looks an awful lot like a common case where a push has been done into the currently checked out branch of a non-bare repository. Did you recently push into your local repo? If not, then no worries -- something else must have caused these files to unexpectedly end up modified. Otherwise, you should be aware that it's not recommended to push into a non-bare repository (and not into the currently checked-out branch, in particular).

28
  • 4
    Thank you for your answer. You said 'Note that the first example assumes that the remote repo's name is "origin" and that the branch named "master" in the remote repo matches the branch in your local repo.' How can I double check my remote repo's name and my branch name to be sure before I execute 'git reset --hard'? Thanks again.
    – hap497
    Commented Oct 27, 2009 at 2:57
  • 32
    If you didn't explicitly name the remote, then it's name is likely just "origin" (the default). You can use "git remote" to get a list of all remote names. You can then use "git remote <name>" to see which branches push/pull with each other (e.g. if your "master" branch was cloned from "master" in the remote named "origin", then you'll get a line that says "master merges with remote master"). Commented Oct 27, 2009 at 13:51
  • 9
    "it's not recommended to push into a non-bare repository (and not into the currently checked-out branch, in particular" Why is that? Commented Mar 20, 2013 at 11:00
  • 51
    Just after fetching, I believe you can do git reset FETCH_HEAD --hard instead, as well, that's the same meaning.
    – Jean
    Commented Apr 30, 2013 at 21:21
  • 13
    It did not remove files I have added. Commented Mar 20, 2018 at 9:01
662

First, use git reset to reset to the previously fetched HEAD of the corresponding upstream branch:

git reset --hard @{u}

The advantage of specifying @{u} or its verbose form @{upstream} is that the name of the remote repo and branch don't have to be explicitly specified. On Windows or with PowerShell, specify "@{u}" (with double quotes).

Next, as needed, use git clean to remove untracked files, optionally also with -x:

git clean -df

Finally, as needed, get the latest changes:

git pull
10
  • 106
    This seems like a better answer than the accepted one, because it dynamically resets to the current upstream branch rather than always a static one such as origin/master
    – jrz
    Commented Sep 22, 2015 at 15:10
  • 4
    @GangadharJannu git reset --hard requires a commit, else it wouldn't know what to reset you to. @{u} points to a specific commit – the head of the tracked branch, from when you last did a git fetch. Commented Oct 16, 2019 at 7:06
  • 2
    @KristofferBakkejord Thanks for the explanation but even without commit hash we can do git reset --hard though it will not reset to remote branch Commented Oct 16, 2019 at 8:42
  • 15
    For anyone else who almost opened a new question here, if you git from Powershell, use quotes (git reset --hard "@{u}"). Took me a while to figure that out.
    – MPStoering
    Commented Dec 13, 2019 at 14:26
  • 1
    @MPStoering using the quotes also worked for me in git bash on Windows. Cheers
    – Jason S
    Commented Jul 13, 2020 at 22:03
647

I needed to do (the solution in the accepted answer):

git fetch origin
git reset --hard origin/master

Followed by:

git clean -f

to remove local files

To see what files will be removed (without actually removing them):

git clean -n -f
10
  • 124
    also, git clean -d -f if there are untracked directories present.
    – garg
    Commented Jan 23, 2015 at 18:09
  • 77
    also git clean -fdx Commented Sep 28, 2015 at 6:32
  • 22
    If you want exact copy of remote branch you have to follow by git clean -ffdx. Note that thare are two f. Commented Feb 22, 2016 at 14:51
  • 11
    The git clean -f was the essential piece I needed. Thanks!
    – dgo
    Commented Apr 26, 2016 at 22:51
  • 21
    be careful using the clean command. it can delete ignored files from other branches. Commented Jan 9, 2017 at 8:23
216

git reset --hard HEAD actually only resets to the last committed state. In this case HEAD refers to the HEAD of your branch.

If you have several commits, this won't work..

What you probably want to do, is reset to the head of origin or whatever you remote repository is called. I'd probably just do something like

git reset --hard origin/HEAD

Be careful though. Hard resets cannot easily be undone. It is better to do as Dan suggests, and branch off a copy of your changes before resetting.

2
  • 3
    There was an incorrect suggestion in my answer that Dan caught earlier. I edited it away, since I don't want to lead anyone astray. As to the origin/master or origin/HEAD stuff, I expect that depends on whether or not you actually do a fetch first. If you just cloned origin, and it had no other branches, which I find to be quite common, then it should reset it fine. But of course, Dan is right. Commented Oct 27, 2009 at 9:58
  • This doesn't work as origin/HEAD is not necessarily the latest commit of your current branch in origin. Use instead : git reset --hard @{u}
    – Xys
    Commented Aug 29, 2023 at 13:48
104

All of the above suggests are right, but often to really reset your project, you also need to remove even files that are in your .gitignore.

To get the moral equivalent of erasing your project directory and re-cloning from the remote is:

git fetch
git reset --hard
git clean -x -d -f

Warning: git clean -x -d -f is irreversible and you may lose files and data (e.g. things you have ignored using .gitignore).

3
  • 18
    Warning: "git clean -x -d -f" is irreversible and you may loose files and data in .gitignore Commented Feb 16, 2016 at 6:20
  • 3
    A little shorter: git clean -xdf that is equal to git clean -x -d -f.
    – Kiryl
    Commented Nov 21, 2019 at 20:30
  • 2
    git clean -ffxd to remove everything not in the repo Commented Dec 31, 2019 at 15:09
71

Use the commands below. These commands will remove all untracked files from local git too

git fetch origin
git reset --hard origin/master
git clean -d -f
2
  • 6
    This is a more complete response because without the git clean -d -f we'll still had some things of the old branch in local directory. Thanks man.
    – Flavio
    Commented Jul 4, 2019 at 7:03
  • 4
    git clean -ffxd to truely remove everything Commented Dec 31, 2019 at 15:09
50

The question mixes two issues here:

  1. how to reset a local branch to the point where the remote is
  2. how to clear your staging area (and possibly the working directory), so that git status says nothing to commit, working directory clean.

The one-stop-answer is:

  1. git fetch --prune (optional) Updates the local snapshot of the remote repo. Further commands are local only.
    git reset --hard @{upstream}Puts the local branch pointer to where the snapshot of the remote is, as well as set the index and the working directory to the files of that commit.
  2. git clean -d --force Removes untracked files and directories which hinder git to say “working directory clean”.
2
  • 2
    The @{upstream} syntax requires upstream to be set which happens by default if you git checkout <branchname>. – Otherwise replace it with origin/<branchname>. Commented Jan 31, 2016 at 1:31
  • Add -x to git clean to remove everything not in the commit (i.e. even files ignored with the .gitignore mechanism). Commented Jan 31, 2016 at 1:34
36

Provided that the remote repository is origin, and that you're interested in branch_name:

git fetch origin
git reset --hard origin/<branch_name>

Also, you go for reset the current branch of origin to HEAD.

git fetch origin
git reset --hard origin/HEAD

How it works:

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

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

2
  • 1
    I'm not sure I follow origin/HEAD here and I don't think it's correct
    – CervEd
    Commented Jun 16, 2021 at 11:07
  • 1
    This is what I was looking for. All other answer reset with remote master branch, I wanted to know remote current branch. The answer if pretty straight-forward though
    – Gangula
    Commented Nov 11, 2023 at 13:44
29

You can fetch the origin and reset to solve the problem

 git fetch origin
 git reset --hard origin/main

You can save your changes before doing the reset like below,

git stash

And after resetting, if you want that changes back, you can simply run,

git stash apply
28

This is something I face regularly, & I've generalised the script Wolfgang provided above to work with any branch

I also added an "are you sure" prompt, & some feedback output

#!/bin/bash
# reset the current repository
# WF 2012-10-15
# AT 2012-11-09
# see http://stackoverflow.com/questions/1628088/how-to-reset-my-local-repository-to-be-just-like-the-remote-repository-head
timestamp=`date "+%Y-%m-%d-%H_%M_%S"`
branchname=`git rev-parse --symbolic-full-name --abbrev-ref HEAD`
read -p "Reset branch $branchname to origin (y/n)? "
[ "$REPLY" != "y" ] || 
echo "about to auto-commit any changes"
git commit -a -m "auto commit at $timestamp"
if [ $? -eq 0 ]
then
  echo "Creating backup auto-save branch: auto-save-$branchname-at-$timestamp"
  git branch "auto-save-$branchname-at-$timestamp" 
fi
echo "now resetting to origin/$branchname"
git fetch origin
git reset --hard origin/$branchname
2
  • 3
    you might want to use "git remote" to get the name of the remote. In certain cases, it won't be "origin" Commented Oct 7, 2014 at 22:54
  • The logic in your script is not correct. The [ "$REPLY" != "y" ] || will only skip the next line echo "about to auto-commit any changes" and continue running the rest of the script. The line should read something like [[ "$REPLY" != "y" ]] && { echo "Exiting branch reset"; exit; }.
    – jgshawkey
    Commented Aug 14, 2020 at 19:03
26

2023 simple solution :

git fetch
git reset --hard @{u}

Reseting to origin/HEAD won't always work as it's not necessarily the latest commit of your current branch.

1
  • 1
    That was easy. Worked perfectly for resetting my local branch against a rebased (and squashed) origin Commented Nov 30, 2023 at 20:28
22

I did:

git branch -D master
git checkout master

to totally reset branch


note, you should checkout to another branch to be able to delete required branch

4
  • 5
    You should read question once again, there is nothing on affecting remote, but setting to same as remote, so you shouldn't do anything with remote, and this helped in my case and non of above. Commented May 14, 2014 at 10:43
  • If you want to set it to the same as remote, you should at least do a fetch at some point don't you agree?
    – Tim
    Commented May 14, 2014 at 10:50
  • 2
    you should at least try this or read docs: kernel.org/pub/software/scm/git/docs/git-checkout.html Commented May 14, 2014 at 11:04
  • Way to go, I had a corrupt .pck file in the branch and the rest of options didn't work, thanks!! Commented Aug 6, 2019 at 15:10
19

Here is a script that automates what the most popular answer suggests ... See https://stackoverflow.com/a/13308579/1497139 for an improved version that supports branches

#!/bin/bash
# reset the current repository
# WF 2012-10-15
# see https://stackoverflow.com/questions/1628088/how-to-reset-my-local-repository-to-be-just-like-the-remote-repository-head
timestamp=`date "+%Y-%m-%d-%H_%M_%S"`
git commit -a -m "auto commit at $timestamp"
if [ $? -eq 0 ]
then
  git branch "auto-save-at-$timestamp" 
fi
git fetch origin
git reset --hard origin/master
18

The answer

git clean -d -f

was underrated (-d to remove directories). Thanks!

1
  • And for a full, 100% clean repo folder with no extra files, run git clean -xdf. This will delete any and all files that git is not aware of, and will make your folder match what is in git's object list exactly. Note that you can add -n (e.g. git clean -nxdf) to perform a "what-if" and it will tell you what it will delete without actually doing anything. (git clean)
    – qJake
    Commented Mar 7, 2020 at 5:56
16

If you had a problem as me, that you have already committed some changes, but now, for any reason you want to get rid of it, the quickest way is to use git reset like this:

git reset --hard HEAD~2

I had 2 not needed commits, hence the number 2. You can change it to your own number of commits to reset.

So answering your question - if you're 5 commits ahead of remote repository HEAD, you should run this command:

git reset --hard HEAD~5

Notice that you will lose the changes you've made, so be careful!

15

Previous answers assume that the branch to be reset is the current branch (checked out). In comments, OP hap497 clarified that the branch is indeed checked out, but this is not explicitly required by the original question. Since there is at least one "duplicate" question, Reset branch completely to repository state, which does not assume that the branch is checked out, here's an alternative:

If branch "mybranch" is not currently checked out, to reset it to remote branch "myremote/mybranch"'s head, you can use this low-level command:

git update-ref refs/heads/mybranch myremote/mybranch

This method leaves the checked out branch as it is, and the working tree untouched. It simply moves mybranch's head to another commit, whatever is given as the second argument. This is especially helpful if multiple branches need to be updated to new remote heads.

Use caution when doing this, though, and use gitk or a similar tool to double check source and destination. If you accidentally do this on the current branch (and git will not keep you from this), you may become confused, because the new branch content does not match the working tree, which did not change (to fix, update the branch again, to where it was before).

13

This is what I use often:

git fetch upstream develop;
git reset --hard upstream/develop;
git clean -d --force;

Note that it is good practice not to make changes to your local master/develop branch, but instead checkout to another branch for any change, with the branch name prepended by the type of change, e.g. feat/, chore/, fix/, etc. Thus you only need to pull changes, not push any changes from master. Same thing for other branches that others contribute to. So the above should only be used if you have happened to commit changes to a branch that others have committed to, and need to reset. Otherwise in future avoid pushing to a branch that others push to, instead checkout and push to the said branch via the checked out branch.

If you want to reset your local branch to the latest commit in the upstream branch, what works for me so far is:

Check your remotes, make sure your upstream and origin are what you expect, if not as expected then use git remote add upstream <insert URL>, e.g. of the original GitHub repo that you forked from, and/or git remote add origin <insert URL of the forked GitHub repo>.

git remote --verbose

git checkout develop;
git commit -m "Saving work.";
git branch saved-work;
git fetch upstream develop;
git reset --hard upstream/develop;
git clean -d --force

On GitHub, you can also checkout the branch with the same name as the local one, in order to save the work there, although this isn't necessary if origin develop has the same changes as the local saved-work branch. I'm using the develop branch as an example, but it can be any existing branch name.

git add .
git commit -m "Reset to upstream/develop"
git push --force origin develop

Then if you need to merge these changes with another branch while where there are any conflicts, preserving the changes in develop, use:

git merge -s recursive -X theirs develop

While use

git merge -s recursive -X ours develop

to preserve branch_name's conflicting changes. Otherwise use a mergetool with git mergetool.

With all the changes together:

git commit -m "Saving work.";
git branch saved-work;
git checkout develop;
git fetch upstream develop;
git reset --hard upstream/develop;
git clean -d --force;
git add .;
git commit -m "Reset to upstream/develop";
git push --force origin develop;
git checkout branch_name;
git merge develop;

Note that instead of upstream/develop you could use a commit hash, other branch name, etc. Use a CLI tool such as Oh My Zsh to check that your branch is green indicating that there is nothing to commit and the working directory is clean (which is confirmed or also verifiable by git status). Note that this may actually add commits compared to upstream develop if there is anything automatically added by a commit, e.g. UML diagrams, license headers, etc., so in that case, you could then pull the changes on origin develop to upstream develop, if needed.

11

Only 3 commands will make it work

git fetch origin
git reset --hard origin/HEAD
git clean -f
9

The top rated answer here did not reset my local code as expected.

  1. nowadays, master is usually main
  2. it doesn't do anything with untracked files you may have lying around

Instead:

  1. check the name of your default remote branch (this is not a git thing so check in GitHub) then replace main or master in step 4 below with this

  2. save current stuff git stash -u

  3. update from remote git fetch origin

  4. reset to remote default branch (but see step 1 above) git reset --hard origin/main

8

If you want to go back to the HEAD state for both the working directory and the index, then you should git reset --hard HEAD, rather than to HEAD^. (This may have been a typo, just like the single versus double dash for --hard.)

As for your specific question as to why those files appear in the status as modified, it looks like perhaps you did a soft reset instead of a hard reset. This will cause the files that were changed in the HEAD commit to appear as if they were staged, which is likely what you are seeing here.

8

No amount of reset and cleaning seemed to have any effect on untracked and modified files in my local git repo (I tried all the options above). My only solution to this was to rm the local repo and re-clone it from the remote.

Fortunately I didn't have any other branches I cared about.

xkcd: Git

7

First, check with git status if you have any local changes. If yes, stash them.

Then execute:

git fetch
git reset --hard @{push}

It will reset the current local branch to the same remote branch which would be used for git push. This is especially useful when git config push.default current is configured. For example, when your branch is abc and remote is origin, it will reset it to origin/abc.

Please see Git revisions for more details about @{push}

1
  • This is really neat. I'm going to change/add a bunch of aliases with this @{push}
    – Snekse
    Commented Dec 19, 2022 at 15:14
4

The only solution that works in all cases that I've seen is to delete and reclone. Maybe there's another way, but obviously this way leaves no chance of old state being left there, so I prefer it. Bash one-liner you can set as a macro if you often mess things up in git:

REPO_PATH=$(pwd) && GIT_URL=$(git config --get remote.origin.url) && cd .. && rm -rf $REPO_PATH && git clone --recursive $GIT_URL $REPO_PATH && cd $REPO_PATH

* assumes your .git files aren't corrupt

1
  • 6
    you can also just reinstall your operating system if you want to be certain! Commented Jul 10, 2019 at 8:07
4

Have you forgotten to create a feature-branch and have committed directly on master by mistake?

You can create the feature branch now and set master back without affecting the worktree (local filesystem) to avoid triggering builds, tests and trouble with file-locks:

git checkout -b feature-branch
git branch -f master origin/master
1
  • Throwing error because it has uncomitted changes.
  1. So, You can use git stash
  • This saves uncomitted changes away for later use, and then reverts them from your working copy.
  • If you want these changes again, you can use git stash apply
  1. Then You can use git pull
  • This takes the recent code from remote repo.
1
  • Doesn't work if you have conflicting unpushed commits (error: "fatal: refusing to merge unrelated histories")
    – nh43de
    Commented Jun 2, 2022 at 16:37
0
git fetch origin
git checkout main
git reset --hard origin/main
# Local `master` branch is now up to date with remote `main`
0
-2

If you don't mind saving your local changes, yet still want to update your repository to match origin/HEAD, you can simply stash your local changes and then pull:

git stash
git pull
0

Not the answer you're looking for? Browse other questions tagged or ask your own question.