Skip to main content

Git Rebase

What is Git Rebase?

git rebase is a command in Git that integrates changes from one branch into another. It is an alternative to the git merge command, but instead of creating a new commit that combines the two branches like merge, rebase moves or "replays" the branch onto the base tip of another branch.

The main reason to use git rebase is to maintain a linear project history. When you view a rebased project's history with a command like git log, it appears as if the changes for each feature were added sequentially, even if they were actually developed in parallel.

Here's a basic outline of how to use git rebase:

  1. Standard Rebase: If you have a branch called feature and want to bring it up to date with the main branch, you can check out to the feature branch and then use the command git rebase main. This will replay the changes made in the feature branch onto main.

  2. Interactive Rebase: You can use the interactive rebase feature by adding the -i option to the rebase command, like git rebase -i HEAD~3. This lets you choose what to do with each commit as you rebase them onto the other branch. You can squash commits (combine them into one), remove them, and more.

  3. Abort a Rebase: If something goes wrong during the rebase, you can stop it with the command git rebase --abort.

  4. Continuing a Rebase: If you've resolved a merge conflict after a rebase, you can continue the rebase with the command git rebase --continue.

How Does Git Rebase Work?

Suppose you have two branches, master and feature. You've made several commits on the feature branch while other commits were added to the master branch.

If you want to integrate the master branch's commits into your feature branch, you can use the git rebase command:

git checkout feature
git rebase master

This command replays your feature branch's commits onto the master branch. If there are any conflicts between the branches, Git will pause and allow you to resolve those conflicts before continuing.

Interactive Rebasing with Git

Interactive rebasing is an advanced Git feature that lets you modify commits as they are moved to a new base commit. It is an essential tool for refining a development history before merging features into a main code base. This tutorial explains what interactive rebasing is and how to do it in Git.

What is Interactive Rebasing?

Interactive rebasing allows you to edit previous commit messages, squash together (combine) commits, split commits, and much more. This gives you the opportunity to clean up your commit history before integrating changes with another branch.

How to Do Interactive Rebasing

Suppose you want to interactively rebase the last three commits. You can do this with the git rebase -i HEAD~3 command:

git rebase -i HEAD~3

This command opens an editor that lists the last three commits. Each commit is prefixed with the word "pick". By replacing "pick" with other commands, you can modify each commit. Here are some options:

  • reword: Allows you to change the commit message.
  • edit: Stops at that commit and allows you to edit the files (to split a commit, for example).
  • squash: Combines this commit with the previous one.

After you save and close the file, Git applies the changes you specified.

Git Rebase Best Practices

While Git rebase is a powerful tool, it can be complex and risky if not used correctly. This tutorial aims to provide you with some best practices to keep in mind when using Git rebase.

Don't Rebase Public History

Rebasing rewrites commit history, which is helpful for making history cleaner. However, it can cause problems if you're working with other people. If you rebase commits that have been pushed and shared with others, you'll create inconsistent histories, causing confusion and potential data loss for your collaborators. So, as a rule, don't rebase commits that have been pushed to a public repository.

Use Rebase for Linear History

If you prefer a clean, linear history free of unnecessary merge commits, rebase is a great choice. It lets you integrate changes from one branch to another without creating a new merge commit.

Use Rebase Interactively for Cleanup

Interactive rebase is a great tool for cleaning up your commits before sharing them publicly. You can squash small commits together, split large ones, or edit commit messages to make them more informative.

Understand How Rebase Works

Before using rebase, make sure you fully understand how it works. It can be a complex command, and misuse can lead to significant issues. If you're not sure what you're doing, it's safer to use git merge instead.


Git rebase is a valuable command that can help you maintain a clean and linear project history. It allows you to integrate changes between branches more seamlessly than a merge. Understanding how to use Git rebase will enhance your Git skills and make you a more effective Git user.