How do I delete a commit from a branch?

Asked 2023-09-20 20:12:14 View 95,879

How do I delete a commit from my branch history? Should I use git reset --hard HEAD?

  • I think this is not a duplicate of Git undo last commit as it asks how to delete any commit from a branch. I also think non of the answers actually address this question. They all rewind the last commits, not cherry-pick and delete a single commit that may occurred a while ago. - anyone
  • @Chris, the answer with git rebase -i HEAD~10 does address the question, as it does let you arbitrarily pick commits to delete. Git applies the commits in the range you specify one-by-one, ignoring commits you have removed from the log. I used this command today to get rid of the second and third most recent commits to my repo while keeping the top one. I agree that none of the other answers are satisfactory. - anyone
  • @MST yes, I should have said, non of the options in the accepted answer address this question, but you are absolutely right - that command seems to work - anyone
  • I think git reset --soft HEAD~1 is exactly what you need. In such case you will undo commit and save your work. reset --hard will remove commit completely. - anyone
  • command: git log | head -n 1 | git revert - anyone

Answers

Careful: git reset --hard WILL DELETE YOUR WORKING DIRECTORY CHANGES. Be sure to stash any local changes you want to keep before running this command.

Assuming you are sitting on that commit, then this command will wack it...

git reset --hard HEAD~1

The HEAD~1 means the commit before head.

Or, you could look at the output of git log, find the commit id of the commit you want to back up to, and then do this:

git reset --hard <sha1-commit-id>

If you already pushed it, you will need to do a force push to get rid of it...

git push origin HEAD --force

However, if others may have pulled it, then you would be better off starting a new branch. Because when they pull, it will just merge it into their work, and you will get it pushed back up again.

If you already pushed, it may be better to use git revert, to create a "mirror image" commit that will undo the changes. However, both commits will be in the log.


FYI: git reset --hard HEAD is great if you want to get rid of WORK IN PROGRESS. It will reset you back to the most recent commit, and erase all the changes in your working tree and index.


Lastly, if you need to find a commit that you "deleted", it is typically present in git reflog unless you have garbage collected your repository.

