How do I undo the most recent local commits in Git?

Question

How do I undo the most recent local commits in Git?

13.9m Views Asked by Hamza Yerlikaya At 22 December 2024 at 18:25

I accidentally committed the wrong files to Git, but didn't push the commit to the server yet.

How do I undo those commits from the local repository?

Original Q&A

There are 106 best solutions below

Fadid On 27 December 2016 at 18:42

Use this command:

git checkout -b old-state number_commit

Carl On 18 November 2014 at 19:11

Usually, you want to undo a commit because you made a mistake and you want to fix it - essentially what the OP did when he asked the question. Really, you actually want to redo a commit.

Most of the answers here focus on the command line. While the command line is the best way to use Git when you're comfortable with it, its probably a bit alien to those coming from other version control systems to Git.

Here's how to do it using a GUI. If you have Git installed, you already have everything you need to follow these instructions.

NOTE: I will assume here that you realised the commit was wrong before you pushed it. If you don't know what pushing means, then you probably haven't pushed. Carry on with the instructions. If you have pushed the faulty commit, the least risky way is just to follow up the faulty commit with a new commit that fixes things, the way you would do it in a version control system that does not allow you to rewrite history.

That said, here's how to fix your most recent fault commit using a GUI:

Navigate to your repository on the command line and start the GUI with git gui
Choose "Amend last commit". You will see your last commit message, the files you staged and the files you didn't.
Now change things to how you want them to look and click Commit.

Mohit On 14 September 2017 at 04:33

Undo the Last Commit

There are tons of situations where you really want to undo that last commit into your code. E.g. because you'd like to restructure it extensively - or even discard it altogether!

In these cases, the "reset" command is your best friend:

$ git reset --soft HEAD~1

The above command (reset) will rewind your current HEAD branch to the specified revision. In our example above, we'd like to return to the one before the current revision - effectively making our last commit undone.

Note the --soft flag: this makes sure that the changes in undone revisions are preserved. After running the command, you'll find the changes as uncommitted local modifications in your working copy.

If you don't want to keep these changes, simply use the --hard flag. Be sure to only do this when you're sure you don't need these changes any more.

$ git reset --hard HEAD~1

iOS Coder On 29 August 2013 at 16:18

Use SourceTree (graphical tool for Git) to see your commits and tree. You can manually reset it directly by right clicking it.

Shubham Chaudhary On 06 January 2014 at 22:34

Use reflog to find a correct state

git reflog

REFLOG BEFORE RESET

Select the correct reflog (f3cb6e2 in my case) and type

git reset --hard f3cb6e2

After that the repo HEAD will be reset to that HEADid reset effect LOG AFTER RESET

Finally the reflog looks like the picture below

reflog after REFLOG FINAL

RIYAS PULLUR On 16 November 2023 at 03:37

Use the following command to reset the repository to a specific commit. Replace n with the number of commits you want to undo. For example, to undo the last 1 commits, you would use:

git reset --hard HEAD~1

Use the following command to reset the repository to a specific commit. Replace n with the number of commits you want to undo. For example, to undo the last 3 commits, you would use:

git reset --hard HEAD~3

Alternatively, you can use the commit hash of the commit to which you want to reset:

git reset --hard <commit-hash>

Jaco Pretorius On 25 May 2012 at 16:04

Use git revert <commit-id>.

To get the commit ID, just use git log.

Montresor On 22 November 2020 at 13:38

In order to remove some files from a Git commit, use the “git reset” command with the “–soft” option and specify the commit before HEAD.

$ git reset --soft HEAD~1

When running this command, you will be presented with the files from the most recent commit (HEAD) and you will be able to commit them.

Now that your files are in the staging area, you can remove them (or unstage them) using the “git reset” command again.

$ git reset HEAD <file>

Note: this time, you are resetting from HEAD as you simply want to exclude files from your staging area

If you are simply not interested in this file any more, you can use the “git rm” command in order to delete the file from the index (also called the staging area).

$ git rm --cached <file>

When you are done with the modifications, you can simply commit your changes again with the “–amend” option.

$ git commit --amend

To verify that the files were correctly removed from the repository, you can run the “git ls-files” command and check that the file does not appear in the file (if it was a new one of course)

$ git ls-files

 <file1>
 <file2>

Remove a File From a Commit using Git Restore

Since Git 2.23, there is a new way to remove files from commit, but you will have to make sure that you are using a Git version greater or equal than 2.23.

$ git --version

Git version 2.24.1

Note: Git 2.23 was released in August 2019 and you may not have this version already available on your computer.

To install newer versions of Git, you can check this tutorial. To remove files from commits, use the “git restore” command, specify the source using the “–source” option and the file to be removed from the repository.

For example, in order to remove the file named “myfile” from the HEAD, you would write the following command

$ git restore --source=HEAD^ --staged  -- <file>

As an example, let’s pretend that you edited a file in your most recent commit on your “master” branch.

The file is correctly committed but you want to remove it from your Git repository.

To remove your file from the Git repository, you want first to restore it.

$ git restore --source=HEAD^ --staged  -- newfile

$ git status

On branch 'master'

Your branch is ahead of 'origin/master' by 1 commit. (use "git push" to publish your local commits)

Changes to be committed:

 (use "git restore --staged <file>..." to unstage)
    modified:   newfile

Changes not staged for commit:

 (use "git add <file>..." to update what will be committed)
 (use "git restore <file>..." to discard changes in working directory)
      modified:   newfile

As you can see, your file is back to the staging area.

From there, you have two choices, you can choose to edit your file in order to re-commit it again, or to simply delete it from your Git repository.

Remove a File from a Git Repository

In this section, we are going to describe the steps in order to remove the file from your Git repository.

First, you need to unstage your file as you won’t be able to remove it if it is staged.

To unstage a file, use the “git reset” command and specify the HEAD as source.

$ git reset HEAD newfile

When your file is correctly unstaged, use the “git rm” command with the “–cached” option in order to remove this file from the Git index (this won’t delete the file on disk)

$ git rm --cached newfile

rm 'newfile'

Now if you check the repository status, you will be able to see that Git staged a deletion commit.

$ git status

On branch 'master'

Your branch is ahead of 'origin/master' by 1 commit. (use "git push" to publish your local commits)

Changes to be committed:

 (use "git restore --staged <file>..." to unstage)
    deleted:    newfile

Now that your file is staged, simply use the “git commit” with the “–amend” option in order to amend the most recent commit from your repository.

`$ git commit --amend

 [master 90f8bb1] Commit from HEAD
  Date: Fri Dec 20 03:29:50 2019 -0500
  1 file changed, 2 deletions(-)
  delete mode 100644 newfile

`As you can see, this won’t create a new commit but it will essentially modify the most recent commit in order to include your changes.

Remove a Specific File from a Git Commit

In some cases, you don’t want all the files to be staged again: you only one to modify one very specific file of your repository.

In order to remove a specific file from a Git commit, use the “git reset” command with the “–soft” option, specify the commit before HEAD and the file that you want to remove.

$ git reset HEAD^ -- <file>

When you are done with the modifications, your file will be back in the staging area.

First, you can choose to remove the file from the staging area by using the “git reset” command and specify that you want to reset from the HEAD.

$ git reset HEAD <file>

Note: it does not mean that you will lose the changes on this file, just that the file will be removed from the staging area.

If you want to completely remove the file from the index, you will have to use the “git rm” command with the “–cached” option.

$ git reset HEAD <file>

In order to make sure that your file was correctly removed from the staging area, use the “git ls-files” command to list files that belong to the index.

$ git ls-files

When you are completely done with your modifications, you can amend the commit you removed the files from by using the “git commit” command with the “–amend” option.

$ git commit --amend

Nalan Madheswaran On 12 November 2018 at 00:49

Get last commit ID by using this command (in the log one on the top it is the latest one):

git log

Get the commit id (GUID) and run this command:

git revert <commit_id>

Zombo On 25 October 2012 at 03:41

I prefer to use git rebase -i for this job, because a nice list pops up where I can choose the commits to get rid of. It might not be as direct as some other answers here, but it just feels right.

Choose how many commits you want to list, then invoke like this (to enlist last three)

git rebase -i HEAD~3

Sample list

pick aa28ba7 Sanity check for RtmpSrv port
pick c26c541 RtmpSrv version option
pick 58d6909 Better URL decoding support

