Squash my last X commits together using Git

Question

How can I squash my last X commits together into one commit using Git

User · Answer

To do this you can use following git command.

 git rebase -i HEAD~n

n(=4 here) is the number of last commit. Then you got following options,

pick 01d1124 Message....
pick 6340aaa Message....
pick ebfd367 Message....
pick 30e0ccb Message....

Update like below pick one commit and squash the others into the most recent,

p 01d1124 Message....
s 6340aaa Message....
s ebfd367 Message....
s 30e0ccb Message....

For details click on the Link

User · Answer

To squash the last 10 commits into 1 single commit   git reset --soft HEAD 10  amp  amp  git commit -m  squashed commit    If you also want to update the remote branch with the squashed commit   git push -f

User · Answer

How can I squash my last X commits together into one commit using Git    git rebase -i HEAD X   The following content will be shown   pick 1bffc15c My earlier commit pick 474bf0c2 My recent commit          For the commits that you want to squash  replace pick with fixup  so it becomes   pick 1bffc15c My earlier commit fixup 474bf0c2 My recent commit          If it s open in vim  default interface within terminal   then press Esc on your keyboard  type  wq and Enter to save the file   Verify  Check git log

User · Answer

If you are on a remote branch called feature-branch  cloned from a Golden Repository golden repo name   then here s the technique to squash your commits into one    Checkout the golden repo  git checkout golden repo name  Create a new branch from it golden repo  as follows  git checkout -b dev-branch  Squash merge with your local branch that you have already  git merge --squash feature-branch  Commit your changes  this will be the only commit that goes in dev-branch   git commit -m  My feature complete   Push the branch to your local repository  git push origin dev-branch

User · Answer

If you re working with GitLab  you can just click the Squash option in the Merge Request as shown below  The commit message will be the title of the Merge Request

User · Answer

Tried all approaches mention here  But finally my issue resolved by following this link  https   gist github com longtimeago f7055aa4c3bba8a62197   git fetch upstream   git checkout omgpull    git rebase -i upstream master    lt  choose squash for all of your commits  except the first one  gt    lt  Edit the commit message to make sense  and describe all your changes  gt     git push origin omgpull -f

User · Answer

I find a more generic solution is not to specify  N  commits  but rather the branch commit-id you want to squash on top of   This is less error-prone than counting the commits up to a specific commit   just specify the tag directly  or if you really want to count you can specify HEAD N   In my workflow  I start a branch  and my first commit on that branch summarizes the goal  i e  it s usually what I will push as the  final  message for the feature to the public repository    So when I m done  all I want to do is git squash master back to the first message and then I m ready to push   I use the alias   squash    EDITOR          sed -n  s  pick   p       1    sed -i  tmp  2    s  pick f        1            git rebase -i   This will dump the history being squashed before it does so   this gives you a chance to recover by grabbing an old commit ID off the console if you want to revert    Solaris users note it uses the GNU sed -i option  Mac and Linux users should be fine with this

User · Answer

If you use TortoiseGit  you can the function Combine to one commit    Open TortoiseGit context menu Select Show Log Mark the relevant commits in the log view Select Combine to one commit from the context menu     This function automatically executes all necessary single git steps  Unfortunatly only available for Windows

User · Answer

In addition to other excellent answers  I d like to add how git rebase -i always confuses me with the commit order - older to newer one or vice versa  So this is my workflow    git rebase -i HEAD  N    where N is the number of commits I want to join  starting from the most recent one  So git rebase -i HEAD 5 would mean  squash the last 5 commits into a new one   the editor pops up  showing the list of commits I want to merge  Now they are displayed in reverse order  the older commit is on top  Mark as  squash  or  s  all the commits in there except the first older one  it will be used as a starting point  Save and close the editor  the editor pops up again with a default message for the new commit  change it to your needs  save and close  Squash completed    Sources  amp  additional reads   1   2

User · Answer

Just add this bash function to your bash of  zshrc file     Squash last X commits with a Commit message    Usage  squash X  COMMIT MSG    where X  Number of last commits    where COMMIT MSG  New commit msg  function squash         if   -z    1   -o -z    2      then         echo  Usage    squash X COMMIT MSG            echo  X  Number of last commits           echo  COMMIT MSG  New commit msg           return 1     fi      git reset --soft HEAD   1      git add    amp  amp  git ci -m   2    With 100 emoji     git push --force     Then just run  squash X  New Commit Message    And you re done