Answered   2023-09-20 20:12:14

  • HEAD~1 or just HEAD^. If you pushed, you should use git revert instead. - anyone
  • Obviously you can also use HEAD~n to "go back" n commits from your head. Maybe from this point you can interpreted ... --hard HEAD also as HEAD~0 => deleting work in progress. - anyone
  • @beamrider9 imho git rebase is almost always the better way to delete commits (as described in Greg Hewgill's answer) -- not least because rebase does in fact include a big warning that you will be deleting stuff 4realz. - anyone
  • this doesn't delete changes from the commit tree though. The OP asked for an already made commit. If you reset --hard, and check the log --oneline --all, the commits still remain in the tree. How do we delete these commits from tree? Thanks. - anyone
  • use reset --soft to delete local commit WITHOUT reverting work in progress! - anyone

If you have not yet pushed the commit anywhere, you can use git rebase -i to remove that commit. First, find out how far back that commit is (approximately). Then do:

git rebase -i HEAD~N

The ~N means rebase the last N commits (N must be a number, for example HEAD~10). Then, you can edit the file that Git presents to you to delete the offending commit. On saving that file, Git will then rewrite all the following commits as if the one you deleted didn't exist.

The Git Book has a good section on rebasing with pictures and examples.

Be careful with this though, because if you change something that you have pushed elsewhere, another approach will be needed unless you are planning to do a force push.

Answered   2023-09-20 20:12:14

  • Note: If you happen to have any --no-ff merges in that last batch of commits, rebase will butcher them :( This is mentioned under -p on this page. The problem is, if you replace -i with -p, you no longer get that pop up with the choices for "edit this commit, sqush that one", etc etc. Anyone know the solution? - anyone
  • What if you have pushed it? (just me using the remote repo) - anyone
  • @Costa you can use push -f to force the push and replace the remote branch with your local one. If it's just your own remote repo, no problem. The trouble starts if somebody else has fetched in the meantime. - anyone
  • I added and committed a data file that was too big for GitHub (yeah, it probably shouldn't be in the source repo anyway; Oh well). When I tried to push, GitHub refused because of the too-large file. All I wanted to do was undo this one commit, while saving a few other unrelated commits that followed. The git rebase -i HEAD~5 command was exactly what I needed to completely remove this commit from my local repo! Thanks! - anyone
  • @dumbledad: With rebase -i, the changes corresponding to the deleted commit are not preserved. - anyone

Another possibility is one of my personal favorite commands:

git rebase -i <commit>~1

This will start the rebase in interactive mode -i at the point just before the commit you want to whack. The editor will start up listing all of the commits since then. Delete the line containing the commit you want to obliterate and save the file. Rebase will do the rest of the work, deleting only that commit, and replaying all of the others back into the log.

Answered   2023-09-20 20:12:14

  • thx, btw if you run into any issues (like empty commits) you can use git rebase --continue - anyone
  • Even easier: git rebase -i HEAD~1 - anyone
  • Wowzers. git rebase -i HEAD~1 really cleaned the repo up a lot! It's hard to tell exactly what it did, but the whole thing looks a lot neater. A little alarming, actually. - anyone
  • I think it's worth noting that the commit is not obliterated, merely removed from the list. If you mess up, you can get the commit back using the reflog. - anyone
  • Is deleting the line the same as d/drop? - anyone

I'm appending this answer because I don't see why anyone who has just tried to commit work would want to delete all that work because of some mistake using Git!

If you want to keep your work and just 'undo' that commit command (you caught before pushing to repo):

git reset --soft HEAD~1

Do not use the --hard flag unless you want to destroy your work in progress since the last commit.

Answered   2023-09-20 20:12:14

  • Here's an example of why: you do a small piece of work on a development server that you commit. Then it turns out that that server doesn't have outgoing HTTPS access, so you can't push the commit anywhere. Easiest to just pretend it never happened, and redo the patch from your local machine. - anyone
  • @KarthikBose there would always be the reflog. even after git reset --hard HEAD~1 your previous latest commit would be available via reflog (until you expire it); see also here: gitready.com/intermediate/2009/02/09/… - anyone
  • Thanks. This answer should be ranked higher or included in the accepted answer. Deleting a commit != reverting a commit. - anyone
  • @RandolphCarter: you will still lose any uncommitted changes though. - anyone
  • @Rob, one example is when you accidentally commit a file that contains a secret (e.g. a password) that should never be in source control. The local commit must be destroyed, not just undone, so it will never get pushed to the server. - anyone

Removing an entire commit

git rebase -p --onto SHA^ SHA

Obviously replace "SHA" with the reference you want to get rid of. The "^" in that command is literal.

http://sethrobertson.github.io/GitFixUm/fixup.html#change_deep

Answered   2023-09-20 20:12:14

  • -p, --preserve-merges Recreate merge commits instead of flattening the history by replaying commits a merge commit introduces. Merge conflict resolutions or manual amendments to merge commits are not preserved. - anyone
  • It says, "replace SHA with the reference you want to get rid of" but the line has SHA in there twice. Here is what I did. git rebase -p --onto 5ca8832c120^ 5ca8832c120 But nothing changed. Am I supposed to use the same SHA twice? If not, then which is the SHA for the commit to be removed and what is the other SHA supposed to be? - anyone
  • to be specific, this method removes ENTIRE commit, including files (not desired in my case) - anyone
  • @Rubicksman ^ must be escaped (^^) on windows (cmd window) - stackoverflow.com/questions/1955985/… - anyone
  • -p [DEPRECATED: use --rebase-merges instead] - anyone

Say we want to remove commits 2 & 4 from the repo. (Higher the the number newer the commit; 0 is the oldest commit and 4 is the latest commit)

commit 0 : b3d92c5
commit 1 : 2c6a45b
commit 2 : <any_hash>
commit 3 : 77b9b82
commit 4 : <any_hash>

Note: You need to have admin rights over the repo since you are using --hard and -f.

  • git checkout b3d92c5 Checkout the last usable commit.
  • git checkout -b repair Create a new branch to work on.
  • git cherry-pick 77b9b82 Run through commit 3.
  • git cherry-pick 2c6a45b Run through commit 1.
  • git checkout master Checkout master.
  • git reset --hard b3d92c5 Reset master to last usable commit.
  • git merge repair Merge our new branch onto master.
  • git push -f origin master Push master to the remote repo.

Answered   2023-09-20 20:12:14

  • last step should be git push -f origin master there is no option --hard - anyone
  • I guess commit 0 is older than commit 1. Please could you tell me why first run through commit 3 (by cherry-pick) and then by commit 1? After checkout of b3d92cd (commit 0) I would expect cherry-pick commit 1, then commit 3. Thanks. - anyone
  • @JarekC I think the top-most commit is the newest commit here, unless I'm seeing something wrong... - anyone
  • This is mostly right but kind of wrong. I just followed this process and had to tweak it a bit. Clarification: commit 0 is the newest commit, commit 4 is the oldest. Start by checking out commit 5, just before the commit that you don't want. Then cherry-pick commit 3, then cherry-pick commit 1, then do it for commit 0. Then checkout master and reset it to commit 5 and follow the rest of the steps. - anyone
  • Good thorough and safe approach. Managing the changes on a separate branch means you can even do interactive rebasing on the repair branch and combine commits before merging back in to master. The only comment I have is that you can consolidate the first two steps: git checkout -b repair b3d92c5 - anyone
git rebase -i HEAD~2

Here '2' is the number of commits you want to rebase.

'git rebase -i HEAD`

if you want to rebase all the commits.

Then you will be able to choose one of these options.

p, pick = use commit

r, reword = use commit, but edit the commit message
e, edit = use commit, but stop for amending
s, squash = use commit, but meld into previous commit
f, fixup = like "squash", but discard this commit's log message
x, exec = run command (the rest of the line) using shell
d, drop = remove commit

These lines can be re-ordered; they are executed from top to bottom. If you remove a line here THAT COMMIT WILL BE LOST. However, if you remove everything, the rebase will be aborted. Note that empty commits are commented out

You can simply remove that commit using option "d" or Removing a line that has your commit.

Answered   2023-09-20 20:12:14

  • In the latest git version there is no more option d. You need just remove lines with commits from rebase to delete them. - anyone

#[Quick Answer]

You have many alternatives, for example:

  • Alternative 1:

     git rebase -i <YourCommitId>~1
    

    Change YourCommitId for the number of the commit which you want to revert back to.

  • Alternative 2:

     git reset --hard YourCommitId
     git push <origin> <branch> --force
    

    Change YourCommitId for the number of the commit which you want to revert back to.

    I don't recommend this option because you may lose your in progress work.

  • Alternative 3:

     git reset --soft HEAD~1
    

    You can keep your work and only undo the commit.

Answered   2023-09-20 20:12:14

  • git reset --soft HEAD~1 worked perfectly for me. Makes sure I don't lost to changes from that commit. Thank you for your clear answer. - anyone

If you didn't publish changes, to remove latest commit, you can do

$ git reset --hard HEAD^

(note that this would also remove all uncommitted changes; use with care).

If you already published to-be-deleted commit, use git revert

$ git revert HEAD

Answered   2023-09-20 20:12:14

  • That didn't work. When I git log, everything is still there, no matter why I do it just adds more commits. I wanna clean up the history. - anyone
  • @Costa: What didn't work (i.e. which version did you use), and how did you git log? - anyone
  • I've tried almost everything on this Q&A. (I tried git revert HEAD, most recently) My git log: tree = log --all --graph --format=format:'%C(bold blue)%h%C(reset) %C(dim black)%s%C(reset)%C(bold red)%d%C(reset) %C(green)by %an, %ar%C(reset)' - anyone
  • @Costa: Note that with first version (using git reset --hard HEAD^) you "remove" commit only from current branch (actually move branch pointer), if there was some other branch this commit was on it would still be there. "Removing" commit with git reset just moves back branch pointer, making commit dangling and available for pruning... if not referenced by other ref (other branch, remote-tracking branch, or tag). Or did you use git revert HEAD? - anyone
  • I just want to delete the commits (like as if they never existed). I went off on some weird coding adventure, with several new commits, and it all ended up being trash. How can I just erase those from my git log? - anyone

Forcefully Change History

Assuming you don't just want to delete the last commit, but you want to delete specific commits of the last n commits, go with:

git rebase -i HEAD~<number of commits to go back>, so git rebase -i HEAD~5 if you want to see the last five commits.

Then in the text editor change the word pick to drop next to every commit you would like to remove. Save and quit the editor. Voila!

Additively Change History

Try git revert <commit hash>. Revert will create a new commit that undoes the specified commit.

Answered   2023-09-20 20:12:14

  • drop keyword is not defined. To delete a commit just remove the whole line. - anyone
  • For me drop was defined as a keyword, but doing a drop didn't seem to remove the commit from the history. Removing the line from the interactive rebase however did. - anyone
  • I deleted the line as suggested in several places: it didn't do anything. Replacing the word pick with drop did delete the commit. Note: the instructions are in the remarked-out section in the bottom portion of the text editor's contents. Using git version 2.24.3 (Apple Git-128) - anyone
git reset --hard commitId

git push <origin> <branch> --force

PS: CommitId refers the one which you want to revert back to

Answered   2023-09-20 20:12:14

  • git push --force <origin> <branchName>. as without mentioning branch name it might change all file on remote. - anyone

If you want to fix up your latest commit, you can undo the commit, and unstage the files in it, by doing:

git reset HEAD~1

This will return your repository to its state before the git add commands that staged the files. Your changes will be in your working directory. HEAD~1 refers to the commit below the current tip of the branch.

If you want to uncommit N commits, but keep the code changes in your working directory:

git reset HEAD~N

If you want to get rid of your latest commit, and do not want to keep the code changes, you can do a "hard" reset.

git reset --hard HEAD~1

Likewise, if you want to discard the last N commits, and do not want to keep the code changes:

git reset --hard HEAD~N

Answered   2023-09-20 20:12:14

  • I tried this and I got my latest commit removed but now when I push to the remote repository it says I have to pull before push. So I pulled and then pushed but when I pulled I again got the commit that I just removed because I pushed it before to remote. What should I do now? - anyone

If you want to delete the commit you are currently on but don't want to delete the data-

git reset --soft HEAD~1

If you want to delete the commit you are currently on and want to delete the related data-

git reset --hard HEAD~1

PS: these commands will only delete the local commits.

Answered   2023-09-20 20:12:14

To delete in local branch, use

git reset --hard HEAD~1

To delete in a remote branch, use

git push origin HEAD --force

Answered   2023-09-20 20:12:14

Source: https://gist.github.com/sagarjethi/c07723b2f4fa74ad8bdf229166cf79d8

Delete the last commit

For example your last commit

git push origin +aa61ab32^:master

Now you want to delete this commit then an Easy way to do this following

Steps

  1. First reset the branch to the parent of the current commit

  2. Force-push it to the remote.

git reset HEAD^ --hard

git push origin -f

For particular commit, you want to reset is following

git reset bb676878^ --hard

git push origin -f

Answered   2023-09-20 20:12:14

If you're an IntelliJ user, the interface is simply awesome. With a single click, you can see the effect immediately at the same time. Shortcut to this place: Cmd + 9 on MacOS.

enter image description here

Answered   2023-09-20 20:12:14

  • This question isn't about intelliJ, but about Git itself. - anyone
  • if you're using intellij this is the fastest and easiest way, but remember that you'll have to force push because you've changed the git history - anyone

Here I just post one clear pipeline to do so

Step1: Use git log to get the commit ID.

git log

enter image description here

Step2: Use git reset to go back to the former version:

git reset --hard <your commit id>

Answered   2023-09-20 20:12:14

  • git log origin/master.. to get unpushed commit. git reset --hard <sha1-commit-id> to sit on the commit, get reset --hard HEAD~1 to delete the commit. - anyone

All the commands above restore the state of your work tree and index as they were before making the commit, but do not restore the state of the repository. If you look at it, the "removed" commit is not actually removed, it is simply not the one on the tip of the current branch.

I think that there are no means to remove a commit with porcelain commands. The only way is to remove it from the log and reflog and then to execute a git prune --expire -now.

Answered   2023-09-20 20:12:14

  • The order in which answers are shown on StackOverflow is not fixed. Please do not refer to “All the commands above”. Make your own answer self-contained. - anyone
  • This answer isn't entirely correct. git prune is actually one of the "porcelain" commands. Also, it is rare that you would want to completely clear out your reflog (one use case is to remove sensitive info from your repo, but like I said, that's a rare use case). More often than not, you'll want to keep old commits around in the reflog, in case you need to recover data. See Pro Git: 9.7 Git Internals - Maintenance and Data Recovery. - anyone

If you want to keep the history, showing the commit and the revert, you should use:

git revert GIT_COMMIT_HASH

enter the message explaining why are you reverting and then:

git push  

When you issue git log you'll see both the "wrong" commit and revert log messages.

Answered   2023-09-20 20:12:14

  • Yes, but the OP was clear that that's not what they want. - anyone

Here's another way to do this:

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". I think the command line is:

git reset --hard COMMIT_ID

Since you just checked out your branch from remote, you're not going to have any local changes to worry about losing. But this would lose them if you did.

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.

Answered   2023-09-20 20:12:14

The mistake:

I git rebase -i --root'ed my branch, ignorantly thinking I could reword the first commit differing from the master (the GitHub for Windows default view is the comparison to master, hiding it's entirety).

I grew a Silicon Valley beard while 900+ commits loaded themselves into Sublime. Exiting with no changes, I charged my battery then proceeded to shave, as all 900+ individual commits nonchalantly rebased - resetting their commit times to now.

Determined to beat Git and preserve the original times, I deleted this local repository and re-cloned from the remote.

Now it had re-added a most recent unneeded commit to master I wished to remove, so proceeded like so.

Exhausting the options:

I didn't wish to git revert - it would create an additional commit, giving Git the upper hand.

git reset --hard HEAD did nothing, after checking the reflog, the last and only HEAD was the clone - Git wins.

To get the most recent SHA, I checked the remote repository on github.com - minor win.

After thinking git reset --hard <SHA> had worked, I updated another branch to master and 1... 2... poof! the commit was back - Git wins.

Checking back out to master, time to try git rebase -i <SHA>, then remove the line... to no avail, sad to say. "If you remove a line here THAT COMMIT WILL BE LOST". Ah...glossed over new feature troll the n00b in the 2.8.3 release notes.

The solution:

git rebase -i <SHA> then d, drop = remove commit.

To verify, I checked out to another branch, and voila - no hiding commit to fetch/pull from the master.

https://twitter.com/holman/status/706006896273063936

Good day to you.

Answered   2023-09-20 20:12:14

If you just messed up your last commit (wrong message, forgot to add some changes) and want to fix it before pushing it to a public repo why not use:

git commit --amend -m "New message here"

If you have newly staged changes they'll be combined with the last commit (that you're trying to get rid of) and will replace that commit.

