How to modify existing, unpushed commits?

7 677

3 102

I wrote the wrong thing in a commit message. Alternatively, I've forgotten to include some files.

How can I change the commit message/files? The commit has not been pushed yet.

Laurie Young

Posted 2008-10-07T15:44:47.920

Reputation: 60 708

868For those somewhat new to git: Laurie's point about having not yet pushed is important. Like rebasing, this is changing the history. If someone has cloned/pulled from your repo between the original and rewritten history then they won't be able to pull after the rewrite (for that branch). – Pat Notz – 2008-10-10T20:12:17.880

Answers

15 017

Amending the most recent commit message

git commit --amend

will open your editor, allowing you to change the commit message of the most recent commit. Additionally, you can set the commit message directly in the command line with:

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

…however, this can make multi-line commit messages or small corrections more cumbersome to enter.

Make sure you don't have any working copy changes staged before doing this or they will get committed too. (Unstaged changes will not get committed.)

Changing the message of a commit that you've already pushed to your remote branch

If you've already pushed your commit up to your remote branch, then you'll need to force push the commit with:

git push <remote> <branch> --force
# Or
git push <remote> <branch> -f

Warning: force-pushing will overwrite the remote branch with the state of your local one. If there are commits on the remote branch that you don't have in your local branch, you will lose those commits.

Warning: be cautious about amending commits that you have already shared with other people. Amending commits essentially rewrites them to have different SHA IDs, which poses a problem if other people have copies of the old commit that you've rewritten. Anyone who has a copy of the old commit will need to synchronize their work with your newly re-written commit, which can sometimes be difficult, so make sure you coordinate with others when attempting to rewrite shared commit history, or just avoid rewriting shared commits altogether.


Use interactive rebase

Another option is to use interactive rebase.
This allows you to edit any message you want to update even if it's not the latest message.

In order to do a git squash, follow these steps:

// X is the number of commits to the last commit you want to be able to edit
git rebase -i HEAD~X

Once you squash your commits - choose the e/r for editing the message

enter image description here

Important note about Interactive rebase

When you use the git rebase -i HEAD~X there can be more than X commits. Git will "collect" all the commits in the last X commits and if there was a merge somewhere in between that range you will see all the commits as well so the outcome will be X+.

Good tip:

If you have to do it for more than a single branch and you might face conflicts when amending the content, set up git rerere and let git resolve those conflicts automatically for you.


Hot-tip

You can also write a small bash function to amend the last git commit message and push it to the remote. Helps me all the time. Here's the function; put it in your .bashrc or similar .zshrc file and reload your shell.

# Amend the last commit message
# Push the changes to remote by force
# USAGE: gamend "Your New Commit Msg"
function gamend() {
    git commit --amend -m "[email protected]"
    git push --force
}

Documentation

EfForEffort

Posted 2008-10-07T15:44:47.920

Reputation: 54 675

111If you've already pushed, just force push again: git push -f origin branchname – hughes – 2012-05-02T14:12:24.877

167@hughes isn't git push -f a bit dangerous if other people are using the same repository? – Armand – 2012-11-08T07:48:41.427

83If you don't want to rewrite the entire commit message, go for git commit --amend -c HEAD. This will open the editor pre-populated with your old commit message, so you can change it. – Sam – 2012-11-14T15:38:10.603

18What @Sam says also seems to work if you just type git commit --amend with nothing else following. – hangtwenty – 2012-12-07T20:37:31.507

7@hughes Don't force push to repositories that other people are using without warning them first!! Otherwise it results in a bizarre conflict when they try to fetch again. If that person doesn't know what he/she is doing, they might resolve the conflict incorrectly and then push that, which would screw up the repository even further. – Mark E. Haase – 2013-05-23T15:05:45.150

17But, don't amend commits that have been shared! – EdwardGarson – 2013-06-19T02:31:17.490

3@guillegr123, no, the proper terminology is, or at least used to be, the "tip" of the branch. – EfForEffort – 2013-06-19T19:55:54.847