User · Answer

Procedure 1  1  Identify the commit short hash    git log --pretty oneline --abbrev-commit abcd1234 Update to Fix for issue B cdababcd Fix issue B deab3412 Fix issue A        Here even git log --oneline also can be used to get short hash   2  If you want to squash  merge  last two commit    git rebase -i deab3412    3  This opens up a nano editor for merging  And it looks like below       pick cdababcd Fix issue B pick abcd1234 Update to Fix for issue B        4  Rename the word pick to squash which is present before abcd1234  After rename it should be like below        pick cdababcd Fix issue B squash abcd1234 Update to Fix for issue B        5  Now save and close the nano editor  Press ctrl   o and press Enter to save  And then press ctrl   x to exit the editor   6  Then nano editor again opens for updating comments  if necessary update it   7  Now its squashed successfully  you can verify it by checking logs     git log --pretty oneline --abbrev-commit 1122abcd Fix issue B deab3412 Fix issue A        8  Now push to repo  Note to add   sign before the branch name  This means forced push     git push origin  master   Note   This is based on using git on ubuntu shell  If you are using different os  Windows or Mac  then above commands are same except editor  You might get different editor   Procedure 2   First add the required files for commit   git add  lt files gt     Then commit using --fixup option and the OLDCOMMIT should be on which we need to merge squash  this commit    git commit --fixup OLDCOMMIT   Now this creates a new commit on top of HEAD with fixup1  lt OLDCOMMIT MSG gt     Then execute below command to merge squash  the new commit to the OLDCOMMIT    git rebase --interactive --autosquash OLDCOMMIT    Here   means the previous commit to OLDCOMMIT  This rebase command opens interactive window on a editor  vim or nano  on that we no need to do anything just save and exiting is sufficient  Because the option passed to this will automatically move the latest commit to next to old commit and change the operation to fixup  equivalent to squash   Then rebase continues and finishes   Procedure 3   If need to add new changes to the last commit means --amend can be used with git-commit          git log --pretty oneline --abbrev-commit     cdababcd Fix issue B     deab3412 Fix issue A                git add  lt files gt    New changes       git commit --amend       git log --pretty oneline --abbrev-commit     1d4ab2e1 Fix issue B     deab3412 Fix issue A              Here --amend merges the new changes to last commit cdababcd and generates new commit ID 1d4ab2e1  Conclusion   Advantage of 1st procedure is to squash multiple commits and to reorder  But this procedure will be difficult if we need to merge a fix to very old commit  So the 2nd procedure helps to merge the commit to very old commit easily  And the 3rd procedure is useful in a case to squash a new changes to last commit

User · Answer

What can be really convenient  Find the commit hash you want to squash on top of  say d43e15   Now use  git reset d43e15 git commit -am  new commit name

User · Answer

2020 Simple solution without rebase   git reset --soft HEAD 2  git commit -m  quot new commit message quot  git push -f 2 means the last two commits will be squashed  You can replace it by any number

User · Answer

Use git rebase -i  lt after-this-commit gt  and replace  pick  on the second and subsequent commits with  squash  or  fixup   as described in the manual   In this example   lt after-this-commit gt  is either the SHA1 hash or the relative location from the HEAD of the current branch from which commits are analyzed for the rebase command  For example  if the user wishes to view 5 commits from the current HEAD in the past the command is git rebase -i HEAD 5

User · Answer

Based on this article I found this method easier for my usecase   My  dev  branch was ahead of  origin dev  by 96 commits  so these commits were not pushed to the remote yet    I wanted to squash these commits into one before pushing the change  I prefere to reset the branch to the state of  origin dev   this will leave all changes from the 96 commits unstaged  and then commit the changes at once   git reset origin dev git add --all git commit -m  my commit message

User · Answer

I recommend avoiding git reset when possible -- especially for Git-novices   Unless you really need to automate a process based on a number of commits  there is a less exotic way      Put the to-be-squashed commits on a working branch  if they aren t already  -- use gitk for this Check out the target branch  e g   master   git merge --squash  working branch name  git commit   The commit message will be prepopulated based on the squash

User · Answer