Then Git will remove commits for any line that you remove.

AudioBubble On 03 September 2020 at 19:44

$ git commit -m 'Initial commit'
$ git add forgotten_file
$ git commit --amend

It’s important to understand that when you’re amending your last commit, you’re not so much fixing it as replacing it entirely with a new, improved commit that pushes the old commit out of the way and puts the new commit in its place. Effectively, it’s as if the previous commit never happened, and it won’t show up in your repository history.

The obvious value to amending commits is to make minor improvements to your last commit, without cluttering your repository history with commit messages of the form, “Oops, forgot to add a file” or “Darn, fixing a typo in last commit”.

2.4 Git Basics - Undoing Things

Theo Itzaris On 16 September 2018 at 08:36

What I do each time I need to undo a commit/commits are:

git reset HEAD~<n> // the number of last commits I need to undo
git status // optional. All files are now in red (unstaged).
Now, I can add & commit just the files that I need:

git add <file names> & git commit -m "message" -m "details"

Optional: I can rollback the changes of the rest files, if I need, to their previous condition, with checkout:

git checkout <filename>

if I had already pushed it to remote origin, previously:

git push origin <branch name> -f // use -f to force the push.

Nic On 24 September 2018 at 11:58

If you want to undo the very first commit in your repo

You'll encounter this problem:

$ git reset HEAD~
fatal: ambiguous argument 'HEAD~': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

The error occurs because if the last commit is the initial commit (or no parents) of the repository, there is no HEAD~.

Solution

If you want to reset the only commit on "master" branch

$ git update-ref -d HEAD
$ git rm --cached -r .

Tom Hale On 27 September 2018 at 13:12

How to edit an earlier commit

Generally I don't want to undo a bunch of commits, but rather edit an earlier commit to how I wish I had committed it in the first place.

I found myself fixing a past commit frequently enough that I wrote a script for it.

Here's the workflow:

```
git commit-edit <commit-hash>
```
This will drop you at the commit you want to edit.

The changes of the commit will be unstaged, ready to be staged as you wish it was the first time.
Fix and stage the commit as you wish it had been in the first place.

