Git’s rebase is a powerful Git command that allows developers to reapply changes from one branch onto another. It is a way to modify the commit history of a branch, allowing you to change the order, content, or message of your commits. In this article, we’ll dive into the details of how the rebase command works, why you’d want to use it, and provide some examples to help you get started.

Why use Rebase?

git rebase can be used to accomplish a variety of tasks, but its primary purpose is to integrate changes from one branch into another. This is typically used when you have a feature branch that you want to merge into your main branch (e.g. master), but you want to ensure that the changes are cleanly applied on top of the current state of the main branch.

One benefit of using git rebase over another command, like git merge, is that it creates a linear commit history, rather than a branch and merge history. This can make it easier to understand the project’s history and troubleshoot issues. Additionally, rebase can help to reduce the number of merge conflicts that occur when you eventually merge your feature branch into the main branch.

Example Usage of Rebase

To better understand how git rebase works, let’s walk through a simple example. Imagine you are working on a feature branch called new-feature and want to integrate it into the master branch. To do this, you would first switch to the master branch using the following command:

$ git checkout master

Next, you would run the following command to start the rebase process:

$ git rebase new-feature

This tells Git to take all the changes that exist in the new-feature branch and apply them on top of the current master branch. If there are any conflicts between the two branches, Git will prompt you to resolve them manually.

Once the rebase is complete, you should have a linear commit history on the master branch, with all the changes from new-feature cleanly applied on top of the current state of master.

Options for the rebase Command

Git’s rebase has quite a few useful options that can be used to customize its behavior. Here are just a few examples:

--onto: Allows you to rebase a specific range of commits onto a different branch. For example, you might use git rebase --onto new-base old-base feature-branch to rebase all commits from feature-branch that come after old-base and before new-base onto a new branch.
--interactive or -i: Launches an interactive rebase session, allowing you to manually edit, reorder, or delete commits as part of the rebase process.
--continue: Continues the rebase after a merge conflict is resolved.
--abort: Stops an in-progress rebase and restores the branch to its original state.
--skip: Skip the current patch.
--autostash: Automatically stashes any uncommitted changes when the operation starts, and then reapplies them after rebase is done.

You can view all of the available options by running the git help rebase command to show the documentation.


In conclusion, git rebase is a powerful tool that allows developers to cleanly integrate changes from one branch into another while maintaining a linear commit history.

By default, Git uses the “fast-forward” merge strategy to integrate changes, but rebase provides a more flexible alternative that can help to reduce merge conflicts and provide a cleaner history.

With the examples and options covered in this article, you should be well on your way to mastering git rebase and using it to streamline your development workflow.