12Just a little detail. If you do git commit --amend while there are staged changes (added with git add) they will become part of the amended commit. This is useful to add changes or deletes you forgot to stage (usually I forgot the -A option in the git add command when I'm deleting files) – txulu – 2013-08-01T08:11:42.853

a great answer! and covers the important point of merges which rebase -i wont let you do by default. To use rebase to change the message of a merge commit you must use the preserve option -p – Sam – 2013-09-24T20:57:29.303

244However git commit --amend isnt as powerful as git rebase -i. – Jeffrey Jose – 2010-07-05T08:40:35.240

73@jeffjose, It definitely doesn't need to be. Also, git commit --amend can fix up the (a?) master commit. – strager – 2010-07-14T06:02:30.677

@rjmunro, the link you provided describes the body of the commit message as optional. "If there are any technical details that cannot be expressed in these strict size constraints [of the subject line], put them in the body instead." Sometimes a small change only needs a single line to describe it. – antinome – 2014-09-17T13:12:08.707

@antinome the answer has now been edited to reflect my previous comment (http://stackoverflow.com/revisions/179147/12), so that -m is now shown as a alternative & not the normal way to do things. I'm happy with the new version, so I'll delete my previous comment.

– rjmunro – 2014-09-17T18:28:29.613

1

A link to http://git-scm.com/book/en/Git-Tools-Rewriting-History would be great in the answer.

– onionjake – 2014-10-02T02:31:38.407

there should be 2 sha's. one of the diff, one of the metadata. that way you can move commits seamlessly around... restore commits. verify that changes are identical (same sha = same diff ... even if different people do it ... etc). – Erik Aronesty – 2015-02-27T20:40:03.630

"Make sure you don't have any working copy changes..." should probably be "Make sure you don't have any staged changes.." As per normal rules only staged changes affect the commit. – user2864740 – 2015-04-03T00:49:35.380

1git commit --amend -m "New commit message" does not make entering multi-line comment cumbersome. you should use: git commit --amend -m $'- line 1\nline2' – gogaman – 2015-05-01T21:42:07.627

2

It would be nice if this answer also mentioned editing a commit message that is not the most recent. I.e., it should include this answer.

– wachr – 2015-06-01T22:32:02.107

These will change the hashes fyki. – Santosh Kumar – 2015-07-12T02:19:02.573

if you already pushed to your remote branch it will not work if your have denyNonFastforwards=true in your config git file. you need to change that to false. try the solution in http://stackoverflow.com/questions/10544139/how-to-force-push-a-reset-to-remote-repository

– yehudahs – 2015-11-12T08:05:01.800

I had some other files in the index which I hadn't committed. This command amended my previous commit message, but also added those files to the commit. Now can I amend again to split the commit up how I wanted it? – Ed Randall – 2016-06-03T23:29:06.587

Very good response but you don't talking about the 3th option like "change commit message on previous commit before HEAD which already not push". – darkomen – 2016-08-04T08:27:46.060

If you receive a denying non-fast-forward error using git push -f you need to set receive.denyNonFastForwards false on the server repository. See http://stackoverflow.com/questions/9832348/git-push-rejected-error-failed-to-push-some-refs#9832377

– Soren Stoutner – 2016-10-30T07:55:55.590

what does "e/r" mean? – rubo77 – 2017-03-29T14:54:23.747

1It means choose the "edit" or "reword" option in the rebase. – EfForEffort – 2017-04-07T15:15:39.627

you will lose those commits. I mean at the remote. Right ? – Saiful Azad – 2017-08-30T11:05:50.227

git commit --amend -m "New commit message" allows you to use "#" in your commit messages without altering Git configuration – Fontanka16 – 2017-10-25T09:26:56.417

the GitHub documentation is really helpful on updating the message of a previous commit with interactive rebase

– zok – 2018-01-08T16:30:01.787

For anyone else having trouble editing things using rebase -i, to change from pick to something else type i then hit enter to go into edit mode, then change pick to what ever else, then hit Esc and enter :wq to save and quit out of the editor. Finally, it will bring you to change the commit message, where you will again enter i, change comment, hit Esc, then type :wq – hvaughan3 – 2018-04-04T14:45:37.317

@Armand You can use git push --force-with-lease. It is safer when working on the same repository – Pierre Ferry – 2018-11-21T09:43:32.523

2 433

git commit --amend -m "your new message"

lfx_cool

Posted 2008-10-07T15:44:47.920

Reputation: 24 379

6@DaveEveritt you most likely pushed your commit upstream before trying to fix it. – Thorbjørn Ravn Andersen – 2013-04-25T08:21:20.357

@ThorbjørnRavnAndersen - thanks, that was 2 years ago, these days I've got my git workflow sorted! – Dave Everitt – 2013-04-25T08:41:27.990

11@Kyralessa not true. In bash you can easily compose multiline commit messages by just not closing the quote until you're done (hitting return at the end of each line within the quotes). – hobs – 2013-06-11T21:11:57.947

1Doesn't this command also commit staged changes? – Thomas S. – 2013-10-29T08:47:52.323

24I don't get how an answer that looks a lot like just the main idea of an answer that was written two years ago and also the accepted answer gets so many votes. Strange. (nothing wrong with the answer though) – happy coder – 2014-01-15T05:30:22.240

2@happycoder: Because the question is very popular and the first hit on Google (and many other search engines) for many git-related terms. And people find it useful. – Amal Murali – 2014-05-21T02:36:03.293

4@AmalMurali, well. My point wasn't so much about the popularity of the question, nor the utility of the answer. But this particular answer is not the oldest answer, nor does it offer any further insight into the accepted answer. It appears to be a copy of a section of the accepted answer. That was my point. CHEERS! – happy coder – 2014-05-21T20:16:23.783

@EarlJenkins Yeah, it's a little funny, but I'm glad they do go into depth even for the "simple" questions. – jay_t55 – 2015-01-10T09:04:48.443

Little thing, if you actually did push the commit to a remote before editing, you can "fix" it with git push -f <remote> <branch>, aka force push. It'll overwrite the previous commit. Not the best method as @Dan explained, but there's not much you can do there. – Jay – 2015-07-07T18:31:33.853

@Wade You should avoid using force push on a shared repo at all costs. Doing so pretty much guarantees a conflict for anyone else using this remote. The only legitimate reason I can think to force a history change is to remove highly sensitive data from an unsecured repository (e.g. accidentally committed 'passwords.txt'). In all other cases, use git revert instead. If you must force push, read this first: http://blog.sensible.io/2012/10/09/git-to-force-put-or-not-to-force-push.html

– Dan Bechard – 2015-07-07T18:54:55.140

@Dan I understand that. That's why I said it's not the best method, and pointed to your comment. But if they have already pushed to their upstream remote, there is very little they can do that wouldn't cause conflicts. – Jay – 2015-07-09T15:32:55.080

1

@Wade I disagree with "there is very little they can do that wouldn't cause conflicts." I was responding specifically to your earlier statement "but there's not much you can do there." There is something you can do, that will not cause conflicts. As I suggested, you should use git revert instead of git push -f. Revert will add a new commit that reverses the changes made in the reverted commit(s), rather than modifying history; thereby eliminating conflicts. http://git-scm.com/docs/git-revert

– Dan Bechard – 2015-07-09T17:35:29.217

@Dan Ohh I see what you mean. Yeah that would work. If they were working on their own branch, they'd still have conflicts even with git revert though, no? – Jay – 2015-07-10T16:56:37.853

@Wade git revert won't introduce any conflicts that git commit wouldn't also introduce. It's simply adding a new commit that happens to contain changes which reverse changes made in a previous commit. In most cases, anyone merging your branch will just be doing a fast-forward. – Dan Bechard – 2015-07-10T18:52:33.350

5I did git commit --amend -m "New message", but pushing to Github generated the "Merge the remote changes before pushing again". After pull, commit --amend, and push again, the new message doesn't appear. Instead I have "Merge branch 'master' of github.com:[myrepo]" – Dave Everitt – 2011-10-14T16:58:32.630

2 311

If the commit you want to fix isn’t the most recent one:

  1. git rebase --interactive $parent_of_flawed_commit

    If you want to fix several flawed commits, pass the parent of the oldest one of them.

  2. An editor will come up, with a list of all commits since the one you gave.

    1. Change pick to reword (or on old versions of Git, to edit) in front of any commits you want to fix.
    2. Once you save, Git will replay the listed commits.

  3. For each commit you want to reword, Git will drop you back into your editor. For each commit you want to edit, Git drops you into the shell. If you’re in the shell:

    1. Change the commit in any way you like.
    2. git commit --amend
    3. git rebase --continue

Most of this sequence will be explained to you by the output of the various commands as you go. It’s very easy, you don’t need to memorise it – just remember that git rebase --interactive lets you correct commits no matter how long ago they were.


Note that you will not want to change commits that you have already pushed. Or maybe you do, but in that case you will have to take great care to communicate with everyone who may have pulled your commits and done work on top of them. How do I recover/resynchronise after someone pushes a rebase or a reset to a published branch?

Aristotle Pagaltzis

Posted 2008-10-07T15:44:47.920

Reputation: 84 233

17Use -p (--preserve-merges) if there was a merge after the flawed commit. – ahven – 2012-01-31T14:37:47.973

4Also, $parent_of_flawed_commit means "commit before the one you screwed up" :) – Nick – 2012-10-04T14:44:14.383

38Can one change the message of the first commit (which doesn't have a parent)? – 13ren – 2010-01-21T19:57:18.797

26This is mentioned in one of the other answers but I will put a note of it here. Since git 1.6.6 you can use reword in place of pick to edit the log message. – MitMaro – 2010-05-31T13:27:57.517

@AristotlePagaltzis I'm the only one pushing commits to a remote repository. Can I git push -f to push rewords for commits that have already pushed? – trusktr – 2013-12-01T02:38:53.507

1This worked really well for me in a Git-SVN workflow where one git commit message in a batch of changes was rejected by an SVN pre-commit hook. I was able to reword and then the dcommit worked. – Jimmy Bosse – 2014-05-29T13:32:15.220

Reword doesn't work for me on Windows (even in a MinGW console from SourceTree). Git always tries to open a file "[email protected]". Very unfortunate that Git wasn't built with cross-platform in mind. – AndiDog – 2014-08-09T07:47:43.743

1Bare in mind you will loose all your commit dates. – pingu – 2010-11-21T17:03:22.637

86Incidentally, $parent_of_flawed_commit is equivalent to $flawed_commit^. – Peeja – 2010-11-28T23:26:12.507

The git rebase --continue was not necessary for me, rebase finished already. – sebix – 2015-09-01T15:39:22.687

@13ren You might already found answer, but this might help others (I did not saw reply to your comment). http://stackoverflow.com/questions/2246208/change-first-commit-of-project-with-git

– Lukino – 2015-09-16T20:07:10.180

7@pingu: No, you won't loose any commit dates. – Daniel Rinser – 2011-05-31T19:11:02.330

62Never EVER do this (or rebase in general) if you have already pushed upstream! – Daniel Rinser – 2011-05-31T19:14:04.590

What if I want to edit the very first commit message, i.e the initial commit's message? – Sam Chats – 2017-07-17T18:23:32.697

2Use --root instead of a commit hash. – Aristotle Pagaltzis – 2017-07-17T22:57:39.047

756

To amend the previous commit, make the changes you want and stage those changes, and then run

git commit --amend

This will open a file in your text editor representing your new commit message. It starts out populated with the text from your old commit message. Change the commit message as you want, then save the file and quit your editor to finish.

To amend the previous commit and keep the same log message, run

git commit --amend -C HEAD

To fix the previous commit by removing it entirely, run

git reset --hard HEAD^

If you want to edit more than one commit message, run

git rebase -i HEAD~commit_count

(Replace commit_count with number of commits that you want to edit.) This command launches your editor. Mark the first commit (the one that you want to change) as “edit” instead of “pick”, then save and exit your editor. Make the change you want to commit and then run

git commit --amend
git rebase --continue

Note: You can "Make the change you want" also from the editor opened by git commit --amend

Fatih

Posted 2008-10-07T15:44:47.920

Reputation: 21 109

17git rebase -i HEAD~commit_count will also allow you to change the commit messages of however many commits you choose. Just mark the chosen commits as "reword" instead of "pick". – Joe – 2013-08-21T20:21:59.403

1What if you don't want to rebase? You just want to change an older message? – SuperUberDuper – 2016-04-21T08:56:35.110

git reset --hard annihilates uncommitted changes. Please replace --hard with --soft. – eel ghEEz – 2018-02-28T17:44:56.687

387

As already mentioned, git commit --amend is the way to overwrite the last commit. One note: if you would like to also overwrite the files, the command would be

git commit -a --amend -m "My new commit message"

John

Posted 2008-10-07T15:44:47.920

Reputation: 3 999

1And if you don't want to add everything, you can first do git add file.ext then just git commit --amend – MalcolmOcean – 2015-09-22T05:56:35.777

349

You also can use git filter-branch for that.

git filter-branch -f --msg-filter "sed 's/errror/error/'" $flawed_commit..HEAD

It's not as easy as a trivial git commit --amend, but it's especially useful, if you already have some merges after your erroneous commit message.

Note that this will try to rewrite EVERY commit between HEAD and the flawed commit, so you should choose your msg-filter command very wise ;-)

Mark

Posted 2008-10-07T15:44:47.920

Reputation: 5 487

3Is there a version of this that does not change the commit if the regex doesn't find anything? – sjakubowski – 2013-03-28T20:08:13.590

2AFAIK filter-branch --msg-filter will generate new commits in any case. However, you could check within the msg-filter, if the sed succeeded and use this information when the filter-branch operation ends to reset your tree to refs/original. – Mark – 2013-03-29T16:16:25.443

3@DavidHogue This is only true when using the filter-branch method. The commit IDs following a modified commit do not change if you use the interactive rebase. – Mark – 2013-07-06T19:08:37.223

3@Mark Yes they do, they are required to. Commit ids are dependent on previous commits. If they didn't change, git would be useless. – Miles Rout – 2014-01-11T04:45:27.853

You need $flawed_commit^..HEAD, not $flawed_commit..HEAD. as stated by the man page: «The command will only rewrite the positive refs mentioned in the command line (e.g. if you pass a..b, only b will be rewritten).» – Ángel – 2014-07-29T11:18:49.423

310

I prefer this way.

git commit --amend -c <commit ID>

Otherwise, there will be a new commit with a new commit ID

krevedko

Posted 2008-10-07T15:44:47.920

Reputation: 3 660

6For me, using your command above actually creates a new commit with a new commit ID plus an extra commit saying "merge branch" as a default commit message. – Jan – 2013-03-29T16:27:38.367

40Amending always creates a new commit with a new commit ID. The commit ID is the SHA hash of the contents of the commit, including the commit message and authored/committed timestamps. This is a feature of Git that, barring hash collisions, ensures that two commits with the same ID are exactly the same commit, with exactly the same content, history and so on. – Emil Lundberg – 2013-06-19T09:30:11.540

5Agree with Emil. Additionally, reading the docs - it seems that all "-c" does is tell git which commit's message to use as the default/template for your new commit..Really its already going to do "-c <commit ID>" by default, so no need to specify it. – Gal – 2013-09-29T19:12:37.247

2The -c does a few things. It uses the old message by default, but it also copies authorship information (person and time). -C does the same thing except that it does not ask you to edit the message. – Joseph K. Strauss – 2014-12-28T02:55:53.837

1Like @SantanuDey , it didn't work for me. I got fatal: Option -m cannot be combined with -c/-C/-F/--fixup. – Andrew Grimm – 2015-04-14T05:22:17.403

Using commit id is useful in situations where you want to fix more than one commit. You dont need any other commands, this is short and clear. – webjockey – 2016-12-21T16:43:12.123

307

If you are using the Git GUI tool, there is a button named amend last commit. Click on that button and then it will display your last commit files and message. Just edit that message and you can commit it with new commit message.

Or use this command from a console/terminal:

git commit -a --amend -m "My new commit message"

Akhilraj N S

Posted 2008-10-07T15:44:47.920

Reputation: 6 653

282

You can use Git rebasing. For example, if you want to modify back to commit bbc643cd, run

$ git rebase bbc643cd^ --interactive

In the default editor, modify 'pick' to 'edit' in the line whose commit you want to modify. Make your changes and then stage them with

$ git add <filepattern>

Now you can use

$ git commit --amend

to modify the commit, and after that

$ git rebase --continue

to return back to the previous head commit.

Shoaib Ud-Din

Posted 2008-10-07T15:44:47.920

Reputation: 3 843

1If you want to make sure your change from git commit --amend took affect you can use git show and it will show the new message. – Steve Tauber – 2013-02-19T20:12:44.310

273

  1. If you only want to modify your last commit message, then do:

    git commit --amend
    

    That will drop you into your text exitor and let you change the last commit message.

  2. If you want to change the last 3 commit messages, or any of the commit messages up to that point, supply HEAD~3 to the git rebase -i command:

    git rebase -i HEAD~3
    

Heena Hussain

Posted 2008-10-07T15:44:47.920

Reputation: 3 287

5This earlier answer already says that you can use git commit --amend, and it also says that you can use git rebase -i HEAD~commit_count, all you did was plug in 3 for commit_count. – None – 2014-07-23T12:21:05.050

254

If you have to change an old commit message over multiple branches (i.e., the commit with the erroneous message is present in multiple branches) you might want to use:

git filter-branch -f --msg-filter \
'sed "s/<old message>/<new message>/g"' -- --all

Git will create a temporary directory for rewriting and additionally backup old references in refs/original/.

  • -f will enforce the execution of the operation. This is necessary if the the temporary directory is already present or if there are already references stored under refs/original. If that is not the case, you can drop this flag.

  • -- separates filter-branch options from revision options.

  • --all will make sure, that all branches and tags are rewritten.

Due to the backup of your old references, you can easily go back to the state before executing the command.

Say, you want to recover your master and access it in branch old_master:

git checkout -b old_master refs/original/refs/heads/master

sebers

Posted 2008-10-07T15:44:47.920

Reputation: 2 746

2This answer doesn't address the OP's question, as they're purely interested in fixing a commit they've only just done. I regularly use git commit --amend to fix up comments or add files I forgot to git add, but only ever before I've git pushed. I also use git filter-branch when I want to totally mess with the version history, but the OP doesn't want this, so this answer needs a big health warning - don't try this at home, peeps!! – kbro – 2013-06-29T03:17:38.723

220

Use

git commit --amend

To understand it in detail, an excellent post is 4. Rewriting Git History. It also talks about when not to use git commit --amend.

skin

Posted 2008-10-07T15:44:47.920

Reputation: 2 382

2Is there a good way to fix commit messages already pushed to a public repository? So far I have come to the conclusion that, once pushed, my commit message typos and thinkos have to live forever. – stackunderflow – 2013-06-04T11:32:34.263

2In a word, NOPE! There is no GOOD way to retract something you have pushed. All retractions are BAD to a greater or lesser degree. You need to adopt the discipline of working in a branch in your own private repository, doing multiple commits as you add a bit, test a bit, tweak a bit. Then merge your entire branch into a single commit, write a new commit message describing the overall change, PROOFREAD it, and push. – kbro – 2013-06-29T03:29:44.040

1Just to point out the obvious that one doesn't have to make a single commit when going back from a feature branch. What many people do is rebase on the target branch (to make things look clean) then merge with the option to suppress fast-forwarding. Agree with the main point of being careful before you push up though. – ShawnFumo – 2013-09-11T18:20:34.890

194

Amend

You have a couple of options here. You can do

git commit --amend

as long as it's your last commit.

Interactive rebase

Otherwise if it's not your last commit you can do an interactive rebase,

git rebase -i [branched_from] [hash before commit]

Then inside the interactive rebase you simply add edit to that commit. When it comes up do a git commit --amend and modify the commit message. If you want to roll back before that commit point you could also use git reflog and just delete that commit. Then you just do a git commit again.

wallerjake

Posted 2008-10-07T15:44:47.920

Reputation: 2 991

181

If you are using the Git GUI, you can amend the last commit which hasn't been pushed with:

Commit/Amend Last Commit

gulchrider

Posted 2008-10-07T15:44:47.920

Reputation: 3 972

169

If it's your last commit, just amend the commit:

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

(using the -o (--only) flag to make sure you change only the commit message)


If it's a buried commit, use the awesome interactive rebase:

git rebase -i @~9   # Show the last 9 commits in a text editor

Find the commit you want, change pick to r (reword), and save and close the file. Done!



Miniature vim tutorial (or, how to rebase with only 8 keystrokes 3jcwrEscZZ):

  • Run vimtutor if you have time
  • hjkl correspond to movement keys
  • All commands can be prefixed with a "range", e.g. 3j moves down 3 lines
  • i to enter insert mode — text you type will appear in the file
  • Esc or Ctrlc to exit insert mode and return to "normal" mode
  • u to undo
  • Ctrlr to redo
  • dd, dw, dl to delete a line, word, or letter, respectively
  • cc, cw, cl to change a line, word, or letter, respectively (same as ddi)
  • yy, yw, yl to copy ("yank") a line, word, or letter, respectively
  • p or P to paste after, or before current position, respectively
  • :wEnter to save (write) a file
  • :q!Enter to quit without saving
  • :wqEnter or ZZ to save and quit

If you edit text a lot, then switch to the Dvorak keyboard layout, learn to touch-type, and learn vim. Is it worth the effort? Yes.



ProTip™:   Don't be afraid to experiment with "dangerous" commands that rewrite history* — Git doesn't delete your commits for 90 days by default; you can find them in the reflog:

$ git reset @~3   # go back 3 commits
$ git reflog
c4f708b [email protected]{0}: reset: moving to @~3
2c52489 [email protected]{1}: commit: more changes
4a5246d [email protected]{2}: commit: make important changes
e8571e4 [email protected]{3}: commit: make some changes
... earlier commits ...
$ git reset 2c52489
... and you're back where you started

* Watch out for options like --hard and --force though — they can discard data.
* Also, don't rewrite history on any branches you're collaborating on.

Zaz

Posted 2008-10-07T15:44:47.920

Reputation: 24 860

165

I use the Git GUI as much as I can, and that gives you the option to amend the last commit:

Tick that box

Also, git rebase -i origin/masteris a nice mantra that will always present you with the commits you have done on top of master, and give you the option to amend, delete, reorder or squash. No need to get hold of that hash first.

Havard Graff

Posted 2008-10-07T15:44:47.920

Reputation: 2 474

3How do I get to that screen that you have displayed in your example? – Marwan Marwan مروان مروان – 2014-06-24T20:01:47.640

1It's the lower right portion of the Windows Git Gui. Just select the 'Amend Last Commit' toggle, and it will populate with the most recent commit info. – wbdarby – 2016-01-29T16:51:33.973

135

Wow, so there are a lot of ways to do this.

Yet another way to do this is to delete the last commit, but keep its changes so that you won't lose your work. You can then do another commit with the corrected message. This would look something like this:

git reset --soft HEAD~1
git commit -m 'New and corrected commit message'

I always do this if I forget to add a file or do a change.

Remember to specify --soft instead of --hard, otherwise you lose that commit entirely.

Radu Murzea

Posted 2008-10-07T15:44:47.920

Reputation: 8 158

3This does the exact same thing as git commit --amend except that it is a 2-step process. – Joseph K. Strauss – 2014-12-28T02:58:00.947

1@JosephK.Strauss I believe ammending the commit also keeps original commit author and date information, having the new commiter and date info separately. I'm not sure this approach does that. – everton – 2016-05-07T23:13:23.073

1@EvertonAgner You are correct. --amend will keep the author information, but the question only asks to change the message. – Joseph K. Strauss – 2016-05-09T13:59:34.550

124

If you just want to edit the latest commit use:

git commit --amend

or

git commit --amend -m 'one line message'

But if you want to edit several commits in a row you should use rebasing instead:

git rebase -i <hash of one commit before the wrong commit>

git rebase editing

In a file like the one above write edit/e or one of the other option and hit save and exit.

Now you'll be at the first wrong commit. Make changes in the files, and they'll be automatically staged for you. Type

git commit --amend

save and exit that and type

git rebase --continue 

to move to next selection until finished with all your selections.

Note that these things change all your SHA hashes after that particular commit.

Shubham Chaudhary

Posted 2008-10-07T15:44:47.920

Reputation: 12 713

1git rebase -i <hash of one commit before the wrong commit> works for me. thanks. – Viraths – 2018-04-13T00:57:11.990

123

For anyone looking for a Windows/Mac GUI to help with editing older messages (i.e. not just the latest message), I'd recommend SourceTree. The steps to follow are below.

SourceTree interactive rebase

For commits that haven't yet been pushed to a remote:

  1. Make sure you've committed or stashed all current changes (i.e. so there are no files listed in the "File Status" tab) - it won't work otherwise.
  2. In the "Log / History" tab, right click on the entry with an adjoining line in the graph one below the commit(s) you wish to edit and select "Rebase children of <commit ref> interactively..."
  3. Select the whole row for the commit message you wish to change (i.e. click on the "Message" column).
  4. Click the "Edit Message" button.
  5. Edit the message as desired in the dialog that comes up and then click OK.
  6. Repeat steps 3-4 if there are other commit messages to change.
  7. Click OK: Rebasing will commence. If all is well, the output will end "Completed successfully".

...Or... for commits that have already been pushed:

Follow the steps in this answer, which are similar to above but require a further command to be run from the command line to force-push the branch - read it all and apply the necessary caution!

Steve Chambers

Posted 2008-10-07T15:44:47.920

Reputation: 21 311

121

If you only want to change your last message you should use the --only flag or its shortcut -o with commit --amend:

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

This ensures that you don't accidentally enhance your commit with staged stuff. Of course it's best to have a proper $EDITOR configuration. Then you can leave the -m option out, and git will pre-fill the commit message with the old one. In this way it can be easily edited.

David Ongaro

Posted 2008-10-07T15:44:47.920

Reputation: 2 290

1The "top" answer doesn't answer the question. It just gives a general introduction to git commit --amend. The question was very specific, therefore longer != better. The decisive mentioning of the -o flag would probably be buried in the rest of the information. I'm also not comfortable editing an answer which has so many votes already. – David Ongaro – 2014-07-20T20:51:26.217

2That being said you're free to edit the top answer, since there is a real danger that people are using that as the "correct" answer. It can easily happen to amend your commit with staged stuff -- it happened to me, and it's really annoying when you happen to push that. But still, quantity is no guarantee for correctness. Neither in number of answers nor in number of votes. – David Ongaro – 2014-07-20T20:51:54.240

1

I wouldn't go so far to say that the top answer is "incorrect" and that it "doesn't answer the question". It definitely works and answers the question, you just need to make sure that you don't have staged changes when you try to amend. But I see your point about having to warn people about that. I'll edit it in later if I have time.

– None – 2014-07-21T21:26:20.507

1

To be fair: even though the --only option with --amend is available since git 1.3.0 it didn't work correctly till it was fixed in 1.7.11.3 (ea2d4ed35902ce15959965ab86d80527731a177c). So the right answer back in 2008 would probably have been something like: git stash; git commit --amend; git stash pop.

– David Ongaro – 2014-07-21T23:00:48.763

99

Update your last wrong commit message with new commit message in one line:

git commit --amend -m "your new commit message"

Or, try git reset like below:

# You can reset your head to n number of commit
# NOT a good idea for changing last commit message
# but you can get an idea to split commit into multiple commits
git reset --soft HEAD^

# it will reset you last commit. Now, you
# can re-commit it with new commit message.

Using reset to split commits into smaller commits

git reset can help you to break one commit into multiple commits too:

# reset your head. I am resetting to last commits:
git reset --soft HEAD^
# (you can reset multiple commit by doing HEAD~2(no. of commits)

# Now, reset your head for splitting it to multiple commits
git reset HEAD

# add and commit your files seperately to make multiple commits: e.g
git add app/
git commit -m "add all files in app directory"

git add config/
git commit -m "add all files in config directory"

Here you have successfully broke your last commit into two commits.

przbadu

Posted 2008-10-07T15:44:47.920

Reputation: 3 693

2

If all you want to do is to edit the message of your last commit, using a soft reset for that purpose is over-kill. Just use git commit --amend, exactly like how it says in the top voted answer. Additionally, git reset --soft HEAD^ works identically to the soft reset in this earlier answer, because they both reset back to the first parent commit.

– None – 2014-07-21T23:15:47.547

2I only bother to add git reset in the solution just to give an idea to split one commit message into multiple commit messages. Because, I have faced that problem when, I was starting to use git. Sometimes, this can be really helpfull. :) – przbadu – 2014-07-22T06:29:00.637

