A futuristic, glowing tree with multiple branches intricately intertwining, symbolizing the complex nature of rebasing and resolving merge conflicts in Git. The tree is set against a dark background, highlighting its luminescent and high-tech appearance with vibrant colors.

Resolving Merge Conflicts When Rebasing Stacked Branches After a Squash Merge

In modern software development, Git workflows often involve feature development on separate branches, followed by squash merging these branches into the main branch. This method is particularly prevalent when using platforms like GitHub or GitLab. Squash merging helps maintain a clean and concise project history but can lead to challenges, especially when dealing with stacked branches.

In this scenario, consider you have divided your feature work into multiple dependent branches, such as part-1 and part-2, where part-2 depends on part-1. After successfully completing and squash merging part-1 into the main branch, you encounter unexpected and complex merge conflicts when attempting to rebase part-2 onto the main branch.

Here’s a step-by-step guide to resolving these conflicts efficiently:

Step 1: Abort the Current Rebase

First, ensure that any ongoing rebase operation is properly aborted to start afresh:

git rebase --abort

Step 2: Rebase Using the Correct Base

Next, rebase part-2 onto the main branch, but target the rebase starting from your local part-1 branch:

git checkout part-2
git rebase --onto origin/main part-1

By using the command git rebase --onto origin/main part-1, you instruct Git to take the commits from part-2 that are not in part-1 and apply them onto origin/main. This approach prevents the conflicts that arise from Git trying to reapply the part-1 changes, which have already been integrated into the main branch via squash merge.


When you rebase part-2 directly onto the updated main, Git attempts to reapply each commit from part-2, including those from part-1. Since the commits from part-1 have new hashes and possibly different content after being squash merged, Git does not recognize them as identical. This leads to merge conflicts because Git perceives the changes from part-1 as new conflicts with the existing state of the main branch.

Using git rebase --onto origin/main part-1 effectively isolates the commits of part-2 that are genuinely new and not part of the already merged part-1, applying them cleanly onto the updated main branch without the redundant conflicts.

Git Documentation Reference

Here is an excerpt from the official Git documentation on rebase, highlighting the --onto option:

git rebase --onto <newbase> <upstream>

All changes made by commits in the current branch but that are not in <upstream> are saved to a temporary area. (...) The current branch is reset to (...) <newbase> if the --onto option was supplied. This has the exact same effect as git reset --hard <newbase> (...) The commits that were previously saved into the temporary area are then reapplied to the current branch, one by one, in order.


Managing stacked branches in a Git workflow requires careful handling, especially after squash merges. By rebasing with the --onto option, you can streamline the process and avoid unnecessary merge conflicts, maintaining a clean and efficient development process.