What does "refusing to merge unrelated histories" mean?

It means Git found two branches that have no common ancestor commit. In a normal repository, all branches stem from the same initial commit. When Git detects two completely independent commit trees, it refuses to merge them automatically because it cannot determine how to combine them without explicit permission.

Is --allow-unrelated-histories safe to use?

Yes, it is safe. The flag simply tells Git to proceed with the merge despite having no common ancestor. You may get merge conflicts if both histories contain files with the same name, but that is the same as any other merge conflict. Resolve them normally and commit.

Why did this start happening after Git 2.9?

Before Git 2.9, merging unrelated histories was allowed by default. The Git maintainers added this safety check because accidentally merging unrelated repositories could create a confusing history. The --allow-unrelated-histories flag was introduced so you can still do it intentionally.

How do I avoid this error when creating a new repository?

The easiest approach is to create the repository on GitHub first (with a README if you want), clone it locally with "git clone", and then start adding your code. This ensures both local and remote share the same initial commit. Alternatively, initialize locally, make your first commit, then add the remote and push before GitHub creates any files.

Can I use rebase instead of merge to fix this?

Yes. You can run "git fetch origin" followed by "git rebase origin/main" to replay your local commits on top of the remote history. This avoids a merge commit and creates a linear history. However, if both sides have many commits, rebasing can be more complex than a simple merge with --allow-unrelated-histories.

refusing to merge unrelated histories — How to fix this Git error

Git refuses to combine two branches that share no common ancestor. This usually happens when you initialized a repo both locally and on GitHub. Here is how to fix it.

Learn Git step by step

Fatal Error

What this error means

Every Git repository starts with an initial commit. When you merge or pull, Git looks for a common ancestor — a commit that both branches descend from. This is how Git figures out what changed on each side.

When Git says "refusing to merge unrelated histories", it means the two branches have no common ancestor at all. They are two completely independent commit trees that were never connected.

This is a safety measure added in Git 2.9. Without it, Git would silently merge two unrelated projects together, which is almost never what you want by accident. The fix is straightforward: tell Git you know what you're doing with a single flag.

terminal — unrelated histories

$git pull origin main

fatal: refusing to merge unrelated histories

Why it happens

Initializing both locally and on GitHub

You ran git init locally and made a commit. Then you created a new repo on GitHub with a README. Each has its own root commit with no shared history. When you try to git pull, Git sees two unrelated trees.

Merging two separate repositories

Sometimes you want to combine two independent projects into one. You add one repo as a remote to the other and try to merge. Since they were created independently, their histories have no common ancestor and Git refuses the merge.

git init + remote add + pull

A common beginner workflow: you run git init, add files, commit, then run git remote add origin <url> followed by git pull origin main. If the remote already has commits, they are unrelated to yours.

How to fix it

Three approaches depending on your situation: pull with the flag, merge manually, or rebase.

1. Pull with --allow-unrelated-histories

terminal — pull fix

# Allow the merge of two unrelated commit trees

$git pull origin main --allow-unrelated-histories

Merge made by the 'ort' strategy.

README.md | 3 +++

1 file changed, 3 insertions(+)

create mode 100644 README.md

2. Merge and resolve conflicts

terminal — merge fix

# If you are merging another repo as a subdirectory

$git merge other-repo/main --allow-unrelated-histories

Auto-merging README.md

CONFLICT (add/add): Merge conflict in README.md

Automatic merge failed; fix conflicts and then commit.

# Resolve conflicts, then:

$git add .

$git commit -m "Merge unrelated histories"

[main 4f7a8b2] Merge unrelated histories

3. Rebase onto remote

terminal — rebase fix

# Alternative: start fresh with remote as base

$git remote add origin https://github.com/user/repo.git

$git fetch origin

$git rebase origin/main

Successfully rebased and updated refs/heads/main.

# Your local commits are now on top of the remote history

How to prevent it

Clone first, code second

Create your repository on GitHub first (with or without a README), then git clone it to your machine. This guarantees your local and remote repos share the same initial commit, so you'll never see this error.

Push before GitHub adds files

If you prefer starting locally, create the GitHub repo without a README, license, or .gitignore. Then add the remote and push your local commits. Since the remote is empty, there are no unrelated histories to conflict with.

Use git clone for existing repos

Never run git init in a folder and then try to connect it to an existing remote repository. Use git clone <url> instead, which downloads the full history and sets up the remote automatically.

Related commands

git merge

Combine branches and understand merge strategies

git pull

Fetch and integrate changes from a remote repository

git remote

Manage remote repository connections

GitQuest is created by Anaïs (nouvelle fenêtre), web developer and head of education, specializing in tech training and digital accessibility.

FAQ — refusing to merge unrelated histories

Master Git merges with GitQuest

Practice merging, pulling, and resolving conflicts through interactive investigations. No more guessing at flags.

Start learning Git