Latest Git:

git merge --abort

This attempts to reset your working copy to whatever state it was in before the merge. That means that it should restore any uncommitted changes from before the merge, although it cannot always do so reliably. Generally you shouldn't merge with uncommitted changes anyway.

Prior to version 1.7.4:

git reset --merge

This is older syntax but does the same as the above.

Prior to version 1.6.2:

git reset --hard

which removes all uncommitted changes, including the uncommitted merge. Sometimes this behaviour is useful even in newer versions of Git that support the above commands.

Hey — you can totally roll it back.
Run this:

git reset --hard ORIG_HEAD

That takes your branch back to the exact state it was in before the pull. Just make sure you haven’t staged or committed anything important after the pull, because --hard will wipe those changes.

If you had uncommitted work before the pull, then you can use:

git reflog

And manually reset to the commit before the pull. Let me know if you need help finding the right one.

Use git checkout with flag --merge (short version -m):

git checkout --merge FILE

This restores the unresolved state, including all information about parent and merge base, which allows restarting the resolution.

This command can also be used to "undo" automatic merge conflict resolution, if rerere is enabled in your git config. This is especially useful with enabled rerere.autoUpdate after it records incorrect merge conflict resolution and you notice too late.

Found the solution here: http://gitster.livejournal.com/43665.html

Find and temporary tag your merge commit. (merged) Tag the current tip of your feature branch so that you can retry if you mess up. (feature-with-merge) Then the commit just before then is called either merged^1 or merged^2 depending on which direction you ran the merge. ^1 is more likely. The rebase command needs to rewind all commits after the merge and reapply them just before. That's rebase merged --onto merged^1 Which means "rewind to the common ancestor with merged then go to its first parent then replay the rewound changes. Rewinding means that the tip of branch pointer feature moves backwards and abandons commits. But those commits (merge then develop) will still be accessible as ancestors of the tag. So you can undo the rebase with reset --hard feature-with-merge A better-practice for testing with updates from main is to have a feature-testing branch with merges from both branches. This is called "throwaway merging" in the documentation. When you see significant merge conflicts (number or difficulty) that's when you have to consider rebasing the feature branch to include upstream changes. Interactive rebase can also solve your problem because it's a very general "rewind changes and do stuff with them." But rebasing merges is an extra layer of complexity that I wouldn't recommend. The better way to learn rebase -i, and the more common way to use it, is to revise your change history before sharing it. When you're working on something it's fine to make changes in a stream-of-consciousness order, typo the commit messages, try something and need to revert it. Interactive rebase allows you to redo your development changes in a different order or organized differently.

Undoing a Git merge that hasn't been pushed to a remote repository is a common task, especially when you realize that the merge introduced unwanted changes, conflicts that are too complex to resolve, or simply wasn't the right time to integrate the branches. Git provides several methods to revert or undo a merge, depending on the state of your repository at the time you decide to undo the merge. This comprehensive guide will walk you through the various scenarios and methods to undo a Git merge that hasn't been pushed yet, ensuring you can safely and effectively manage your repository's history. Table of Contents Understanding the Merge Scenarios Prerequisites Method 1: Aborting an Ongoing Merge Method 2: Resetting to a Previous Commit After a Completed Merge Method 3: Using git reflog to Locate and Reset to a Previous State Method 4: Reverting a Merge Commit Best Practices and Considerations Example Scenarios Troubleshooting Common Issues Additional Resources Understanding the Merge Scenarios Before diving into the methods, it's crucial to understand the different states your repository might be in after initiating a merge: Merge in Progress (Conflicts Unresolved): You started a merge, encountered conflicts, and haven't resolved them yet. Merge Completed (Commit Made): You successfully completed the merge by resolving conflicts and creating a merge commit. Merge Completed (Fast-Forward): The merge was a fast-forward, meaning no actual merge commit was created because the branch was directly ahead. Merge via Rebase or Other Operations: You used operations like git pull --rebase which involve merging changes in a different manner. Each scenario requires a slightly different approach to undo the merge effectively. Prerequisites Ensure that you have: Git Installed: Verify by running git --version. If not installed, download it from the official Git website. Navigated to Your Repository: Use cd path/to/your/repository to navigate to the Git repository where the merge occurred. Backup Important Changes: Before performing operations that rewrite history or alter commits, consider creating a backup branch to prevent accidental data loss. git branch backup-branch Method 1: Aborting an Ongoing Merge Use Case: You initiated a merge (git merge ) but encountered conflicts and decide you want to cancel the merge process before completing it. Steps: Check the Merge Status: Ensure that a merge is indeed in progress. git status Sample Output: On branch feature-branch You have unmerged paths. (fix conflicts and run "git commit") (use "git merge --abort" to abort the merge) Unmerged paths: both modified: src/app.js Abort the Merge: Use the git merge --abort command to stop the merge process and revert to the state before the merge began. git merge --abort Alternative Command: If git merge --abort doesn't work or isn't available, you can use: git reset --merge Verify the Abortion: After aborting, check the repository status to ensure the merge has been canceled. git status Expected Output: On branch feature-branch Your branch is up to date with 'origin/feature-branch'. nothing to commit, working tree clean

git merge --abort edit: I'm dumb. Reset master to before the merge and force push. This will get you to the status before the merge on the server as well.