SynthesisvsSSEEdit (xEdit for Skyrim SE)

Synthesis and SSEEdit (xEdit) are the two central tools for resolving conflicts between plugins in Skyrim, but they tackle the problem from opposite sides. SSEEdit is a record editor: it shows you every modification of every plugin and lets you edit overrides by hand. Synthesis is a framework that runs patchers written in C# (by the community or by you) that regenerate patches deterministically every time you change the modlist. Most serious modders use both at different points in the workflow — this comparison helps you know which one to open and when.

Opposite philosophies

SSEEdit is the Skyrim branch of the xEdit project, the Bethesda record editor ElminsterAU has maintained since Oblivion. It's the universal tool for inspecting and modifying Bethesda plugins. You open SSEEdit, load your load order, and see a huge tree with every record any plugin has touched. If two mods modify the same NPC, you see both overrides side by side and decide which version wins.

The workflow is manual and specific: to resolve a conflict between Mod A and Mod B, you open the disputed record, copy the winner to a new plugin, and edit. Each patch you write ends up as an ESP/ESL file in your load order. If tomorrow you uninstall Mod B, your patch is left with dead references and has to be regenerated by hand.

Synthesis is a more recent project (Noggog & the Mutagen team) that flips the paradigm: instead of editing records, you write a function that describes how records of a certain type should be combined. That function is executed by Synthesis whenever your modlist changes, producing a fresh patch that reflects the current modlist exactly.

Typical Synthesis patcher examples:

• SynLeveledList: merges leveled lists from all mods (the automated equivalent of SSEEdit's Leveled List Patcher).
• SynNpcAttributesForwarder: forwards NPC attributes (face geometry, stats, factions) across multiple overhauls.
• SynRaceMenuPlus: integrates race changes without losing preset mods.
• SynBashedPatcher: the modern C# equivalent of Wrye Bash.

The core promise: once your Synthesis pipeline is configured, any modlist change is absorbed with a click instead of hours of manual rework.

Inspection vs transformation

When a mod does something weird in-game, the typical debug flow is:

1. Open SSEEdit.
2. Load the load order.
3. Find the suspect record (e.g. an NPC showing up headless).
4. See the override chain: vanilla → Mod A → Mod B → your patch.
5. Identify which override is breaking (probably Mod B didn't forward Mod A's head record).
6. Decide the fix.

Synthesis doesn't help with this flow. Synthesis is for running transformations, not for investigating plugins. It has no record-exploration UI.

For anything that's "what's happening in my load order", SSEEdit wins outright.

Repeatability and maintenance

Here Synthesis wins. A 200+ mod modlist typically needs:

• A leveled list patch (so items and enemies from every mod show up in the world).
• An NPC appearance patch (so USSEP forwards fixes onto NPCs that cosmetic mods also touch).
• A bashed patch or equivalent (consolidation of minor changes between plugins).
• Specific patches between mods that conflict on concrete records.

With SSEEdit each one of these is done by hand. If you add two new mods, you repeat the process. If you update them, you repeat. If you remove them, you repeat and clean up patches.

With Synthesis you configure the patchers once and they re-run in seconds. The resulting patch reflects your current modlist with no "drift" between what's on disk and what your patches assume.

For modders who maintain living modlists (frequently adding and removing mods), Synthesis pays off its initial config curve within a few weeks.

Learning curve

SSEEdit is more accessible short-term. Anyone with curiosity can open it, navigate records, and understand what each plugin does. There are thousands of YouTube tutorials and written guides. The concepts (record, override, master, FormID) are learned visually.

Synthesis has more setup curve but less daily-use curve. Setting up your first Synthesis pipeline (installing the .NET runtime, adding patchers from the public repository, configuring settings) takes an afternoon the first time. After that, it's just open and hit Run. If you want to write a custom patcher you need to know C# and the Mutagen library — that is a real curve, but most modders never write patchers, they only consume them.

What SSEEdit does and Synthesis doesn't

• Cleaning official masters (ITM/UDR from Update.esm, Dawnguard.esm, etc.). SSEEdit's Quick Auto Clean is standard; the official SE guide recommends running it before modding.
• Editing records by hand for one-off patches.
• Investigating conflicts record by record.
• Learning Bethesda's plugin structure — the number-one pedagogical tool.
• Converting plugins between versions (LE to SE) using comparison functions.

What Synthesis does and SSEEdit doesn't (comfortably)

• Deterministic patches that regenerate. SSEEdit can run scripts but it's not the focus.
• Chained patcher pipelines that produce a single final ESP output.
• Patcher distribution via repository: subscribe to a patcher in the directory and it updates on its own.
• Structured logs of what each patcher did to which record.

At a glance

Scenario	Best pick
Investigating what a plugin does	SSEEdit
Cleaning official masters	SSEEdit
Resolving a one-off conflict between 2 mods	SSEEdit
Merging leveled lists across the whole modlist	Synthesis
Forwarding NPC appearance across overhauls	Synthesis
Living modlist with frequent changes	Synthesis
Learning Bethesda plugins	SSEEdit
Writing a reusable custom patcher	Synthesis

Final verdict

Don't pick between them: you're going to use both.

SSEEdit is the universal Bethesda plugin authoring tool — you open it to understand, debug, clean, and write manual patches. It's essential and has no substitute.

Synthesis is the automation layer on top: when the patches you need are repetitive (leveled lists, NPC forwards, bashed-style merges), Synthesis does them in one click and keeps them in sync with your modlist.

A typical serious-modlist pipeline: install mods → run LOOT → run Synthesis for automatable patches → open SSEEdit to write the specific patches Synthesis doesn't cover → play.

If you're just starting, learn SSEEdit first. Synthesis makes sense once you already understand what it's automating.