82

On this question there are a lot of answers but none of them explains in super detail how to change older commit messages using VIM. I was stuck trying to do this myself, so here I'll write down in detail how I did this especially for people who have no experience in VIM!

I wanted to change my five latest commits that I already pushed to the server. This is quite 'dangerous' cause if someone else already pulled from this you can mess things up by changing the commit messages. However when you’re working on your own little branch and are sure no one pulled it you can change it like this:

Let's say you want to change your five latest commits, then you type this in the terminal:

git rebase -i HEAD~5 *Where 5 is the number of commit messages you want to change. (so if you want to change the 10th to last commit you type in 10)

This command will get you into VIM there you can ‘edit’ your commit history. You’ll see your last 5 commits at the top like this:

pick <commit hash> commit message

Instead of pick you need to write reword. You can do this in VIM by typing in i, that makes you go in to INSERT-mode. (You see that you’re in insert mode by the word INSERT at the bottom) For the commits you want to change type in reword instead of pick

Then you need to save and quit this screen, you do that by first going in to ‘command-mode’ by pressing the esc button. (you can check that you’re in command-mode if the word INSERT at the bottom has disappeared) Then you can type in a command by typing :, the command to save and quit is wq. So if you type in :wq you’re ont he right track.

Then VIM wil go over every commit message you want to reword, here you can actually change the commit messages. You’ll do this by going into INSERT-mode, changing the commit message, going into the command-mode and save and quit. Do this 5 times and you’re out of VIM!