Of course if you amend a commit after you've pushed it, you're rewriting history so if you do that be sure to understand the implications.

You can also pass the '--no-edit' option instead of '-m' if you would prefer to use the previous commit's message.

Docs: http://git-scm.com/docs/git-commit.html

Answered   2023-09-20 20:12:14

  • That's not what OP is asking for. - anyone

If you've already pushed, first find the commit you want to be at HEAD ($GIT_COMMIT_HASH_HERE), then run the following:

git reset --hard $GIT_COMMIT_HASH_HERE
git push origin HEAD --force

Then each place the repo has been cloned, run:

git reset --hard origin/master

Answered   2023-09-20 20:12:14

What I do usually when I commit and push (if anyone pushed his commit this solve the problem):

git reset --hard HEAD~1

git push -f origin

hope this help

Answered   2023-09-20 20:12:14

git reset --hard HEAD~1
You will be now at previous head. Pull the branch. Push new code. Commit will be removed from git

Answered   2023-09-20 20:12:14

  • Unless you have already pushed the changes. In that case hard reset will not clean up your remote. In that case rebase is the good option - anyone

Reset on local branch

git reset --hard HEAD~<Number of commit> So git reset --hard HEAD~3

Force push to origin

git push -f origin

Answered   2023-09-20 20:12:14