I think the easiest way to do this is by making a new branch based on master and doing a merge --squash of the feature branch   git checkout master git checkout -b feature branch squashed git merge --squash feature branch   Then you have all of the changes ready to commit

User · Answer

In question it could be ambiguous what is meant by  last     for example git log --graph outputs the following  simplified      commit H0     merge        commit B0         commit B1          commit H1         commit H2        Then last commits by time are H0  merge  B0  To squash them you will have to rebase your merged branch on commit H1   The problem is that H0 contains H1 and H2  and generally more commits before merge and after branching  while B0 don t  So you have to manage changes from H0  merge  H1  H2  B0 at least   It s possible to use rebase but in different manner then in others mentioned answers   rebase -i HEAD 2  This will show you choice options  as mentioned in other answers    pick B1 pick B0 pick H0   Put squash instead of pick to H0   pick B1 pick B0 s H0   After save and exit rebase will apply commits in turn after H1  That means that it will ask you to resolve conflicts again  where HEAD will be H1 at first and then accumulating commits as they are applied    After rebase will finish you can choose message for squashed H0 and B0     commit squashed H0 and B0     commit B1      commit H1     commit H2     P S  If you just do some reset to BO    for example  using reset --mixed that is explained in more detail here https   stackoverflow com a 18690845 2405850    git reset --mixed hash of commit B0 git add   git commit -m  some commit message    then you squash into B0 changes of H0  H1  H2  losing completely commits for changes after branching and before merge

User · Answer

If for example  you want to squash the last 3 commits to a single commit in a branch  remote repository  in for example  https   bitbucket org What I did is  git reset --soft HEAD 3 git commit git push origin  lt branch name gt  --force

User · Answer

You can do this fairly easily without git rebase or git merge --squash  In this example  we ll squash the last 3 commits   If you want to write the new commit message from scratch  this suffices   git reset --soft HEAD 3  amp  amp  git commit   If you want to start editing the new commit message with a concatenation of the existing commit messages  i e  similar to what a pick squash squash     squash git rebase -i instruction list would start you with   then you need to extract those messages and pass them to git commit   git reset --soft HEAD 3  amp  amp   git commit --edit -m   git log --format  B --reverse HEAD  HEAD  1      Both of those methods squash the last three commits into a single new commit in the same way  The soft reset just re-points HEAD to the last commit that you do not want to squash  Neither the index nor the working tree are touched by the soft reset  leaving the index in the desired state for your new commit  i e  it already has all the changes from the commits that you are about to    throw away

User · Answer

If you want to squish every commit into a single commit  e g  when releasing a project publicly for the first time   try   git checkout --orphan  lt new-branch gt  git commit

User · Answer

This is super-duper kludgy  but in a kind of cool way  so I ll just toss it into the ring   GIT EDITOR  f     if      basename  1      git-rebase-todo     then sed -i  2   s pick squash    1  else vim  1  fi    f  git rebase -i foo 5 foo   Translation  provide a new  editor  for git which  if the filename to be edited is git-rebase-todo  the interactive rebase prompt  changes all but the first  pick  to  squash   and otherwise spawns vim - so that when you re prompted to edit the squashed commit message  you get vim   And obviously I was squashing the last five commits on branch foo  but you could change that however you like    I d probably do what Mark Longair suggested  though

User · Answer

If you don t care about the commit messages of the in-between commits  you can use   git reset --mixed  lt commit-hash-into-which-you-want-to-squash gt  git commit -a --amend

User · Answer

Based on Chris Johnsen s answer   Add a global  squash  alias from bash   or Git Bash on Windows   git config --global alias squash   f    git reset --soft HEAD   1   amp  amp  git commit --edit -m   git log --format  B --reverse HEAD  HEAD  1       f        or using Windows  Command Prompt   git config --global alias squash   f    git reset --soft HEAD   1   amp  amp  git commit --edit -m    git log --format  B --reverse HEAD  HEAD  1        f     Your    gitconfig should now contain this alias    alias      squash     f    git reset --soft HEAD   1   amp  amp  git commit --edit -m    git log --format  B --reverse HEAD  HEAD  1        f     Usage   git squash N       Which automatically squashes together the last N commits  inclusive   Note  The resultant commit message is a combination of all the squashed commits  in order  If you are unhappy with that  you can always git commit --amend to modify it manually   Or  edit the alias to match your tastes