Then, if you already pushed your wrong commits, you need to git push --force to overwrite them. Remember that git push --force is quite a dangerous thing to do, so make sure that no-one pulled from the server since you pushed your wrong commits!

Now you have changed your commit messages!

(As you see I'm not that experienced in VIM so if I used wrong 'lingo' to explain what's happening, feel free to correct me!)

Marijn

Posted 2008-10-07T15:44:47.920

Reputation: 1 131

4&lt;nitpick&gt;There are no "threads" on Stack Overflow, because it's not a discussion forum, there are only "questions", "answers", and "posts".&lt;/nitpick&gt;. Also, not all versions of Vim are the same, not all of them will let you delete characters in insertion mode (makes sense in a way, right?). If you want to always be able to delete characters in Vim, X and x will do that (little x deletes characters in front of the cursor, X will delete behind). If you make mistakes, you can use u repeatedly to undo. Finally, r is shorthand for reword in the interactive rebase editor. – None – 2014-08-07T17:47:10.897

1To change a word in vim is cw typed at its beginning (though the question is not about vim, I agree). – Yaroslav Nikitenko – 2015-12-05T06:25:59.323

76

I have added the alias of reci, recm for recommit (amend) it, now I can do it with git recm or git recm -m .

$ vim ~/.gitconfig

