Easy Merge Conflict — readable Unity scene & prefab merges

See it in action

The same conflict — raw Git vs. Easy Merge Conflict

One real Addressables .asset conflict, two ways. On the left, exactly what Git leaves in your file. On the right, the same six clashes resolved as readable Ours/Theirs choices.

Raw conflict markers in your file

Raw Git merge conflict markers in an Addressables .asset file: overlapping <<<<<<< OURS, =======, >>>>>>> THEIRS blocks mixing m_Address, m_SerializedLabels and m_GUID lines.

Easy Merge Conflict — 6 / 6 resolved

Easy Merge Conflict window showing the same Addressables AssetGroup conflict as a clean list — FlameSword vs IceSword, epic vs legendary, rare vs uncommon — each with an Ours/Theirs pick.

The same structural merge handles whole scenes & prefabs — resolved by GameObject, with a reconstructed Hierarchy of the merged result.

01_Battle.unity — Player conflict resolved, Light & Camera kept automatically

Easy Merge Conflict resolving 01_Battle.unity: a Hierarchy of Player, Light (added by ours) and Camera (added by theirs); Player's Transform m_LocalPosition shown as Ours x5 vs Theirs x9.

One scene, both sides merged. The clashing m_LocalPosition on Player is a side-by-side pick, while the Light only ours added and the Camera only theirs added are kept automatically — and the reconstructed Hierarchy shows exactly what the merged scene will contain.

The difference

From an unreadable wall of IDs → a decision you can make

What Git shows you

<<<<<<< HEAD m_LocalPosition: {x: 9, y: 0, z: 2} m_Children: - {fileID: 1980456} ======= m_LocalPosition: {x: 5, y: 1, z: 0} m_Children: - {fileID: 1980456} - {fileID: 7740921} >>>>>>> feature/enemy m_Component: - component: {fileID: 4001…} …which GameObject is this even?

What Easy Merge Conflict shows you

⚠

Player › Transform modified

m_LocalPosition

ours: x 9 · y 0 · z 2 theirs: x 5 · y 1 · z 0

● Ours○ Theirs

＋

Player › Transform · m_Children auto-merged

Grunt › Transform (added by theirs — kept automatically)

Pick a side per object, click Apply & Stage — it writes the merged file and runs git add. Non-conflicting changes from both sides are merged for you; you only decide what truly clashes.

How it works

It reads the clean versions, not the markers

Instead of parsing the corrupted <<<<<<< markers in your working copy, it asks Git for the three clean versions of the file — base, ours, theirs — and diffs them structurally, by object, property, list element and field.

1 · Hit a conflict

Merge, rebase, cherry-pick or revert that touches a Unity YAML asset or a .meta file.

2 · Open the window

Tools ▸ Easy Merge Conflict lists every conflicted asset with readable names and a per-file count.

3 · Decide & stage

Pick Ours/Theirs per conflict, then Apply & Stage. Finish the merge (commit) in your Git client.

What you get

Built to stop the data loss

🔤

Readable conflicts

Every fileID and guid resolves to a real GameObject, component or asset name — with type icons and thumbnails.

🧩

Per-element list merge

When two people each add a different child, component, material property or Addressable entry to the same object, both are kept — the data loss that makes default scene merge so risky, gone.

🪪

.meta & GUID conflictsnew

Importer settings merge per field. On a GUID clash you pick a side and references to the other GUID are repointed across the project — so nothing turns into a “Missing” reference.

🔁

Rebase-aware

Git flips “ours”/“theirs” during a rebase. The tool detects rebase / cherry-pick / revert and relabels the buttons so you never throw away your own commit by reflex.

🌳

Reconstructed Hierarchy

A Unity-like tree built from the merged result — so objects only the other side added appear too, and anything the merge would drop is flagged before you write.

🛟

Safe by default

Backs up the file before Apply, validates the result re-imports cleanly, warns about broken references, and offers one-click Restore.

Coverage

Works across Unity's text-YAML assets

Any asset Unity serializes as text — plus .meta sidecar files.

.unity.prefab.asset.mat.controller .overrideController.anim.mixer.preset.mask .spriteatlas.renderTexture.terrainlayer.lighting.meta

Honest by design

What it does — and doesn't

Does

Structural 3-way merge of scenes, prefabs and other YAML assets
Per-property, per-list-element and per-field resolution
Merges .meta importer settings + repoints GUID-clash references project-wide
Resolves & stages the asset, then you finish the merge in your Git client
Editor-only — ships nothing into your build

Doesn't (by design)

Doesn't run commit / --continue / --abort — you finish in your Git client
Very deeply-nested both-sides edits surface as one whole-block choice (never a silent drop)
Doesn't merge binary-serialized assets — use Force Text serialization
Not a general Git workflow tool or a replacement for your VCS

Good to know

Requirements & FAQ

Unity 2022.3 or newer · Git on your PATH (or point the tool at a git binary) · Assets serialized as Force Text (Unity's default for source control).

How is this different from Unity's built-in Smart Merge (UnityYAMLMerge)?

Smart Merge is a command-line merge driver you configure in Git, and it still resolves to raw YAML you can't easily read or review. Easy Merge Conflict is a visual Editor window: it shows conflicts by GameObject and property with names resolved, lets you decide each one, reconstructs the resulting Hierarchy, and warns about broken references before you write.

Does it change my Git workflow?

No. It uses the Git you already have and works with any workflow — GitHub, GitLab, Plastic-over-Git, Fork, Sourcetree, command line. It resolves and stages the conflicted asset; you commit / continue the merge however you normally do.

What happens with a .meta GUID conflict?

When each side gave an asset a different GUID, the tool shows both GUIDs with how many references each has. You pick the side to keep, and every reference to the other GUID is repointed across the project so nothing breaks. Those cross-file rewrites are written but left unstaged for you to review; only the .meta itself is staged.

Is anything included in my game build?

No. It's an Editor-only tool — nothing ships into your runtime build.

Can it corrupt my files?

It backs up the working-copy file before every Apply, validates that the merged asset re-imports cleanly, and offers one-click Restore. Multi-file GUID rewrites are backed up as a set and rolled back automatically if any write fails.

Read Unity merge conflicts
in plain language.