How do I revert from my current state to a snapshot made on a certain commit?

If I do `git log`, then I get the following output:

    $ git log
    commit a867b4af366350be2e7c21b8de9cc6504678a61b`
    Author: Me &lt;me@me.com&gt;
    Date:   Thu Nov 4 18:59:41 2010 -0400

    blah blah blah...

    commit 25eee4caef46ae64aa08e8ab3f988bc917ee1ce4
    Author: Me &lt;me@me.com&gt;
    Date:   Thu Nov 4 05:13:39 2010 -0400

    more blah blah blah...

    commit 0766c053c0ea2035e90f504928f8df3c9363b8bd
    Author: Me &lt;me@me.com&gt;
    Date:   Thu Nov 4 00:55:06 2010 -0400

    And yet more blah blah...

    commit 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
    Author: Me &lt;me@me.com&gt;
    Date:   Wed Nov 3 23:56:08 2010 -0400

    Yep, more blah blah.

How do I revert to the commit from November 3, i.e. commit `0d1d7fc`?


How do I revert a Git repository to a previous commit?

Sometimes git suggests `git rm --cached` to unstage a file, sometimes `git reset HEAD file`. When should I use which?

EDIT:

    D:\code\gt2&gt;git init
    Initialized empty Git repository in D:/code/gt2/.git/
    D:\code\gt2&gt;touch a
    
    D:\code\gt2&gt;git status
    # On branch master
    #
    # Initial commit
    #
    # Untracked files:
    #   (use &quot;git add &lt;file&gt;...&quot; to include in what will be committed)
    #
    #       a
    nothing added to commit but untracked files present (use &quot;git add&quot; to track)
    
    D:\code\gt2&gt;git add a
    
    D:\code\gt2&gt;git status
    # On branch master
    #
    # Initial commit
    #
    # Changes to be committed:
    #   (use &quot;git rm --cached &lt;file&gt;...&quot; to unstage)
    #
    #       new file:   a
    #
    D:\code\gt2&gt;git commit -m a
    [master (root-commit) c271e05] a
     0 files changed, 0 insertions(+), 0 deletions(-)
     create mode 100644 a
    
    D:\code\gt2&gt;touch b
    
    D:\code\gt2&gt;git status
    # On branch master
    # Untracked files:
    #   (use &quot;git add &lt;file&gt;...&quot; to include in what will be committed)
    #
    #       b
    nothing added to commit but untracked files present (use &quot;git add&quot; to track)
    
    D:\code\gt2&gt;git add b
    
    D:\code\gt2&gt;git status
    # On branch master
    # Changes to be committed:
    #   (use &quot;git reset HEAD &lt;file&gt;...&quot; to unstage)
    #
    #       new file:   b
    #



Why are there two ways to unstage a file in Git?

I did a `git pull` and got an error: 

&gt; The following working tree files would be overwritten by merge...
&gt; Please move or remove them before you can merge.

To resolve this I did the following:

    git fetch
    git reset --hard origin/master

Now when I do `git pull`, it says everything up to date. I want to know what exactly happens when I run these commands. I know `git fetch` fetches the changes from the remote repo without merging them into my local repo.

What is the meaning of `git reset --hard origin/master`? How does it work?

What is the meaning of git reset --hard origin/master?

I&#39;d been working on something, and decided it was completely screwed...after having committed some of it. So I tried the following sequence:

    git reset --hard
    git rebase origin
    git fetch
    git pull
    git checkout

At which point I got the message

    Your branch is ahead of &#39;origin/master&#39; by 2 commits.

**I want to discard my local commits**, without having to wipe out my local directory and redownload everything. How can I accomplish that?



How to discard local commits in Git?

I have a git repository which holds a Drupal site.  I spent the last day trying to build a feature using several different modules.  I have given up on my current approach and have decided to try a different combination of modules.  However, my repository has several commits on the master branch that contain this feature development process (I understand that I did not branch in an effective manner.)  I want to get rid of the last three or four commits and set master to that point in my history (I don&#39;t want to merge my current work with anything, I just want it to go away.)  How do I do this?




How do I move master back several commits in git?

I reset my local master to a commit by this command:

    git reset --hard e3f1e37

when I enter `$ git status` command, terminal says:

    # On branch master
    # Your branch is behind &#39;origin/master&#39; by 7 commits, and can be fast-forwarded.
    
    #   (use &quot;git pull&quot; to update your local branch)
    #
    nothing to commit, working directory clean

Since I want to reset origin/header as well, I checkout to origin/master:

    $ git checkout origin/master
    Note: checking out &#39;origin/master&#39;.
    
    You are in &#39;detached HEAD&#39; state. You can look around, make experimental
    changes and commit them, and you can discard any commits you make in this
    state without impacting any branches by performing another checkout.
    
    If you want to create a new branch to retain commits you create, you may
    do so (now or later) by using -b with the checkout command again. Example:
    
      git checkout -b new_branch_name
    
    HEAD is now at 2aef1de... master problem fixed for master. its okay now.

and reset the header by this command:

    $ git reset --hard e3f1e37
    HEAD is now at e3f1e37 development version code incremented for new build.

Then I tried to add commit to origin/header that I was not successful.

    $ git commit -m &quot;Reverting to the state of the project at e3f1e37&quot;
    # HEAD detached from origin/master
    nothing to commit, working directory clean

Finally, I checkout to my local master.

    $ git checkout master
    Switched to branch &#39;master&#39;
    Your branch is behind &#39;origin/master&#39; by 7 commits, and can be fast-forwarded.
      (use &quot;git pull&quot; to update your local branch)

Since, I reset the head of origin/master I expect local and origin should be in same direction but as you see, git is saying that my local/master is behind origin/master by 7 commits.

How can I fix this issue? The things that I&#39;m looking for is Head of local/master and origin/master point to same commit. Following image shows what I did. Thanks.

![enter image description here][1]


  [1]: http://i.stack.imgur.com/fuQB3.png

Git, How to reset origin/master to a commit?

How can I uncommit my last commit in git?

Is it

    git reset --hard HEAD

or

    git reset --hard HEAD^

?


How to uncommit my last commit in Git

Is there a git command to revert all uncommitted changes in a working tree and index and to also remove newly created files and folders?

How to revert uncommitted changes including files and folders?

I know that Git tracks changes I make to my application, and it holds on to them until I commit the changes, but here&#39;s where I&#39;m hung up:

When I want to revert to a previous commit I use: 

&lt;pre&gt;&lt;code&gt;git reset --hard HEAD&lt;/code&gt;&lt;/pre&gt;

And Git returns:

    HEAD is now at 820f417 micro

How do I then revert the files on my hard drive back to that previous commit?

My next steps were:

    git add .
    git commit -m &quot;revert&quot;

But none of the files have changed on my hard drive...

What am I doing right/wrong?


How do I use &#39;git reset --hard HEAD&#39; to revert to a previous commit?

In Git, I was trying to do a `squash commit` by merging in another branch and then resetting `HEAD` to the previous place via:

    git reset origin/master

But I need to step out of this. How can I move HEAD back to the previous location?

I have the SHA-1 fragment (`23b6772`) of the commit that I need to move it to. How can I get back to this commit?


How can I move HEAD back to a previous location? (Detached head) &amp; Undo commits

I&#39;m trying to undo all changes since my last commit. I tried `git reset --hard` and `git reset --hard HEAD` after viewing [this post][1]. I responds with head is now at 18c3773... but when I look at my local source all the files are still there. What am I missing?


  [1]: https://stackoverflow.com/questions/7999259/git-how-to-perform-the-tfs-equivalent-of-undo-pending-changes

git undo all uncommitted or unsaved changes

&gt; **UPDATE&#178;**: With Git 2.23 (August 2019), there&#39;s a new command `git restore` that does this, see the [accepted answer](https://stackoverflow.com/a/15404733/946850).

&gt; **UPDATE**: This will work more intuitively as of Git 1.8.3, see [my own answer](https://stackoverflow.com/a/16589534/946850).

Imagine the following use case: I want to get rid of all changes in a specific subdirectory of my Git working tree, leaving all other subdirectories intact.

- I can do `git checkout .` , but [git checkout . adds directories excluded by sparse checkout](https://stackoverflow.com/questions/15251638/git-checkout-adds-directories-excluded-by-sparse-checkout)

- There is `git reset --hard`, but it won&#39;t let me do it for a subdirectory: 

        &gt; git reset --hard .
        fatal: Cannot do hard reset with paths.

  Again: https://stackoverflow.com/questions/11200839/why-git-cant-do-hard-soft-resets-by-path

- I can reverse-patch the current state using `git diff subdir | patch -p1 -R`, but this is a rather weird way of doing this.

What is the proper Git command for this operation?

The script below illustrates the problem. Insert the proper command below the `How to make files` comment -- the current command will restore the file `a/c/ac` which is supposed to be excluded by the sparse checkout. Note that I *do not* want to explicitly restore `a/a` and `a/b`, I only &quot;know&quot; `a` and want to restore everything below. **EDIT**: And I also don&#39;t &quot;know&quot; `b`, or which other directories reside on the same level as `a`.

    #!/bin/sh

    rm -rf repo; git init repo; cd repo
    for f in a b; do
      for g in a b c; do
        mkdir -p $f/$g
        touch $f/$g/$f$g
        git add $f/$g
        git commit -m &quot;added $f/$g&quot;
      done
    done
    git config core.sparsecheckout true
    echo a/a &gt; .git/info/sparse-checkout
    echo a/b &gt;&gt; .git/info/sparse-checkout
    echo b/a &gt;&gt; .git/info/sparse-checkout
    git read-tree -m -u HEAD
    echo &quot;After read-tree:&quot;
    find * -type f

    rm a/a/aa
    rm a/b/ab
    echo &gt;&gt; b/a/ba
    echo &quot;After modifying:&quot;
    find * -type f
    git status

    # How to make files a/* reappear without changing b and without recreating a/c?
    git checkout -- a

    echo &quot;After checkout:&quot;
    git status
    find * -type f


How to git reset --hard a subdirectory?

By mistake, I did `git add .` and `git commit` in the `develop` branch. But luckily, I did not do `git push`.

So I wanted to revert it back to original state.

I tried `git reset --soft` and `git reset HEAD --hard` but looks like I have messed it up.

How do I fix this? I want to go back to original state and possibly keep the code changes.

How to undo the last commit in git

I mistakenly added files using the command &quot;git add dir&quot;. I have not yet run &quot;git commit&quot;. Is there a way to remove this dir and everything contained within it from the commit?

I have tried `git reset dir`, but it didn&#39;t work. Apparently `git reset file` is the way to undo it. But I have so many files and so little time.

Undo “git add &lt;dir&gt;”?

What is the simplest way to undo a particular commit that is:

* not in the head or HEAD
* Has been pushed to the remote.

Because if it is not the latest commit, 

    git reset HEAD

doesn&#39;t work. And because it has been pushed to a remote,

    git rebase -i

and
    
    git rebase --onto

will cause some problem in the remotes. 

More so, I don&#39;t want to modify the history really. If there was bad code, it was there in the history and can be seen. I just want it out in the working copy, and I don&#39;t mind a reverse merge commit.

In other words, what is the [Git][2] equivalent of the following svn commands:

    svn merge -r 303:295 http://svn.example.com/repos/calc/trunk

which removes all changes from 295 to 302 by reverse merging all changes in those revisions, as a new commit.

    svn merge -c -302 ^/trunk

which undoes the 302 commit, of course by adding another commit that reverse merges the changes from that respective commit.

I thought it should be a fairly simple operation in Git and a fairly common use case. What else is the point of atomic commits? 

We have staging [stashing][3] and all to ensure the commits are perfectly atomic, shouldn&#39;t you be able to undo one or more of those atomic commits easily?

  [2]: http://en.wikipedia.org/wiki/Git_%28software%29
  [3]: http://en.wikipedia.org/wiki/Git_%28software%29#Stash


Undo a particular commit in Git that&#39;s been pushed to remote repos

I would like to know how to delete a commit.

By `delete`, I mean it is as if I didn&#39;t make that commit, and when I do a push in the future, my changes will not push to the remote branch.

I read git help, and I think the command I should use is `git reset --hard HEAD`.  Is this correct?

Delete commits from a branch in Git

I started some work on a new feature and after coding for a bit, I decided this feature should be on its own branch. 

How do I move the existing uncommitted changes to a new branch and reset my current one?

I want to reset my current branch while preserving existing work on the new feature.

Move existing, uncommitted work to a new branch in Git

My issue is I have changed a file e.g.: README, added a new line &#39;*this for my testing line*&#39; and saved the file, then I issued the following commands:

        
    git status

    # On branch master
    # Changed but not updated:
    #   (use &quot;git add &lt;file&gt;...&quot; to update what will be committed)
    #   (use &quot;git checkout -- &lt;file&gt;...&quot; to discard changes in working directory)
    #
    #	modified:   README
    #
    no changes added to commit (use &quot;git add&quot; and/or &quot;git commit -a&quot;)


    git add README
 
    git commit -a -m &#39;To add new line to readme&#39;


I didn&#39;t push the code to GitHub. Now I want to cancel this commit.

For this, I used 

    git reset --hard HEAD~1

But I lost the newly added line &#39;*this for my testing line*&#39; from the README file.
This should not happen. I need the content to be there. **Is there a way to retain the content and cancel my local commit?**


 



How to cancel a local git commit?

[GitRef.org - Basic][1]:

&gt; `git rm` will remove entries from the
&gt; staging area. This is a bit different
&gt; from `git reset HEAD` which &quot;unstages&quot;
&gt; files. By &quot;unstage&quot; I mean it reverts
&gt; the staging area to what was there
&gt; before we started modifying things.
&gt; `git rm` on the other hand just kicks
&gt; the file off the stage entirely, so
&gt; that it&#39;s not included in the next
&gt; commit snapshot, thereby effectively
&gt; deleting it.
&gt;
&gt; By default, a `git rm file` will remove the file from the staging area entirely and also off your disk &gt; (the working directory). To leave the file in the working directory, you can use `git rm --cached`.

But what exactly is the difference between `git rm --cached asd` and `git reset head -- asd`?


  [1]: http://gitref.org/basic/

&quot;git rm --cached x&quot; vs &quot;git reset head --​ x&quot;?

`$ git reset -- &lt;file_path&gt;` can reset by path.

However, `$ git reset (--hard|--soft) &lt;file_path&gt;` will report an error like below:

    Cannot do hard|soft reset with paths.

Why git can&#39;t do hard/soft resets by path?

When I want to unstage a staged file, all of my Git tutorials show something like:

```
$ git add *
$ git status
On branch master
Changes to be committed:
  (use &quot;git reset HEAD &lt;file&gt;...&quot; to unstage)

    renamed:    README.md -&gt; README
    modified:   CONTRIBUTING.md