[alias]

    ......
    cm = commit
    reci = commit --amend
    recm = commit --amend
    ......

Chu-Siang Lai

Posted 2008-10-07T15:44:47.920

Reputation: 1 908

76

You can use git-rebase-reword

It is designed to edit any commit (not just last) same way as commit --amend

$ git rebase-reword <commit-or-refname>

It is named after the action on rebase interactive to amend a commit: "reword". See this post and man -section interactive mode-

Examples:

$ git rebase-reword b68f560
$ git rebase-reword HEAD^

albfan

Posted 2008-10-07T15:44:47.920

Reputation: 7 989

5This requires installing an external program. In my opinion, it would be better to learn to use the built-in tools and aliases more effectively. I would type: g c; g rb -i @~9 (commit and rebase), move the new commit to where I want it, change commit to f (fixup), and save. If you wanted something faster than that, you could alias git commit --fixup=&lt;commit&gt;; git rebase -i --autosquash &lt;commit&gt;^ – Zaz – 2015-04-29T15:25:01.987

1https://github.com/qxo/git-rebase-reword both for linux and windows – qxo – 2016-10-29T10:25:14.423

55

I realised that I had pushed a commit with a typo in it. In order to undo, I did the following:

git commit --amend -m "T-1000, advanced prototype"
git push --force