I have already pushed. Need to return some commits back remotly. Have tried many variations, but only this from Justin via git bush is working fine for me:

git reset --hard $GIT_COMMIT_HASH_HERE
git push origin HEAD --force

Answered   2023-09-20 20:12:14

// display git commit log    
$ git log --pretty=oneline --abbrev-commit

// show last two commit and open in your default editor
// then delete second commit line and save it
$ git rebase -i HEAD~2

Reference: How to delete a commit in git, local and remote

Answered   2023-09-20 20:12:14

Take backup of your code in to temp folder. Following command will reset same as server.

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

If you want to keep your changes , and remove recent commits

git reset --soft HEAD^
git pull

Answered   2023-09-20 20:12:14

delete local commit

As you can see on above image i want to delete revert"test change 2" commit(SHA1 ID: 015b5220c50e3dfbb1063f23789d92ae1d3481a2(you can get SHA1 ID by using gitk command in git bash)).

For that i can use(all below command work on local only. you need to push after delete):

  1. git reset --hard 515b5220c50e3dfbb1063f23789d92ae1d3481a2 //it back-up you to that commit (SHA1 ID of test change 4 commit is 515b5220c50e3dfbb1063f23789d92ae1d3481a2)
  2. git reset --hard HEAD~1 // it back-up you before one commit.
  3. git reset --hard HEAD^ // To remove the last commit from git

after delete:

after delete commit

Answered   2023-09-20 20:12:14