User · Answer

In the branch you would like to combine the commits on  run   git rebase -i HEAD  n number of commits back to review    example   git rebase -i HEAD 1   This will open the text editor and you must switch the  pick  in front of each commit with  squash  if you would like these commits to be merged together  From documentation   p  pick    use commit  s  squash    use commit  but meld into previous commit  For example  if you are looking to merge all the commits into one  the  pick  is the first commit you made and all future ones  placed below the first  should be set to  squash   If using vim  use  x in insert mode to save and exit the editor   Then to continue the rebase   git rebase --continue   For more on this and other ways to rewrite your commit history see this helpful post

User · Answer

Anomies answer is good  but I felt insecure about this so I decided to add a couple of screenshots   Step 0  git log  See where you are with git log  Most important  find the commit hash of the first commit you don t want to squash  So only the      Step 1  git rebase  Execute git rebase -i  your hash   in my case     git rebase -i 2d23ea524936e612fae1ac63c95b705db44d937d   Step 2  pick   squash what you want  In my case  I want to squash everything on the commit that was first in time  The ordering is from first to last  so exactly the other way as in git log  In my case  I want     Step 3  Adjust message s   If you have picked only one commit and squashed the rest  you can adjust one commit message     That s it  Once you save this   wq   you re done  Have a look at it with git log

User · Answer

git rebase -i HEAD     where the number of   s is X   in this case  squash the two last commits

User · Answer

If you re using GitUp  select the commit you want to merge with its parent and press S  You have to do it once for each commit  but it s much more straightforward than coming up with the correct command line incantation  Especially if it s something you only do once in a while

User · Answer

What about an answer for the question related to a workflow like this    many local commits  mixed with multiple merges FROM master  finally a push to remote  PR and merge TO master by reviewer   Yes  it would be easier for the developer to merge --squash after the PR  but the team thought that would slow down the process     I haven t seen a workflow like that on this page   That may be my eyes   If I understand rebase correctly  multiple merges would require multiple conflict resolutions  I do NOT want even to think about that   So  this seems to work for us    git pull master git checkout -b new-branch git checkout -b new-branch-temp edit and commit a lot locally  merge master regularly git checkout new-branch git merge --squash new-branch-temp     puts all changes in stage git commit  one message to rule them all  git push Reviewer does PR and merges to master

User · Answer

You can use git merge --squash for this  which is slightly more elegant than git rebase -i   Suppose you re on master and you want to squash the last 12 commits into one   WARNING  First make sure you commit your work   check that git status is clean  since git reset --hard will throw away staged and unstaged changes   Then     Reset the current branch to the commit just before the last 12  git reset --hard HEAD 12    HEAD  1  is where the branch was just before the previous command    This command sets the state of the index to be as it would just   after a merge from that commit  git merge --squash HEAD  1     Commit those squashed changes   The commit message will be helpfully   prepopulated with the commit messages of all the squashed commits  git commit   The documentation for git merge describes the --squash option in more detail     Update  the only real advantage of this method over the simpler git reset --soft HEAD 12  amp  amp  git commit suggested by Chris Johnsen in his answer is that you get the commit message prepopulated with every commit message that you re squashing

User · Answer

First I find out the number of commits between my feature branch and current master branch by  git checkout master git rev-list master   --count   Then  I create another branch based out my-feature branch  keep my-feature branch untouched   Lastly  I run  git checkout my-feature git checkout -b my-rebased-feature git checkout master git checkout my-rebased-feature git rebase master git rebase head x -i    fixup pick rewrite git push origin my-rebased-feature -f    force  if my-rebased-feature was ever pushed  otherwise no need for -f flag    make a PR with clean history  delete both my-feature and my-rebased-feature after merge   Hope it helps  thanks

User · Answer

Simple one-liner that always works  given that you are currently on the branch you want to squash  master is the branch it originated from  and the latest commit contains the commit message and author you wish to use   git reset --soft   git merge-base HEAD master   amp  amp  git commit --reuse-message HEAD  1

User · Answer