Warning: force pushing your changes will overwrite the remote branch with your local one. Make sure that you aren't going to be overwriting anything that you want to keep. Also be cautious about force pushing an amended (rewritten) commit if anyone else shares the branch with you, because they'll need to rewrite their own history if they have the old copy of the commit that you've just rewritten.

neoneye

Posted 2008-10-07T15:44:47.920

Reputation: 30 107

5Nothing gets ever "overwritten" in git. In this case the branch pointer will be set to your new commit and the old commit will get stale if no references are left to it and it might get cleaned up after a few weeks. (Until then others still can find and reference it, e.g. by looking into the reflog.) – David Ongaro – 2014-09-04T23:47:35.160

49

I like to use the following:

  1. git status
  2. git add --all
  3. git commit -am "message goes here about the change"
  4. git pull <origin master>
  5. git push <origin master>

Kedar Adhikari

Posted 2008-10-07T15:44:47.920

Reputation: 651

43

If you have not pushed the code to your remote branch (GitHub/Bitbucket) you can change the commit message on the command line as below.

 git commit --amend -m "Your new message"

If you're working on a specific branch do this:

git commit --amend -m "BRANCH-NAME: new message"

If you've already pushed the code with the wrong message, and you need to be careful when changing the message. That is, after you change the commit message and try pushing it again, you end up with having issues. To make it smooth, follow these steps.

Please read my entire answer before doing it.

git commit --amend -m "BRANCH-NAME : your new message"

git push -f origin BRANCH-NAME                # Not a best practice. Read below why?

Important note: When you use the force push directly you might end up with code issues that other developers are working on the same branch. So to avoid those conflicts, you need to pull the code from your branch before making the force push:

 git commit --amend -m "BRANCH-NAME : your new message"
 git pull origin BRANCH-NAME
 git push -f origin BRANCH-NAME

This is the best practice when changing the commit message, if it was already pushed.

Prabhakar

Posted 2008-10-07T15:44:47.920

Reputation: 4 122