(You may want to use git stash save --keep-index to squirrel away any files you're not committing)
Redo the commit with --amend, eg:
```
git commit --amend
```
Complete the rebase:
```
git rebase --continue
```

Call this following git-commit-edit and put it in your $PATH:

#!/bin/bash

# Do an automatic git rebase --interactive, editing the specified commit
# Revert the index and working tree to the point before the commit was staged
# https://stackoverflow.com/a/52324605/5353461

set -euo pipefail

script_name=${0##*/}

warn () { printf '%s: %s\n' "$script_name" "$*" >&2; }
die () { warn "$@"; exit 1; }

[[ $# -ge 2 ]] && die "Expected single commit to edit. Defaults to HEAD~"

# Default to editing the parent of the most recent commit
# The most recent commit can be edited with `git commit --amend`
commit=$(git rev-parse --short "${1:-HEAD~}")

# Be able to show what commit we're editing to the user
if git config --get alias.print-commit-1 &>/dev/null; then
  message=$(git print-commit-1 "$commit")
else
  message=$(git log -1 --format='%h %s' "$commit")
fi

if [[ $OSTYPE =~ ^darwin ]]; then
  sed_inplace=(sed -Ei "")
else
  sed_inplace=(sed -Ei)
fi

export GIT_SEQUENCE_EDITOR="${sed_inplace[*]} "' "s/^pick ('"$commit"' .*)/edit \\1/"'
git rebase --quiet --interactive --autostash --autosquash "$commit"~
git reset --quiet @~ "$(git rev-parse --show-toplevel)"  # Reset the cache of the toplevel directory to the previous commit
git commit --quiet --amend --no-edit --allow-empty  #  Commit an empty commit so that that cache diffs are un-reversed

echo
echo "Editing commit: $message" >&2
echo

Chamod Dissanayake On 04 June 2021 at 18:00

You can use the git reset unwanted_file command with the file you don't want to stage. By using this command, we can move the changed file from the staging area to the working directory.

How can I undo commits in Git locally and remotely?

Spyder On 18 February 2016 at 03:27

There are many ways to do it:

Git command to undo the last commit/ previous commits:

Warning: Do Not use --hard if you do not know what you are doing. --hard is too dangerous, and it might delete your files.

Basic command to revert the commit in Git is:

$ git reset --hard <COMMIT -ID>

or

$ git reset --hard HEAD~<n>

COMMIT-ID: ID for the commit

n: is the number of last commits you want to revert

You can get the commit id as shown below:

$ **git log --oneline**

d81d3f1 function to subtract two numbers

be20eb8 function to add two numbers

bedgfgg function to multiply two numbers

where d81d3f1 and be20eb8 are commit id.

Now, let's see some cases:

Suppose you want to revert the last commit 'd81d3f1'. Here are two options:

$ git reset --hard d81d3f1

or

$ git reset --hard HEAD~1

Suppose you want to revert the commit 'be20eb8':

$ git reset --hard be20eb8

For more detailed information, you can refer to and try out some other commands too for resetting the head to a specified state:

$ git reset --help

Umar Hayat On 09 December 2022 at 22:05

A simple step-by-step guide is as follows:

Destroy a commit and throw away any uncommitted changes
```
git reset --hard HEAD~1
```
Undo the commit, but keep your changes
```
git reset HEAD~1
```
Keep your files, and stage all changes back automatically
```
git reset --soft HEAD~1
```
Resurrect a commit you destroyed
```
git reflog # To find the sh
```

CyberChris On 31 July 2020 at 06:18

I validate an efficient method proposed, and here is a concrete example using it:

In case you want to permanently undo/cancel your last commit (and so on, one by one, as many as you want) three steps:

1: Get the id = SHA of the commit you want to arrive on with, of course

$ git log

2: Delete your previous commit with

$ git reset --hard 'your SHA'

3: Force the new local history upon your origin GitHub with the -f option (the last commit track will be erased from the GitHub history)

$ git push origin master -f

Example

$ git log

Last commit to cancel

commit e305d21bdcdc51d623faec631ced72645cca9131 (HEAD -> master, origin/master, origin/HEAD)
Author: Christophe <[email protected]>
Date:   Thu Jul 30 03:42:26 2020 +0200

U2_30 S45; updating files package.json & yarn.lock for GitHub Web Page from docs/CV_Portfolio...

Commit we want now on HEAD

commit 36212a48b0123456789e01a6c174103be9a11e61
Author: Christophe <[email protected]>
Date:   Thu Jul 30 02:38:01 2020 +0200

First commit, new title

Reach the commit before by deleting the last one

$ git reset --hard 36212a4

HEAD is now at 36212a4 First commit, new title

Check it's OK

$ git log

commit 36212a48b0123456789e01a6c174103be9a11e61 (HEAD -> master)
Author: Christophe <[email protected]>
Date:   Thu Jul 30 02:38:01 2020 +0200

    First commit, new title

$ git status

On branch master
Your branch is behind 'origin/master' by 1 commit, and can be fast-forwarded.
 (use "git pull" to update your local branch)

nothing to commit, working tree clean

Update your history on the Git(Hub)

$ git push origin master -f

Total 0 (delta 0), reused 0 (delta 0), pack-reused 0
To https://github.com/ GitUser bla bla/React-Apps.git
 + e305d21...36212a4 master -> master (forced update)

Check it's all right

$ git status

On branch master
Your branch is up to date with 'origin/master'.

nothing to commit, working tree clean

FraK On 11 August 2015 at 14:11

In my case I committed and pushed to the wrong branch, so what I wanted was to have all my changes back so I can commit them to a new correct branch, so I did this:

On the same branch that you committed and pushed, if you type "git status" you won't see anything new because you committed and pushed, now type:

    git reset --soft HEAD~1

This will get all your changes(files) back in the stage area, now to get them back in the working directory(unstage) you just type:

git reset FILE

Where "File" is the file that you want to commit again. Now, this FILE should be in the working directory(unstaged) with all the changes that you did. Now you can change to whatever branch that you want and commit the changes in that branch. Of course, the initial branch that you committed is still there with all changes, but in my case that was ok, if it is not for you-you can look for ways to revert that commit in that branch.

omkaartg On 18 May 2018 at 07:00

git push --delete (branch_name) //this will be removing the public version of your branch

git push origin (branch_name) //This will add the previous version back

Khem On 22 May 2018 at 23:52

Rebasing and dropping commits are the best when you want to keep the history clean useful when proposing patches to a public branch etc.

If you have to drop the topmost commit then the following one-liner helps

git rebase --onto HEAD~1 HEAD

But if you want to drop 1 of many commits you did say

a -> b -> c -> d -> master

and you want to drop commit 'c'

git rebase --onto b c

This will make 'b' as the new base of 'd' eliminating 'c'

Zaz On 31 July 2010 at 09:39

To change the last commit

Replace the files in the index:

git rm --cached *.class
git add *.java

Then, if it's a private branch, amend the commit:

git commit --amend

Or, if it's a shared branch, make a new commit:

git commit -m 'Replace .class files with .java files'

(To change a previous commit, use the awesome interactive rebase.)

ProTip™: Add *.class to a gitignore to stop this happening again.

To revert a commit

Amending a commit is the ideal solution if you need to change the last commit, but a more general solution is reset.

You can reset Git to any commit with:

git reset @~N

Where N is the number of commits before HEAD, and @~ resets to the previous commit.

Instead of amending the commit, you could use:

git reset @~
git add *.java
git commit -m "Add .java files"

Check out git help reset, specifically the sections on --soft --mixed and --hard, for a better understanding of what this does.

Reflog

If you mess up, you can always use the reflog to find dropped commits:

$ git reset @~
$ git reflog
c4f708b HEAD@{0}: reset: moving to @~
2c52489 HEAD@{1}: commit: added some .class files
$ git reset 2c52489
... and you're back where you started

Yahs Hef On 24 May 2015 at 21:09

You need to do the easy and fast

    git commit --amend

if it's a private branch or

    git commit -m 'Replace .class files with .java files'

if it's a shared or public branch.

egridasov On 18 July 2013 at 06:41

In my case I accidentally committed some files I did not want to. So I did the following and it worked:

git reset --soft HEAD^
git rm --cached [files you do not need]
git add [files you need]
git commit -c ORIG_HEAD

Verify the results with gitk or git log --stat

Mohideen bin Mohammed On 18 July 2017 at 11:05

HEAD:

Before reset commit we should know about HEAD... HEAD is nothing but your current state in your working directory. It is represented by a commit number.

Git commit:

Each change assigned under a commit which is represented by a unique tag. Commits can't be deleted. So if you want your last commit, you can simply dive into it using git reset.

You can dive into the last commit using two methods:

Method 1: (if you don't know the commit number, but want to move onto the very first)

git reset HEAD~1  # It will move your head to last commit

Method 2: (if you know the commit you simply reset onto your known commit)

git reset 0xab3 # Commit number

Note: if you want to know a recent commit try git log -p -1

Here is the graphical representation:

Shwetank On 02 August 2017 at 08:58

You can undo your Git commits in two ways: First is you can use git revert, if you want to keep your commit history:

git revert HEAD~3
git revert <hashcode of commit>

Second is you can use git reset, which would delete all your commit history and bring your head to commit where you want it.

git reset <hashcode of commit>
git reset HEAD~3

You can also use the --hard keyword if any of it starts behaving otherwise. But, I would only recommend it until it's extremely necessary.

Michał Szajbe On 23 October 2019 at 09:19

To undo the last local commit, without throwing away its changes, I have this handy alias in ~/.gitconfig

[alias]
  undo = reset --soft HEAD^

Then I simply use git undo which is super-easy to remember.

CodeWizard On 26 September 2021 at 17:50

Before answering, let's add some background, explaining what this HEAD is.

`First of all what is HEAD?`

HEAD is simply a reference to the current commit (latest) on the current branch.
There can only be a single HEAD at any given time (excluding git worktree).

The content of HEAD is stored inside .git/HEAD and it contains the 40 bytes SHA-1 of the current commit.

`detached HEAD`

If you are not on the latest commit - meaning that HEAD is pointing to a prior commit in history it's called detached HEAD.

On the command line, it will look like this - SHA-1 instead of the branch name since the HEAD is not pointing to the tip of the current branch:

A few options on how to recover from a detached HEAD:

`git checkout`

git checkout <commit_id>
git checkout -b <new branch> <commit_id>
git checkout HEAD~X // x is the number of commits to go back

This will checkout the new branch pointing to the desired commit.
This command will checkout to a given commit.
At this point, you can create a branch and start to work from this point on.

# Checkout a given commit.
# Doing so will result in a `detached HEAD` which mean that the `HEAD`
# is not pointing to the latest so you will need to checkout branch
# in order to be able to update the code.
git checkout <commit-id>

# Create a new branch forked to the given commit
git checkout -b <branch name>

`git reflog`

You can always use the reflog as well.
git reflog will display any change which updated the HEAD and checking out the desired reflog entry will set the HEAD back to this commit.

Every time the HEAD is modified there will be a new entry in the reflog

git reflog
git checkout HEAD@{...}

This will get you back to your desired commit

`git reset --hard <commit_id>`

"Move" your HEAD back to the desired commit.

# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32

# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts if you've modified things which were
# changed since the commit you reset to.

Note: (Since Git 2.7) you can also use the git rebase --no-autostash as well.

`git revert <sha-1>`

"Undo" the given commit or commit range.
The reset command will "undo" any changes made in the given commit.
A new commit with the undo patch will be committed while the original commit will remain in history as well.

# Add a new commit with the undo of the original one.
# The <sha-1> can be any commit(s) or commit range
git revert <sha-1>

This schema illustrates which command does what.
As you can see there, reset && checkout modify the HEAD.

Alexis Määttä Vinkler On 05 October 2021 at 13:26

Undoing a series of local commits

OP: How do I undo the most recent local commits in Git? I accidentally committed the wrong files [as part of several commits].

Start case

There are several ways to "undo" as series of commits, depending on the outcome you're after. Considering the start case below, reset, rebase and filter-branch can all be used to rewrite your history.

How can C1 and C2 be undone to remove the tmp.log file from each commit?

In the examples below, absolute commit references are used, but it works the same way if you're more used to relative references (i.e. HEAD~2 or HEAD@{n}).

Alternative 1: `reset`

$ git reset --soft t56pi

With reset, a branch can be reset to a previous state, and any compounded changes be reverted to the Staging Area, from where any unwanted changes can then be discarded.

Note: As reset clusters all previous changes into the Staging Area, individual commit meta-data is lost. If this is not OK with you, chances are you're probably better off with rebase or filter-branch instead.

Alternative 2: `rebase`

$ git rebase --interactive t56pi

Using an interactive rebase each offending commit in the branch can be rewritten, allowing you to modify and discard unwanted changes. In the infographic above, the source tree on the right illustrates the state post rebase.

Step-by-step

Select from which commit the rebase should be based (e.g. t56pi)
Select which commits you'd like to change by replacing pick with edit. Save and close.
Git will now stop on each selected commit allowing you to reset HEAD, remove the unwanted files, and create brand new commits.

Note: With rebase much of the commit meta data is kept, in contrast to the reset alternative above. This is most likely a preferred option, if you want to keep much of your history but only remove the unwanted files.

Alternative 3: `filter-branch`

$ git filter-branch --tree-filter 'rm -r ./tmp.log' t56pi..HEAD

Above command would filter out the file ./tmp.log from all commits in the desired range t56pi..HEAD (assuming our initial start case from above). See below illustration for clarity.

Similar to rebase, filter-branch can be used to wipe unwanted files from a subsection of a branch. Instead of manually editing each commit through the rebase process, filter-branch can automatically preformed the desired action on each commit.

Note: Just like rebase, filter-branch would preserve the rest of the commit meta-data, by only discarding the desired file. Notice how C1 and C2 have been rewritten, and the log-file discarded from each commit.

Conclusion

Just like anything related to software development, there are multiple ways to achieve the same (or similar) outcome for a give problem. You just need to pick the one most suitable for your particular case.

Finally - a friendly advice

Do note that all three alternatives above rewrites the history completely. Unless you know exactly what you're doing and have good communication within your team - only rewrite commits that have not yet been published remotely!

Source: All examples above are borrowed from this blog.

Madhan Ayyasamy On 31 January 2013 at 07:06

If you are planning to undo a local commit entirely, whatever you change you did on the commit, and if you don't worry anything about that, just do the following command.

git reset --hard HEAD^1

(This command will ignore your entire commit and your changes will be lost completely from your local working tree). If you want to undo your commit, but you want your changes in the staging area (before commit just like after git add) then do the following command.

git reset --soft HEAD^1

Now your committed files come into the staging area. Suppose if you want to upstage the files, because you need to edit some wrong content, then do the following command

git reset HEAD

Now committed files to come from the staged area into the unstaged area. Now files are ready to edit, so whatever you change, you want to go edit and added it and make a fresh/new commit.

More (link broken) (Archived version)

Gerard de Visser On 18 August 2021 at 12:35

If you want to revert the last commit but still want to keep the changes locally that were made in the commit, use this command:

git reset HEAD~1 --mixed

thestar On 28 August 2014 at 16:03

To reset to the previous revision, permanently deleting all uncommitted changes:

git reset --hard HEAD~1

santos_mgr On 03 September 2014 at 07:15

If you have committed junk but not pushed,

git reset --soft HEAD~1

HEAD~1 is a shorthand for the commit before head. Alternatively you can refer to the SHA-1 of the hash if you want to reset to. --soft option will delete the commit but it will leave all your changed files "Changes to be committed", as git status would put it.

If you want to get rid of any changes to tracked files in the working tree since the commit before head use "--hard" instead.

OR

If you already pushed and someone pulled which is usually my case, you can't use git reset. You can however do a git revert,

git revert HEAD

This will create a new commit that reverses everything introduced by the accidental commit.

JeremyWeir On 29 November 2018 at 20:44

If you simply want to trash all your local changes/commits and make your local branch look like the origin branch you started from...

git reset --hard origin/branch-name

Arun Karnawat On 10 December 2018 at 07:05

The simplest way to undo the last commit is

git reset HEAD^

This will bring the project state before you have made the commit.

Keshan Nageswaran On 21 December 2018 at 02:02

The difference between git reset --mixed, --soft and --hard

Prerequisite: When a modification to an existing file in your repository is made, this change is initially considered as unstaged. In order to commit the changes, it needs to be staged which means adding it to the index using git add. During a commit operation, the files that are staged gets added to an index.

Let's take an example:

- A - B - C (master)

HEAD points to C and the index matches C.

--soft

When we execute git reset --soft B with the intention of removing the commit C and pointing the master/HEAD to B.
The master/HEAD will now point to B, but the index still has changed from C.
When executing git status you could see the files indexed in commit C as staged.
Executing a git commit at this point will create a new commit with the same changes as C

--mixed

Execute git reset --mixed B.
On execution, master/HEAD will point to B and the index is also modified to match B because of the mixed flag used.
If we run git commit at this point, nothing will happen since the index matches HEAD.
We still have the changes in the working directory, but since they're not in the index, git status shows them as unstaged.
To commit them, you would git add and then commit as usual.

--hard

Execute git reset --hard B
On execution, master/HEAD will point to B and modifies your working directory
The changes added in C and all the uncommitted changes will be removed.
Files in the working copy will match the commit B, this will result in loosing permanently all changes which were made in commit C plus uncommitted changes

Hope this comparison of flags that are available to use with git reset command will help someone to use them wisely. Refer these for further details link1 & link2

Tom Stickel On 26 April 2016 at 21:35

VISUAL STUDIO USERS (2015, etc.)

If you cannot synchronise in Visual Studio as you are not allowed to push to a branch like "development" then as much as I tried, in Visual Studio NEITHER the REVERT NOR the RESET (hard or soft) would work.

Per the answer with TONS OF VOTES:

Use this at the command prompt of root of your project to nuke anything that will attempt to get pushed:

git reset --hard HEAD~1

Backup or zip your files just in case you don't wish to lose any work, etc...

Brent Bradburn On 23 April 2013 at 17:27

How to fix the previous local commit

Use git-gui (or similar) to perform a git commit --amend. From the GUI you can add or remove individual files from the commit. You can also modify the commit message.

How to undo the previous local commit

Just reset your branch to the previous location (for example, using gitk or git rebase). Then reapply your changes from a saved copy. After garbage collection in your local repository, it will be like the unwanted commit never happened. To do all of that in a single command, use git reset HEAD~1.

Word of warning: Careless use of git reset is a good way to get your working copy into a confusing state. I recommend that Git novices avoid this if they can.

How to undo a public commit

Perform a reverse cherry pick (git-revert) to undo the changes.

If you haven't yet pulled other changes onto your branch, you can simply do...

git revert --no-edit HEAD

Then push your updated branch to the shared repository.

The commit history will show both commits, separately.

Advanced: Correction of the private branch in public repository

This can be dangerous -- be sure you have a local copy of the branch to repush.

Also note: You don't want to do this if someone else may be working on the branch.

git push --delete (branch_name) ## remove public version of branch

Clean up your branch locally then repush...

git push origin (branch_name)

In the normal case, you probably needn't worry about your private-branch commit history being pristine. Just push a followup commit (see 'How to undo a public commit' above), and later, do a squash-merge to hide the history.

CommaToast On 13 May 2013 at 17:12

Another way:

Checkout the branch you want to revert, then reset your local working copy back to the commit that you want to be the latest one on the remote server (everything after it will go bye-bye). To do this, in SourceTree I right-clicked on the and selected "Reset BRANCHNAME to this commit".

Then navigate to your repository's local directory and run this command:

git -c diff.mnemonicprefix=false -c core.quotepath=false push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME

This will erase all commits after the current one in your local repository but only for that one branch.

Kyle Delaney On 11 June 2021 at 21:58

Visual Studio Code makes this very easy.

ranidu harshana On 06 August 2023 at 09:41

You can use github desktop. After adding a commit it shows a popup to undo a commit. It is very easy to undo a latest commit from it

CodeWizard On 28 January 2017 at 00:10

Before answering let's add some background, explaining what is this HEAD.

`First of all what is HEAD?`

HEAD is simply a reference to the current commit (latest) on the current branch.
There can only be a single HEAD at any given time. (excluding git worktree)

The content of HEAD is stored inside .git/HEAD and it contains the 40 bytes SHA-1 of the current commit.

`detached HEAD`

If you are not on the latest commit - meaning that HEAD is pointing to a prior commit in history its called detached HEAD.

On the command line, it will look like this- SHA-1 instead of the branch name since the HEAD is not pointing to the tip of the current branch

A few options on how to recover from a detached HEAD:

`git checkout`

git checkout <commit_id>
git checkout -b <new branch> <commit_id>
git checkout HEAD~X // x is the number of commits t go back

This will checkout new branch pointing to the desired commit.
This command will checkout to a given commit.
At this point, you can create a branch and start to work from this point on.

# Checkout a given commit. 
# Doing so will result in a `detached HEAD` which mean that the `HEAD`
# is not pointing to the latest so you will need to checkout branch
# in order to be able to update the code.
git checkout <commit-id>

# create a new branch forked to the given commit
git checkout -b <branch name>

`git reflog`

You can always use the reflog as well.
git reflog will display any change which updated the HEAD and checking out the desired reflog entry will set the HEAD back to this commit.

Every time the HEAD is modified there will be a new entry in the reflog

git reflog
git checkout HEAD@{...}

This will get you back to your desired commit

`git reset --hard <commit_id>`

"Move" your HEAD back to the desired commit.

# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32

# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts if you've modified things which were
# changed since the commit you reset to.

Note: (Since Git 2.7)
you can also use the git rebase --no-autostash as well.

`git revert <sha-1>`

"Undo" the given commit or commit range.
The reset command will "undo" any changes made in the given commit.
A new commit with the undo patch will be committed while the original commit will remain in the history as well.

# add new commit with the undo of the original one.
# the <sha-1> can be any commit(s) or commit range
git revert <sha-1>

This schema illustrates which command does what.
As you can see there reset && checkout modify the HEAD.

neoneye On 06 April 2012 at 13:58

I wanted to undo the latest five commits in our shared repository. I looked up the revision id that I wanted to rollback to. Then I typed in the following.

prompt> git reset --hard 5a7404742c85
HEAD is now at 5a74047 Added one more page to catalogue
prompt> git push origin master --force
Total 0 (delta 0), reused 0 (delta 0)
remote: bb/acl: neoneye is allowed. accepted payload.
To [email protected]:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
prompt>

ManojP On 25 November 2021 at 11:15

In case if you want to revert to a last commit and remove the log history as well

Use the below command. Let’s say you want to go to a previous commit which has commit ID SHA-1 hash value:

71e2e57458bde883a37b332035f784c6653ec509

Then you can point to this commit. It will not display any log message after this commit and all history will be erased after that.

git push origin +71e2e57458bde883a37b332035f784c6653ec509^:master

Dominic Cerisano On 27 June 2017 at 21:34

For sake of completeness, I will give the one glaringly obvious method that was overlooked by the previous answers.

Since the commit was not pushed, the remote was unchanged, so:

Delete the local repository.
Clone the remote repository.

This is sometimes necessary if your fancy Git client goes bye-bye (looking at you, egit).

Don't forget to re-commit your saved changes since the last push.

nickf On 13 December 2011 at 10:18

If you have Git Extras installed, you can run git undo to undo the latest commit. git undo 3 will undo the last three commits.

V V On 04 December 2015 at 17:20

Remove a wrong commit that is already pushed to Github

git push origin +(previous good commit id):(branch name)

Please specify the last good commit id you would like to reset back in Github.

For example. If latest commit id is wrong then specify the previous commit id in above git command with the branch name.

You can get previous commit id using git log

dseminara On 12 September 2014 at 14:51

There are two main scenarios

You haven't pushed the commit yet

If the problem was extra files you commited (and you don't want those on repository), you can remove them using git rm and then commiting with --amend

git rm <pathToFile>

You can also remove entire directories with -r, or even combine with other Bash commands

git rm -r <pathToDirectory>
git rm $(find -name '*.class')

After removing the files, you can commit, with --amend option

git commit --amend -C HEAD # the -C option is to use the same commit message

This will rewrite your recent local commit removing the extra files, so, these files will never be sent on push and also will be removed from your local .git repository by GC.

You already pushed the commit

You can apply the same solution of the other scenario and then doing git push with the -f option, but it is not recommended since it overwrites the remote history with a divergent change (it can mess your repository).

Instead, you have to do the commit without --amend (remember this about -amend`: That option rewrites the history on the last commit).

Tharindu Lakshan On 27 February 2023 at 18:30

If you have committed changes to Git, but have not yet pushed those changes to the remote repository, you can use the git reset command to undo those commits from your local repository.

Here's how:

Use the git log command to find the commit hash of the commit that you want to undo. The commit hash is a long string of numbers and letters that uniquely identifies the commit. You can copy the commit hash to your clipboard by highlighting it and pressing Ctrl + C on Windows or Command + C on macOS.
```
git log
commit 1234567890abcdefg
Author: Your Name <[email protected]>
Date:   Mon Feb 21 13:42:24 2022 -0500

   Commit message goes here
```
Use the git reset command with the --hard option and the commit hash that you want to reset to. This will remove all the commits after the specified commit from your local repository, including any changes made in those commits.
```
git reset --hard 1234567890abcdefg
```
Note that the --hard option will permanently delete any changes that you have made since the specified commit. If you want to keep your changes as unstaged changes in your working directory, you can use the --soft option instead of --hard.
```
git reset --soft 1234567890abcdefg
```
After running the git reset command, you can use the git log command again to verify that the unwanted commits have been removed from your local repository.
```
$ git log
commit 1234567890abcdefg
Author: Your Name <[email protected]>
Date:   Mon Feb 21 13:42:24 2022 -0500

    Commit message goes here
```

If the unwanted commits are no longer in the log, you have successfully removed them from your local repository.

Georgi Georgiev On 03 September 2018 at 13:19

git revert commit

This will generate the opposite changes from the commit which you want to revert back, and then just commit that changes. I think this is the simplest way.

https://git-scm.com/docs/git-revert

sed On 17 April 2018 at 15:41

Try this, hard reset to previous commit where those files were not added, then:

git reset --hard <commit_hash>

Make sure you have a backup of your changes just in case, as it's a hard reset, which means they'll be lost (unless you stashed earlier)

Paras Korat On 05 July 2019 at 06:26

Do as the following steps.

Step 1

Hit git log

From the list of log, find the last commit hash code and then enter:

Step 2

git reset <hash code>

AO_ On 08 July 2019 at 15:20

I wrote about this ages ago after having these same problems myself:

How to delete/revert a Git commit

Basically you just need to do:

git log, get the first seven characters of the SHA hash, and then do a git revert <sha> followed by git push --force.

You can also revert this by using the Git revert command as follows: git revert <sha> -m -1 and then git push.

Abubakr Elghazawy On 11 March 2019 at 07:19

git reset --soft HEAD~1

Reset will rewind your current HEAD branch to the specified revision.

Note the --soft flag: this makes sure that the changes in undone revisions are preserved. After running the command, you'll find the changes as uncommitted local modifications in your working copy.

If you don't want to keep these changes, simply use the --hard flag. Be sure to only do this when you're sure you don't need these changes anymore.

 git reset --hard HEAD~1

Undoing Multiple Commits

git reset --hard 0ad5a7a6

Keep in mind, however, that using the reset command undoes all commits that came after the one you returned to:

geoom On 04 March 2014 at 04:35

For a local commit

git reset --soft HEAD~1

or if you do not remember exactly in which commit it is, you might use

git rm --cached <file>

For a pushed commit

The proper way of removing files from the repository history is using git filter-branch. That is,

git filter-branch --index-filter 'git rm --cached <file>' HEAD

But I recomnend you use this command with care. Read more at git-filter-branch(1) Manual Page.

Manish Shrivastava On 05 March 2014 at 13:55

A single command:

git reset --soft 'HEAD^'

It works great to undo the last local commit!

shreshta bm On 10 December 2015 at 07:17

You can always do a git checkout <SHA code> of the previous version and then commit again with the new code.

arslan On 17 April 2020 at 06:36

git reset --soft HEAD~1

git status

Output

On branch master
Your branch is ahead of 'origin/master' by 1 commit.
(use "git push" to publish your local commits)

Changes to be committed:
(use "git restore --staged ..." to unstage) new file: file1

git log --oneline --graph

Output

90f8bb1 (HEAD -> master) Second commit \

7083e29 Initial repository commit \

Ryan Lundy On 28 July 2011 at 22:22

Undoing a commit is a little scary if you don't know how it works. But it's actually amazingly easy if you do understand. I'll show you the 4 different ways you can undo a commit.

Say you have this, where C is your HEAD and (F) is the state of your files.

   (F)
A-B-C
    ↑
  master

Option 1: `git reset --hard`

You want to destroy commit C and also throw away any uncommitted changes. You do this:

git reset --hard HEAD~1

The result is:

 (F)
A-B
  ↑
master

Now B is the HEAD. Because you used --hard, your files are reset to their state at commit B.

Option 2: `git reset`

Maybe commit C wasn't a disaster, but just a bit off. You want to undo the commit but keep your changes for a bit of editing before you do a better commit. Starting again from here, with C as your HEAD:

   (F)
A-B-C
    ↑
  master

Do this, leaving off the --hard:

git reset HEAD~1

In this case the result is:

   (F)
A-B-C
  ↑
master

In both cases, HEAD is just a pointer to the latest commit. When you do a git reset HEAD~1, you tell Git to move the HEAD pointer back one commit. But (unless you use --hard) you leave your files as they were. So now git status shows the changes you had checked into C. You haven't lost a thing!

Option 3: `git reset --soft`

For the lightest touch, you can even undo your commit but leave your files and your index:

git reset --soft HEAD~1

This not only leaves your files alone, it even leaves your index alone. When you do git status, you'll see that the same files are in the index as before. In fact, right after this command, you could do git commit and you'd be redoing the same commit you just had.

Option 4: you did `git reset --hard` and need to get that code back

One more thing: Suppose you destroy a commit as in the first example, but then discover you needed it after all? Tough luck, right?

Nope, there's still a way to get it back. Type this

git reflog

and you'll see a list of (partial) commit SHAs (that is, hashes) that you've moved around in. Find the commit you destroyed, and do this:

git checkout -b someNewBranchName shaYouDestroyed

You've now resurrected that commit. Commits don't actually get destroyed in Git for some 90 days, so you can usually go back and rescue one you didn't mean to get rid of.

akshay_rahar On 06 March 2016 at 11:53

Undo last commit:

git reset --soft HEAD^ or git reset --soft HEAD~

This will undo the last commit.

Here --soft means reset into staging.

HEAD~ or HEAD^ means to move to commit before HEAD.

Replace last commit to new commit:

git commit --amend -m "message"

It will replace the last commit with the new commit.

ioopl On 16 March 2016 at 15:41

I got the commit ID from bitbucket and then did:

git checkout commitID .

Example:

git checkout 7991072 .

And it reverted it back up to that working copy of that commit.

Abubakar Khalid On 10 August 2022 at 10:48

If you have made local commits that you don't like, and they have not been pushed yet you can reset things back to a previous good commit. It will be as if the bad commits never happened. Here's how:

In your terminal (Terminal, Git Bash, or Windows Command Prompt), navigate to the folder for your Git repo. Run git status and make sure you have a clean working tree. Each commit has a unique hash (which looks something like 2f5451f). You need to find the hash for the last good commit (the one you want to revert back to). Here are two places you can see the hash for commits: In the commit history on GitHub or Bitbucket or website. In your terminal (Terminal, Git Bash, or Windows Command Prompt) run the command git log --online Once you know the hash for the last good commit (the one you want to revert back to), run the following command (replacing 2f5451f with your commit's hash):

git reset 2f5451f
git reset --hard 2f5451f

NOTE: If you do git reset the commits will be removed, but the changes will appear as uncommitted, giving you access to the code. This is the safest option because maybe you wanted some of that code and you can now make changes and new commits that are good. Often though you'll want to undo the commits and throw away the code, which is what git reset --hard does.

lbragile On 01 January 2021 at 21:47

I usually first find the commit hash of my recent commit:

git log

It looks like this: commit {long_hash}

Copy this long_hash and reset to it (go back to same files/state it was on that commit):

git reset --hard {insert long_hash without braces}

copycat On 06 January 2021 at 14:42

If the repository has been committed locally and not yet pushed to the server, another crude/layman way of solving it would be:

Git clone the repository in another location.
Copy the modifications (files/directories) from the original repository into this new one. Then commit and push with the changes from the new one.
Replace the old repository with this new one.

Varun Parakh On 28 June 2013 at 10:18

On SourceTree (GUI for GitHub), you may right-click the commit and do a 'Reverse Commit'. This should undo your changes.

On the terminal:

You may alternatively use:

git revert

Or:

git reset --soft HEAD^ # Use --soft if you want to keep your changes.
git reset --hard HEAD^ # Use --hard if you don't care about keeping your changes.

user853293 On 15 May 2013 at 13:12

Type git log and find the last commit hash code and then enter:

git reset <the previous co>

poorva On 17 May 2013 at 13:02

If you want to permanently undo it and you have cloned some repository.

The commit id can be seen by:

git log

Then you can do like:

git reset --hard <commit_id>

git push origin <branch_name> -f

Alisa On 06 November 2016 at 03:38

In order to get rid of (all the changes in) last commit, last 2 commits and last n commits:

git reset --hard HEAD~1
git reset --hard HEAD~2
...
git reset --hard HEAD~n

And, to get rid of anything after a specific commit:

git reset --hard <commit sha>

e.g.,

git reset --hard 0d12345

Be careful with the hard option: it deletes the local changes in your repo as well and reverts to the previous mentioned commit. You should only run this if you are sure you messed up in your last commit(s) and would like to go back in time.

As a side-note, about 7 letters of the commit hash is enough, but in bigger projects, you may need up to 12 letters for it to be unique. You can also use the entire commit SHA if you prefer.

The above commands work in GitHub for Windows as well.

Uchiha Itachi On 15 November 2016 at 21:07

Assuming you're working in Visual Studio, if you go in to your branch history and look at all of your commits, simply select the event prior to the commit you want to undo, right-click it, and select Revert. Easy as that.

Ali Motameni On 18 November 2016 at 08:57

Think we have code.txt file. We make some changes on it and commit. We can undo this commit in three ways, but first you should know what is the staged file... An staged file is a file that ready to commit and if you run git status this file will be shown with green color and if this is not staged for commit will be shown with red color:

It means if you commit your change, your changes on this file is not saved. You can add this file in your stage with git add code.txt and then commit your change:

Undo last commit:

Now if we want to just undo commit without any other changes, we can use

git reset --soft HEAD^
If we want to undo commit and its changes (THIS IS DANGEROUS, because your change will lost), we can use

git reset --hard HEAD^
And if we want to undo commit and remove changes from stage, we can use

git reset --mixed HEAD^ or in a short form git reset HEAD^

vidur punj On 17 June 2022 at 18:12

git reset --soft HEAD~1

Soft: This will remove the commit from local only and keep the changes done in files as it is.

    git reset --hard HEAD~1
    git push origin master

Hard: This will remove that commit from local and remote and remove changes done in files.

shiraz On 10 February 2019 at 21:25

Replace your local version, including your changes with the server version. These two lines of code will force Git to pull and overwrite local.

Open a command prompt and navigate to the Git project root. If you use Visual Studio, click on Team, Sync and click on "Open Command Prompt" (see the image) below.

Once in the Cmd prompt, go ahead with the following two instructions.

git fetch --all

Then you do

git reset --hard origin/master

This will overwrite the existing local version with the one on the Git server.

Eugen Konkov On 15 December 2016 at 16:21

I have found this site which describes how to undo things that you have committed into the repository.

Some commands:

git commit --amend        # Change last commit
git reset HEAD~1 --soft   # Undo last commit

Andrew On 16 June 2011 at 17:27

There are two ways to "undo" your last commit, depending on whether or not you have already made your commit public (pushed to your remote repository):

How to undo a local commit

Let's say I committed locally, but now I want to remove that commit.

git log
    commit 101: bad commit    # Latest commit. This would be called 'HEAD'.
    commit 100: good commit   # Second to last commit. This is the one we want.

To restore everything back to the way it was prior to the last commit, we need to reset to the commit before HEAD:

git reset --soft HEAD^     # Use --soft if you want to keep your changes
git reset --hard HEAD^     # Use --hard if you don't care about keeping the changes you made

Now git log will show that our last commit has been removed.

How to undo a public commit

If you have already made your commits public, you will want to create a new commit which will "revert" the changes you made in your previous commit (current HEAD).

git revert HEAD

Your changes will now be reverted and ready for you to commit:

git commit -m 'restoring the file I removed by accident'
git log
    commit 102: restoring the file I removed by accident
    commit 101: removing a file we don't need
    commit 100: adding a file that we need

For more information, check out Git Basics - Undoing Things.

Ranjithkumar Ravi On 23 April 2014 at 11:21

How to undo the last Git commit?

To restore everything back to the way it was prior to the last commit, we need to reset to the commit before HEAD.

If you don't want to keep your changes that you made:
```
git reset --hard HEAD^
```
If you want to keep your changes:
```
git reset --soft HEAD^
```

Now check your git log. It will show that our last commit has been removed.

Jishnu Sukumaran On 06 July 2015 at 08:30

Use this command

git checkout -b old-state 0d1d7fc32

Ehtasham ul haq On 01 January 2024 at 12:08

To undo the most recent local commits in Git, you have a couple of options depending on what you want to do:

Soft Reset: If you want to keep the changes from the commits but just undo the commit itself, you can use a soft reset. This will move the HEAD pointer to a previous commit without altering the working directory or staging area.

git reset --soft HEAD~1

This command will remove the most recent commit from the branch but keep the changes from that commit in the staging area. You can then make further modifications or commit again.

Mixed Reset: If you want to undo the commit and also unstage the changes (but keep them in your working directory), you can use a mixed reset.

bash

git reset --hard HEAD~1

Caution: Using git reset --hard will remove all changes made in the most recent commit irreversibly. Be sure that you want to discard these changes before using this command.

Remember to replace HEAD~1 with the number of commits you want to undo if it's more than one. Also, be cautious when using reset commands, especially --hard, as it can discard changes irreversibly.

Raj Rusia On 06 March 2018 at 12:26

You can undo your commits from the local repository. Please follow the below scenario.

In the below image I check out the 'test' branch (using Git command git checkout -b test) as a local and check status (using Git command git status) of local branch that there is nothing to commit.

In the next image image you can see here I made a few changes in Filter1.txt and added that file to the staging area and then committed my changes with some message (using Git command git commit -m "Doing commit to test revert back").

"-m is for commit message"

In the next image you can see your commits log whatever you have made commits (using Git command git log).

So in the above image you can see the commit id with each commit and with your commit message now whatever commit you want to revert back or undo copy that commit id and hit the below Git command, git revert {"paste your commit id"}. Example:

git revert 9ca304ed12b991f8251496b4ea452857b34353e7

I have reverted back my last commit. Now if you check your Git status, you can see the modified file which is Filter1.txt and yet to commit.

amd On 28 July 2016 at 07:24

WHAT TO USE, `reset --soft` or `reset --hard`?

I am just adding two cents for @Kyralessa's answer:

If you are unsure what to use go for --soft (I used this convention to remember it --soft for safe).

Why?

If you choose --hard by mistake you will LOSE your changes as it wasn't before. If you choose --soft by mistake you can achieve the same results of --hard by applying additional commands

git reset HEAD file.html
git checkout -- file.html

Full example

echo "some changes..." > file.html
git add file.html
git commit -m "wrong commit"

# I need to reset
git reset --hard HEAD~1 (cancel changes)
# OR
git reset --soft HEAD~1 # Back to staging
git reset HEAD file.html # back to working directory
git checkout -- file.html # cancel changes

Credits goes to @Kyralessa.

Alexandr On 29 July 2016 at 10:14

If you are working with SourceTree, this will help you.

Right click on the commit then select "Reset (current branch)/master to this commit" and last select "Soft" reset.

Prashant Biradar On 11 March 2024 at 16:57

Another solution:

If we want to achieve with interactive mode using git rebase command: Run below command

git rebase -i HEAD~2

Note: Here, Number 2 indicates N last commits we want to see it on interactive prompt.

Then interactive window will open in editor. We can edit and save file.

pick 31de0dc6387 First commit message
pick e98b2fc43d3 Second commit message
# Rebase d2b363648d3..e98b2fc43d3 onto d2b363648d3 (2 commands)
#
# Commands:
# p, pick <commit> = use commit
# r, reword <commit> = use commit, but edit the commit message
# e, edit <commit> = use commit, but stop for amending
# s, squash <commit> = use commit, but meld into previous commit
# f, fixup [-C | -c] <commit> = like "squash" but keep only the previous
#                    commit's log message, unless -C is used, in which case
#                    keep only this commit's message; -c is same as -C but
#                    opens the editor
# x, exec <command> = run command (the rest of the line) using shell
# b, break = stop here (continue rebase later with 'git rebase --continue')
# d, drop <commit> = remove commit
# l, label <label> = label current HEAD with a name
# t, reset <label> = reset HEAD to a label
# m, merge [-C <commit> | -c <commit>] <label> [# <oneline>]

There are various options, we can pick only those commits which we want, We can squash all commits into single commit or modify commit messages. Also, we can change the order of commits.

To undo changes we can remove the below line from editor and save file.

pick e98b2fc43d3 Second commit message

After removing second commit id:

pick 31de0dc6387 First commit message
# Rebase d2b363648d3..e98b2fc43d3 onto d2b363648d3 (2 commands)
#
# Commands:
# p, pick <commit> = use commit
# r, reword <commit> = use commit, but edit the commit message
# e, edit <commit> = use commit, but stop for amending
# s, squash <commit> = use commit, but meld into previous commit
# f, fixup [-C | -c] <commit> = like "squash" but keep only the previous
#                    commit's log message, unless -C is used, in which case
#                    keep only this commit's message; -c is same as -C but
#                    opens the editor
# x, exec <command> = run command (the rest of the line) using shell
# b, break = stop here (continue rebase later with 'git rebase --continue')
# d, drop <commit> = remove commit
# l, label <label> = label current HEAD with a name
# t, reset <label> = reset HEAD to a label
# m, merge [-C <commit> | -c <commit>] <label> [# <oneline>]

Once you make the file change then save file and run below command

git rebase --continue

You can verify your changes with git log command which will give you commits history.

Now, you can push your changes.

git push origin <branch>

Kaushal Sachan On 02 March 2024 at 19:04

There are two way to undo most recent local commits..

01. git reset --hard HEAD~1
02.git reset --hard <commit-1-id>

Both method can use for reset second, third ... commits as below

01. git reset --hard HEAD~2
02.git reset --hard <commit-2-id>

01. git reset --hard HEAD~3
02.git reset --hard <commit-3-id>

.... ....... n so on.

Jade Han On 29 June 2016 at 06:28

You can use:

git reset HEAD@{1}

This command will delete your wrong commit without a Git log.

Ankit Patidar On 15 February 2018 at 07:08

Undo the last commit:

git reset --soft HEAD^ or git reset --soft HEAD~

This will undo the last commit.

Here --soft means reset into staging.

HEAD~ or HEAD^ means to move to commit before HEAD.

Replace the last commit to new commit:

git commit --amend -m "message"

It will replace the last commit with the new commit.

Eugen Konkov On 28 February 2018 at 08:34

Here is site: Oh shit, git!.

Here are many recipes how to undo things in Git. Some of them:

Oh shit, I need to change the message on my last commit!

git commit --amend
# follow prompts to change the commit message

Oh shit, I accidentally committed something to master that should have been on a brand new branch!

# Create a new branch from the current state of master
git branch some-new-branch-name
# Remove the commit from the master branch
git reset HEAD~ --hard
git checkout some-new-branch-name
# Your commit lives in this branch now :)

hubot On 29 May 2016 at 14:21

Just use git reset --hard <last good SHA> to reset your changes and give new commit. You can also use git checkout -- <bad filename>.

Stipe On 07 January 2020 at 00:26

Everybody comments in such a complicated manner.

If you want to remove the last commit from your branch, the simplest way to do it is:

git reset --hard HEAD~1

Now to actually push that change to get rid of your last commit, you have to

git push --force

And that's it. This will remove your last commit.

KawaiKx On 07 May 2017 at 01:01

Suppose you made a wrong commit locally and pushed it to a remote repository. You can undo the mess with these two commands:

First, we need to correct our local repository by going back to the commit that we desire:

git reset --hard <previous good commit id where you want the local repository  to go>

Now we forcefully push this good commit on the remote repository by using this command:

git push --force-with-lease

The 'with-lease' version of the force option it will prevent accidental deletion of new commits you do not know about (i.e. coming from another source since your last pull).

user1583465 On 17 November 2020 at 07:50

git reset HEAD@{n} will reset your last n actions.

For reset, for the last action, use git reset HEAD@{1}.

Muhammad Ali On 25 March 2023 at 16:18

Before picking specific tools (commands), please pick what you need rather than blindly running commands.

Amending the commit

Just in case you want to edit your last commit, there is a command.
Advantage: It allows you to correct the last commit's message as well as add more changes to it.
```
git commit --amend
```

Resetting the Commit

Really want to undo the last commit (because of massive changes or you want to discard it all).
Advantage: The reset command will return to the one before the current revision, effectively making the last commit undone.

A. Soft Reset

Advantage: A soft flag. It guarantees the preservation of modifications made in undone revisions. The changes appear in your working copy as uncommitted local modifications once you run the command.

git reset --soft HEAD~1

B. Hard Reset

Advantage: If you don't want to keep these changes, simply use the --hard flag. Be sure to only do this when you're sure you don't need these changes anymore.

git reset --hard HEAD~1

Undo last commit but keep changes made to the files

Advantage:

This command will tell Git to advance the HEAD pointer back one commit. The files' modifications won't be impacted, though. Now, if you run git status, you ought to still be able to view the local file changes.

git reset HEAD~1

Use according to your needs.

steven On 08 May 2015 at 08:04

Just undo the last commit:

git reset --soft HEAD~

Or undo the time before last time commit:

git reset --soft HEAD~2

Or undo any previous commit:

git reset --soft <commitID>

(you can get the commitID using git reflog)

When you undo a previous commit, remember to clean the workplace with

git clean

More details can be found in the docs: git-reset

Ankit Tiwari On 17 June 2020 at 09:32

In these cases, the "reset" command is your best friend:

git reset --soft HEAD~1

Reset will rewind your current HEAD branch to the specified revision. In our example above, we'd like to return to the one before the current revision - effectively making our last commit undone.

Note the --soft flag: this makes sure that the changes in undone revisions are preserved. After running the command, you'll find the changes as uncommitted local modifications in your working copy.

If you don't want to keep these changes, simply use the --hard flag. Be sure to only do this when you're sure you don't need these changes anymore.

git reset --hard HEAD~1

Ravi_Parmar On 03 October 2013 at 12:43

"Reset the working tree to the last commit"

git reset --hard HEAD^

"Clean unknown files from the working tree"

git clean

see - Git Quick Reference

NOTE: This command will delete your previous commit, so use with caution! git reset --hard is safer.

U. Ali On 11 October 2013 at 14:41

First run:

git reflog

It will show you all the possible actions you have performed on your repository, for example, commit, merge, pull, etc.

Then do:

git reset --hard ActionIdFromRefLog

nPcomp On 16 March 2017 at 21:20

If you would like to eliminate the wrong files you should do

git reset --soft <your_last_good_commit_hash_here> Here, if you do git status, you will see the files in the staging area. You can select the wrong files and take them down from the staging area.

Like the following.

git reset wrongFile1 wrongFile2 wrongFile3

You can now just add the files that you need to push,

git add goodFile1 goodFile2

Commit them

git commit -v or git commit -am "Message"

And push

git push origin master

However, if you do not care about the changed files you can hard reset to previous good commit and push everything to the server.

By

git reset --hard <your_last_good_commit_hash_here>

git push origin master

If you already published your wrong files to the server, you can use the --force flag to push to the server and edit the history.

git push --force origin master

Praveen On 03 June 2017 at 19:32

Find the last commit hash code by seeing the log by:

git log

Then

git reset <the previous co>

Krzysztof Walczewski On 20 June 2017 at 10:05

In IntelliJ IDEA you can just open the Git repository log by pressing Alt+9, right mouse button click at some tag from the commits list, and select: "Reset Current Branch to Here...".

Alireza On 21 June 2017 at 09:33

Just reset it doing the command below using git:

git reset --soft HEAD~1

Explain: what git reset does, it's basically reset to any commit you'd like to go back to, then if you combine it with --soft key, it will go back, but keep the changes in your file(s), so you get back to the stage which the file was just added, HEAD is the head of the branch and if you combine with ~1 (in this case you also use HEAD^), it will go back only one commit which what you want...

I create the steps in the image below in more details for you, including all steps that may happens in real situations and committing the code:

Sazzad Hissain Khan On 31 December 2015 at 14:34

A Typical Git Cycle

In speaking of Git-related commands in the previous answers, I would like to share my typical Git cycles with all readers which may helpful. Here is how I work with Git,

Cloning the first time from the remote server

git clone $project
Pulling from remote (when I don't have a pending local commit to push)

git pull
Adding a new local file1 into $to_be_committed_list (just imagine $to_be_committed_list means staged area)

git add $file1
Removing mistakenly added file2 from $to_be_committed_list (assume that file2 is added like step 3, which I didn't want)

git reset $file2
Committing file1 which is in $to_be_committed_list

git commit -m "commit message description"
Syncing local commit with remote repository before pushing

git pull --rebase
Resolving when conflict occurs prerequisite configure mergetool

git mergetool #resolve merging here, also can manually merge
Adding conflict-resolved files, let's say file1:

git add $file1
Continuing my previous rebase command

git rebase --continue
Pushing ready and already synced last local commit

git push origin head:refs/for/$branch # branch = master, dev, etc.

mfathy00 On 03 January 2016 at 23:59

To undo your local commit you use git reset <commit>. Also that tutorial is very helpful to show you how it works.

Alternatively, you can use git revert <commit>: reverting should be used when you want to add another commit that rolls back the changes (but keeps them in the project history).

code-8 On 06 January 2016 at 14:10

Simple, run this in your command line:

git reset --soft HEAD~

Lennart Koopmann On 29 May 2009 at 18:13

This will add a new commit which deletes the added files.

git rm yourfiles/*.class
git commit -a -m "deleted all class files in folder 'yourfiles'"

Or you can rewrite history to undo the last commit.

Warning: this command will permanently remove the modifications to the .java files (and any other files) that you committed -- and delete all your changes from your working directory:

git reset --hard HEAD~1

The hard reset to HEAD-1 will set your working copy to the state of the commit before your wrong commit.

bdonlan On 29 May 2009 at 18:16

Add/remove files to get things the way you want:

git rm classdir
git add sourcedir

Then amend the commit:

git commit --amend

The previous, erroneous commit will be edited to reflect the new index state - in other words, it'll be like you never made the mistake in the first place.

Note that you should only do this if you haven't pushed yet. If you have pushed, then you'll just have to commit a fix normally.

Ranadheer Reddy On 30 March 2017 at 20:56

Reference: How to undo last commit in Git?

If you have Git Extensions installed you can easily undo/revert any commit (you can download Git Extensions from here).

Open Git Extensions, right click on the commit you want to revert then select "Revert commit".

A popup will be opened (see the screenshot below)

Select "Automatically create a commit" if you want to directly commit the reverted changes or if you want to manually commit the reverted changes keep the box un-selected and click on "Revert this commit" button.

Videsh Chauhan On 23 May 2019 at 09:52

You can use git revert <commit-id>.

And for getting the commit ID, just use git log.

**Esko Luontola** · Accepted Answer

Undo a commit & redo

$ git commit -m "Something terribly misguided" # (0: Your Accident)
$ git reset HEAD~                              # (1)
[ edit files as necessary ]                    # (2)
$ git add .                                    # (3)
$ git commit -c ORIG_HEAD                      # (4)

git reset is the command responsible for the undo. It will undo your last commit while leaving your working tree (the state of your files on disk) untouched. You'll need to add them again before you can commit them again.
Make corrections to working tree files.
git add anything that you want to include in your new commit.
Commit the changes, reusing the old commit message. reset copied the old head to .git/ORIG_HEAD; commit with -c ORIG_HEAD will open an editor, which initially contains the log message from the old commit and allows you to edit it. If you do not need to edit the message, you could use the -C option.

Alternatively, to edit the previous commit (or just its commit message), commit --amend will add changes within the current index to the previous commit.

To remove (not revert) a commit that has been pushed to the server, rewriting history with git push origin main --force[-with-lease] is necessary. It's almost always a bad idea to use --force; prefer --force-with-lease instead, and as noted in the git manual:

You should understand the implications of rewriting history if you amend a commit that has already been published.

There are 106 best solutions below

Undo a commit & redo

Further Reading

Remove a File From a Commit using Git Restore

On branch 'master'

Remove a File from a Git Repository

On branch 'master'

Remove a Specific File from a Git Commit

If you want to undo the very first commit in your repo

Solution

How to edit an earlier commit

Example

Reach the commit before by deleting the last one

Check it's OK

Update your history on the Git(Hub)

Check it's all right

To change the last commit

To revert a commit

Reflog

First of all what is HEAD?

detached HEAD

A few options on how to recover from a detached HEAD:

Undoing a series of local commits

Start case

Alternative 1: reset

Alternative 2: rebase

Alternative 3: filter-branch

Conclusion

Finally - a friendly advice

The difference between git reset --mixed, --soft and --hard

--soft

--mixed

--hard

How to fix the previous local commit

How to undo the previous local commit

How to undo a public commit

Advanced: Correction of the private branch in public repository

This can be dangerous -- be sure you have a local copy of the branch to repush.

First of all what is HEAD?

detached HEAD

A few options on how to recover from a detached HEAD:

In case if you want to revert to a last commit and remove the log history as well

For a local commit

For a pushed commit

Output

Output

Option 1: git reset --hard

Option 2: git reset

Option 3: git reset --soft

Option 4: you did git reset --hard and need to get that code back

Undo last commit:

Replace last commit to new commit:

How to undo a local commit

How to undo a public commit

WHAT TO USE, reset --soft or reset --hard?

Why?

Full example

Amending the commit

Resetting the Commit

Undo last commit but keep changes made to the files

A Typical Git Cycle

Related Questions in GIT

Related Questions in VERSION-CONTROL

Related Questions in GIT-COMMIT

Related Questions in UNDO

Trending Questions

Popular # Hahtags

Popular Questions

`First of all what is HEAD?`

`detached HEAD`

Alternative 1: `reset`

Alternative 2: `rebase`

Alternative 3: `filter-branch`

`First of all what is HEAD?`

`detached HEAD`

Option 1: `git reset --hard`

Option 2: `git reset`

Option 3: `git reset --soft`

Option 4: you did `git reset --hard` and need to get that code back

WHAT TO USE, `reset --soft` or `reset --hard`?