```

This hint tells us to use `git reset` for unstaging a staged file.

But instead, in my terminal, I see:

```
git status
On branch master
Changes to be committed:
  (use &quot;git restore --staged &lt;file&gt;...&quot; to unstage)
	renamed:    cat.js -&gt; catcat.js
	renamed:    tolendo.gogo -&gt; tolendo.txt

Untracked files:
  (use &quot;git add &lt;file&gt;...&quot; to include in what will be committed)
	readme (copy).md
	tolendo (copy).txt
	zing (copy).html
```

My terminal tells me to use `git restore --staged` but the tutorials, as well as [Git’s website](https://git-scm.com/book/en/v2/Git-Basics-Undoing-Things#_unstaging), tell me to use `git reset HEAD`.

I have no idea about the new `restore` command. I tried Google to find the difference between `git reset` and `git restore` but nothing seemed to fit my question.

What is the `git restore` command and what is the difference between `git restore` and `git reset`?

As Git user I regular come across the situation, that I need to rework one or more commits in a way which do not fit into `--amend` or `rebase -i`with fixup commits. Typically I would do something like

    git reset HEAD~1
    # hack, fix, hack
    git commit -a
    # argh .. do I need to retype my message?
 
I take sensible composed commit messages quite serious. They typically contain larger text with references &amp; justifications for the change. Until now, I&#39;m quite annoyed on the lengthy process to recover my old commit message via an unsorted `git reflog`, `git log`and copy &amp; paste process.

Is there a better to tackle this? And how would it, if my comprises more than one commit?

_Edit:_ After a bit thinking about this I think what I&#39;m looking for is some _git stash_-like functionality for commit messages where fixup/amend commits are not appropriate.

Git: How to reuse/retain commit messages after &#39;git reset&#39;?

I am trying to recover my work. I stupidly did `git reset --hard`, but before that I&#39;ve done only `get add .` and didn&#39;t do `git commit`. Please help! Here is my log:

    MacBookPro:api user$ git status
    # On branch master
    # Changes to be committed:
    #   (use &quot;git reset HEAD &lt;file&gt;...&quot; to unstage)
    
    #   modified:   .gitignore
    ...


    MacBookPro:api user$ git reset --hard
    HEAD is now at ff546fa added new strucuture for api

Is it possible to undo `git reset --hard` in this situation?

Undo git reset --hard with uncommitted files in the staging area

I tried to undo my commit in git. Is it dangerous to use `git reset --hard HEAD~1`?

What is the difference between different options for `git reset`?


What is difference between &#39;git reset --hard HEAD~1&#39; and &#39;git reset --soft HEAD~1&#39;?

I&#39;ve always thought of `git reset` and `git checkout` as the same, in the sense that both bring the project back to a specific commit. However, I feel they can&#39;t be exactly the same, as that would be redundant. What is the actual difference between the two? I&#39;m a bit confused, as the svn only has `svn co` to revert the commit. 

### ADDED  
VonC and Charles explained the differences between `git reset` and `git checkout` really well. My current understanding is that `git reset` reverts all of the changes back to a specific commit, whereas `git checkout` more or less prepares for a branch. I found the following two diagrams quite useful in coming to this understanding:

![http://a.imageshack.us/img651/1559/86421927.png][2]
![http://a.imageshack.us/img801/1986/resetr.png][3]

### ADDED 3

From http://think-like-a-git.net/sections/rebase-from-the-ground-up/using-git-cherry-pick-to-simulate-git-rebase.html, checkout and reset can emulate the rebase. 

[![enter image description here][4]][4]

    git checkout bar 
    git reset --hard newbar 
    git branch -d newbar 

[![enter image description here][5]][5]


  [1]: http://i.stack.imgur.com/RPeKg.png
  [2]: http://i.stack.imgur.com/C4BCo.png
  [3]: http://i.stack.imgur.com/Tiv4H.png
  [4]: http://i.stack.imgur.com/EYijy.png
  [5]: http://i.stack.imgur.com/6F3ZK.png

What&#39;s the difference between &quot;git reset&quot; and &quot;git checkout&quot;?

For example, in the following master branch, I need to trash just the commit af5c7bf16e6f04321f966b4231371b21475bc4da, which is the second due to previous rebase:

    commit 60b413512e616997c8b929012cf9ca56bf5c9113
    Author: Luca G. Soave &lt;luca.soave@gmail.com&gt;
    Date:   Tue Apr 12 23:50:15 2011 +0200
    
        add generic config/initializers/omniauth.example.rb
    
    commit af5c7bf16e6f04321f966b4231371b21475bc4da
    Author: Luca G. Soave &lt;luca.soave@gmail.com&gt;
    Date:   Fri Apr 22 00:15:50 2011 +0200
    
        show github user info if logged
    
    commit e6523efada4d75084e81971c4dc2aec621d45530
    Author: Luca G. Soave &lt;luca.soave@gmail.com&gt;
    Date:   Fri Apr 22 17:20:48 2011 +0200
    
        add multiple .container at blueprint layout
    
    commit 414ceffc40ea4ac36ca68e6dd0a9ee97e73dee22
    Author: Luca G. Soave &lt;luca.soave@gmail.com&gt;
    Date:   Thu Apr 21 19:55:57 2011 +0200
    
        add %h1 Fantastic Logo + .right for &#39;Sign in with Github&#39;


I need to mantain 
  
 - the First commit 60b413512e616997c8b929012cf9ca56bf5c9113,
 - the Third commit e6523efada4d75084e81971c4dc2aec621d45530 and 
 - the Last commit 414ceffc40ea4ac36ca68e6dd0a9ee97e73dee22 

&quot;throwing away&quot; just the Second commit **af5c7bf16e6f04321f966b4231371b21475bc4da**

How can I do that?
Thanks in advance 
Luca


I need to pop up and trash away a &quot;middle&quot; commit in my master branch. How can I do it?

We have all heard that one should never rebase published work, that it’s dangerous, etc. However, I have not seen any recipes posted for how to deal with the situation in case a rebase *is* published.

Now, do note that this is only really feasible if the repository is only cloned by a known (and preferably small) group of people, so that whoever pushes the rebase or reset can notify everyone else that they will need to pay attention next time they fetch(!).

One obvious solution that I have seen will work if you have no local commits on `foo` and it gets rebased:

    git fetch
    git checkout foo
    git reset --hard origin/foo

This will simply throw away the local state of `foo` in favour of its history as per the remote repository.

But how does one deal with the situation if one has committed substantial local changes on that branch?

How do I recover/resynchronise after someone pushes a rebase or a reset to a published branch?

I have following working tree state

    $ git status foo/bar.txt
    # On branch master
    # Unmerged paths:
    #   (use &quot;git reset HEAD &lt;file&gt;...&quot; to unstage)
    #   (use &quot;git add/rm &lt;file&gt;...&quot; as appropriate to mark resolution)
    #
    #       deleted by us:      foo/bar.txt
    #
    no changes added to commit (use &quot;git add&quot; and/or &quot;git commit -a&quot;)

File `foo/bar.txt` is there and I want to get it to the &quot;unchanged state&quot; again (similar to &#39;svn revert&#39;):

    $ git checkout HEAD foo/bar.txt
    error: path &#39;foo/bar.txt&#39; is unmerged
    $ git reset HEAD foo/bar.txt
    Unstaged changes after reset:
    M       foo/bar.txt

Now it is getting confusing:

    $ git status foo/bar.txt
    # On branch master
    # Changes to be committed:
    #   (use &quot;git reset HEAD &lt;file&gt;...&quot; to unstage)
    #
    #       new file:   foo/bar.txt
    #
    # Changed but not updated:
    #   (use &quot;git add &lt;file&gt;...&quot; to update what will be committed)
    #   (use &quot;git checkout -- &lt;file&gt;...&quot; to discard changes in working directory)
    #
    #       modified:   foo/bar.txt
    #

The same file in both sections, new *and* modified? What should I do?

Git: can&#39;t undo local changes (error: path ... is unmerged)

How can I undo _every_ change made to my directory after the last commit, including deleting added files, resetting modified files, and adding back deleted files?

Reset all changes after last commit in git

In one of my development branches, I made some changes to my codebase. Before I was able to complete the features I was working on, I had to switch my current branch to master to demo some features. But just using a &quot;git checkout master&quot; preserved the changes I also made in my development branch, thus breaking some of the functionality in master. So what I did was commit the changes on my development branch with a commit message &quot;temporary commit&quot; and then checkout master for the demo.

Now that I&#39;m done with the demo and back to work on my development branch, I would like to remove the &quot;temporary commit&quot; that I made while still preserving the changes I made. Is that possible?

Can I delete a git commit but keep the changes?

After `git reset --hard`, `git status` gives me files within the `Changes not staged for commit:` section.

I&#39;ve also tried `git reset .`, `git checkout -- .` and `git checkout-index -f -a`, to no avail.

So, how can I get rid of those unstaged changes?

This seems to hit only Visual Studio project files. Weird. See this paste: http://pastebin.com/eFZwPn9Z. What is special with those files, is that in .gitattributes I have:

    *.sln        eol=crlf
    *.vcproj     eol=crlf
    *.vcxproj*   eol=crlf

Also, `autocrlf` is set to false in my global `.gitconfig`. Could that be somehow relevant?

Unstaged changes left after git reset --hard

I&#39;m trying to learn Git. I&#39;m confused between 

    git rm --cached file

and

    git reset file

both of the commands seem to take the file from staged to un-staged area. How do the commands differ?



git rm --cached file vs git reset file

I am trying to learn how to restore or rollback files and projects to a prior state, and don&#39;t understand the difference between `git revert`, `checkout`, and `reset`.  Why are there 3 different commands for seemingly the same purpose, and when should someone choose one over the other?


What&#39;s the difference between Git Revert, Checkout and Reset?

Is it possible to undo the changes caused by the following command? If so, how?

    git reset --hard HEAD~1

How can I undo git reset --hard HEAD~1?

I&#39;m trying to learn how to use Git effectively and I&#39;m wondering how I should (good practice/bad practice?) solve the following case:

Say I have the following chain of commits in master:

- Initial commit
- Commit 1
- Commit 2
- Commit 3

Then I realize that what&#39;s done in the last two commits is completely wrong and I need to start from Commit 1 again. Questions:

- How should I do that?
- Can I move Commit 2 and 3 to a separate branch to keep for future reference (say they weren&#39;t that bad after all) and continue working from Commit 1 on master?

All Git Reset Solutions on Gang of Coders

Total of 35 Git Reset Solutions

How do I revert a Git repository to a previous commit?

Why are there two ways to unstage a file in Git?

What is the meaning of git reset --hard origin/master?

How to discard local commits in Git?

How do I move master back several commits in git?

Git, How to reset origin/master to a commit?

How to uncommit my last commit in Git

How to revert uncommitted changes including files and folders?

How do I use 'git reset --hard HEAD' to revert to a previous commit?

How can I move HEAD back to a previous location? (Detached head) & Undo commits

git undo all uncommitted or unsaved changes

How to git reset --hard a subdirectory?

How to undo the last commit in git

Undo “git add <dir>”?

Undo a particular commit in Git that's been pushed to remote repos

Delete commits from a branch in Git

Move existing, uncommitted work to a new branch in Git

How to cancel a local git commit?

"git rm --cached x" vs "git reset head -- x"?

Why git can't do hard/soft resets by path?

What is the `git restore` command and what is the difference between `git restore` and `git reset`?

Git: How to reuse/retain commit messages after 'git reset'?

Undo git reset --hard with uncommitted files in the staging area

What is difference between 'git reset --hard HEAD~1' and 'git reset --soft HEAD~1'?

What's the difference between "git reset" and "git checkout"?

I need to pop up and trash away a "middle" commit in my master branch. How can I do it?

How do I recover/resynchronise after someone pushes a rebase or a reset to a published branch?

Git: can't undo local changes (error: path ... is unmerged)

Reset all changes after last commit in git

Can I delete a git commit but keep the changes?

Unstaged changes left after git reset --hard

git rm --cached file vs git reset file

What's the difference between Git Revert, Checkout and Reset?

How can I undo git reset --hard HEAD~1?

Move commits from master onto a branch using git