To avoid having to resolve any merge conflicts when rebasing onto a commit in the same branch  you can use the following command  git rebase -i  lt last commit id before your changes start gt  -s recursive -X ours  To squash all commits into one  when you are prompted to edit commits to be merged  -i flag   update all but first action from pick to squash as recommended in other answers too   Here  we use the merge strategy  -s flag  recursive and strategy option  -X  ours to make sure that the later commits in the history win any merge conflicts    NOTE  Do not confuse this with git rebase -s ours which does something else    Reference  git rebase recursive merge strategy

User · Answer

Thanks to this handy blog post I found that you can use this command to squash the last 3 commits   git rebase -i HEAD 3   This is handy as it works even when you are on a local branch with no tracking information remote repo   The command will open the interactive rebase editor which then allows you to reorder  squash  reword  etc as per normal     Using the interactive rebase editor   The interactive rebase editor shows the last three commits   This constraint was determined by HEAD 3 when running the command git rebase -i HEAD 3   The most recent commit  HEAD  is displayed first on line 1   The lines starting with a   are comments documentation   The documentation displayed is pretty clear   On any given line you can change the command from pick to a command of your choice   I prefer to use the command fixup as this  squashes  the commit s changes into the commit on the line above and discards the commit s message     As the commit on line 1 is HEAD  in most cases you would leave this as pick    You cannot use squash or fixup as there is no other commit to squash the commit into   You may also change the order of the commits  This allows you to squash or fixup commits that are not adjacent chronologically       A practical everyday example  I ve recently committed a new feature   Since then  I have committed two bug fixes   But now I have discovered a bug  or maybe just a spelling error  in the new feature I committed   How annoying   I don t want a new commit polluting my commit history   The first thing I do is fix the mistake and make a new commit with the comment squash this into my new feature    I then run git log or gitk and get the commit SHA of the new feature  in this case 1ff9460    Next  I bring up the interactive rebase editor with git rebase -i 1ff9460    The   after the commit SHA tells the editor to include that commit in the editor   Next  I move the commit containing the fix  fe7f1e0  to underneath the feature commit  and change pick to fixup   When closing the editor  the fix will get squashed into the feature commit and my commit history will look nice and clean   This works well when all the commits are local  but if you try to change any commits already pushed to the remote you can really cause problems for other devs that have checked out the same branch

User · Answer

WARNING   My last X commits  might be ambiguous      MASTER    Fleetwood Mac            Fritz                                  Add Danny  Lindsey     Stevie            Kirwan  Buckingham    Nicks                                                                 ----------       Add Christine                       Perfect      Buckingham                    Nicks                 LA1974----------                                                                                                Bill  lt ------ YOU ARE EDITING HERE   Clinton         CHECKED OUT  CURRENT WORKING DIRECTORY                  In this very abbreviated history of the https   github com fleetwood-mac band-history repository you have opened a pull request to merge in the the Bill Clinton commit into the original  MASTER  Fleetwood Mac commit   You opened a pull request and on GitHub you see this   Four commits    Add Danny Kirwan Add Christine Perfect LA1974 Bill Clinton                         Thinking that nobody would ever care to read the full repository history   There actually is a repository  click the link above   You decide to squash these commits  So you go and run git reset --soft HEAD 4  amp  amp  git commit  Then you git push --force it onto GitHub to clean up your PR   And what happens  You just made single commit that get from Fritz to Bill Clinton  Because you forgot that yesterday you were working on the Buckingham Nicks version of this project  And git log doesn t match what you see on GitHub    MORAL OF THE STORY   Find the exact files you want to get to  and git checkout them Find the exact prior commit you want to keep in history  and git reset --soft that Make a git commit that warps directly from the from to the to

User · Answer

Many answers are based on git rebase command  but in my experience it is somewhat complex and advanced for git-beginners  Let s say you want to squish last 3 commits  Then following are the steps   First check git log  Use git log -1 --oneline to note down the commit-id of the present state  just in case you do something wrong with git reset  Go back 3 commits  Using git reset --soft HEAD 3 you ll go back 3 commits  and sort of forget that you ve had made these three commits earlier  Do a new commit  Now simply do git commit -m  lt NEW SINGLE MESSAGE gt  which will automatically combine the three commits under your message  In case something goes wrong with git reset  you can again return to the original state by git reset --soft  lt ORIGINAL COMMIT gt

[git] Squash my last X commits together using Git

Examples related to git

Examples related to rebase

Examples related to squash

Examples related to git-squash