When two engineers modify the same PCB at the same time, Git can tell you that "the file changed," but it has difficulty explaining what actually changed in the design. KiCad 11 addresses a critical requirement for EDA team collaboration with native, visual Diff and Merge capabilities that understand the structure of KiCad design objects.
Git Can Manage KiCad Files, but It Does Not Understand KiCad Designs
KiCad project files use a text-based format, which makes them well suited for storage in Git. However, conventional line-by-line Diff tools are often difficult to use for PCB and schematic files.
An engineer may only move a footprint, modify a section of routing, or adjust a symbol property. At the text level, however, these operations can produce extensive coordinate and structural changes. When two branches modify the same file at the same time, Git conflict markers cannot explain whether the conflict involves a particular component, a specific net, or an individual property.
Resolving conflicts directly in a text editor can create additional risks. A manual edit may damage parentheses, UUIDs, or the overall file structure. Even if Git accepts the resulting file, the EDA tool may no longer be able to read it correctly.
KiCad 11 takes a different approach: KiCad itself interprets KiCad files and presents their differences in terms of design objects.
From Comparing Text Lines to Comparing Design Objects
The new Diff functionality parses PCB files, schematic files, and library files. It organizes changes according to design objects and their properties instead of forcing engineers to inspect large blocks of S-expression text.
The difference view primarily divides changes into four categories:
- Added: A new object has been created.
- Removed: An existing object has been deleted.
- Modified: A property of an existing object has changed.
- Conflict: Different versions contain changes to the same object that cannot be resolved automatically.

Figure | KiCad's schematic Diff view overlays design changes directly on the drawing instead of presenting only textual differences.
Within the graphical interface, engineers can:
- Browse differences by object in the change tree on the left.
- Use the search box to filter changes.
- Show or hide added, removed, modified, and conflicting items independently.
- Control layer visibility when reviewing PCB differences.
- Click an object on the canvas to locate its corresponding change record.
- Automatically center and highlight an object when a change is selected.
- View a Before/After comparison of its properties.
- Temporarily hide noisy changes and focus on the most important parts of the design.
For real projects, this is more useful than simply overlaying two screenshots. Engineers can identify which object changed and then inspect exactly how its properties or geometry were modified.
Compare Git Branches Directly in the KiCad Project Manager
KiCad 11 places the branch comparison entry in the Project Manager:
Tools → Compare Project Branches...
The current project must be tracked by Git before this function can be used. After opening the comparison dialog, engineers can select:
- Base ref: The branch or commit used as the reference.
- Head ref: The branch or commit to be reviewed.
After clicking Compare, KiCad lists the project files that have changed. Double-clicking a file opens its corresponding native Diff view.

Figure | PCB Diff interface. The change list is shown on the left, the graphical comparison appears in the center, and Before/After property values are available at the bottom.
This allows hardware teams to establish a review workflow similar to a software Pull Request:
- The designer completes schematic or PCB modifications in a feature branch.
- The reviewer selects the main branch and the feature branch in KiCad.
- The reviewer checks the changes file by file and object by object.
- After confirming that the modifications match the design intent, the branches can be merged.
Git effectively gains an additional layer of interpretation that understands EDA design data.
Native Three-Way Merge
Diff answers the question "where are the differences?" Merge addresses the next question: "How should two versions be combined?"
KiCad 11 uses a standard three-way merge model:
- Ancestor: The common ancestor version shared by both branches.
- Ours: The version in the current branch.
- Theirs: The version from the branch being merged.
Figure | Three-way merge workflow. Non-overlapping changes can be merged automatically, while conflicts affecting the same object require a manual selection.
When an object has been modified on only one side, KiCad can automatically use the result from that side. For example:
- Engineer A changes the value of R12.
- Engineer B moves C8.
- Because the two changes do not affect the same object, both can be included automatically in the merge result.
However, a conflict is reported when both branches modify the same object or when situations such as "deleted versus modified," duplicate UUIDs, or object collisions occur.
The conflict-resolution interface allows engineers to select a result for each conflict:
- Ours: Keep the version from the current branch.
- Theirs: Use the version from the other branch.
- Ancestor: Restore the common ancestor version.
When the selection changes, the graphical canvas synchronously previews the corresponding geometric context. This helps engineers determine which version matches the intended design. The merge cannot be applied until every conflict has been explicitly resolved.
Validation After the Merge
The purpose of native Merge is to produce the valid KiCad file. The merged design should still be checked for issues such as:
- Whether reference designators remain unique.
- Whether connectivity must be rebuilt and has been correctly marked.
- Whether the file schemas used by the three input versions are compatible.
However, a structurally valid file does not necessarily represent a correct electrical design.
After completing the merge, engineers should still:
- Check the properties of critical nets and components.
- Refill copper zones and verify the resulting areas.
- Run ERC and DRC.
- Verify the BOM, footprints, layer stackup, and design rules.
- Perform any necessary simulation or technical review of critical high-speed, RF, and power circuits.
Native Merge reduces the risk of file corruption and manually edited conflicts, but it does not replace design review itself.
Integration with Git mergetool
KiCad 11 also provides a Git-oriented three-way merge tool. Developers can use the standard command:
git mergetool
to enter KiCad's conflict-resolution workflow.
KiCad's Git integration automatically configures its internal Merge Driver. This hidden command is primarily intended to be called by Git and does not normally require manual execution by end users. When a conflict cannot be resolved automatically, kicad-cli mergetool launches the main KiCad application and opens the graphical resolution dialog. After the conflict is resolved, the merged file is written back to disk.
Three-way Merge currently supports the following file types:
| File Type | Extension |
|---|---|
| PCB | .kicad_pcb |
| Schematic | .kicad_sch |
| Symbol library | .kicad_sym |
| Individual footprint | .kicad_mod |
CLI Diff Brings Design Comparison into CI and Automation
In addition to the GUI, KiCad 11 adds multiple Diff subcommands to kicad-cli:
pcb diff: Compare two.kicad_pcbfiles.sch diff: Compare two.kicad_schfiles.sym diff: Compare two.kicad_symsymbol libraries.fp diff: Compare two.prettyfootprint library directories.
Supported output formats include:
- JSON
- Text
- PNG
- SVG
For example, differences between two PCB versions can be exported as a PNG image:
kicad-cli pcb diff before.kicad_pcb after.kicad_pcb --format png -o pcb-diff.png
A CI system can also check only the exit code:
kicad-cli sch diff main.kicad_sch review.kicad_sch --exit-code-only
Under the current convention, exit code 0 indicates that the two files are identical, while 5 indicates that differences were found. Other nonzero values indicate an error. This allows teams to automatically check whether a design changed during a commit or merge request, or to generate graphical difference reports as part of an automated workflow.
What Does This Mean for Hardware Teams?
1. Design Review Moves Closer to the Software Engineering Workflow
A Pull Request no longer needs to contain only a note such as "updated the PCB." Reviewers can directly inspect which components, traces, and properties have changed.
2. Fewer "Last Person to Save Wins" Situations
Different engineers can work in separate branches. Non-overlapping modifications may be merged automatically, while genuinely conflicting changes can be handled together in a focused review.
3. Symbol and Footprint Libraries Become Easier to Govern
Changes to shared libraries can pass through a Diff, Review, and Merge workflow instead of relying on compressed archives, chat attachments, or manual file replacement.
4. CI Can Begin to Understand EDA Changes
PNG, SVG, JSON, and exit-code output allow design differences to enter automated pipelines, review pages, and internal quality systems.
Native Diff and Merge Is Not Real-Time Multiuser Editing
Native Diff and Merge should not be confused with real-time, document-style collaborative editing.
It is designed for file-based, Git-branch-based asynchronous collaboration. Each engineer still edits a separate working copy and integrates the results through commits, comparisons, and merges.
When multiple engineers are working on the same complex PCB, the best strategy remains to divide the work carefully and minimize parallel modifications to the same object or local region. Merge tools can resolve conflicts, but they cannot make the underlying conflicts disappear.
Conclusion
KiCad has used text-based project formats for many years. However, a file being suitable for storage in Git is not the same as being easy for engineers to compare and merge safely.
The significance of native Diff and Merge is not limited to adding two more toolbar functions. These capabilities allow version control to understand EDA design objects more directly. When differences can be interpreted, conflicts can be localized, and merged results can be verified, KiCad gains a stronger foundation for mature team collaboration.
For individual users, the feature makes it easier to review exactly what changed between design versions. For engineering teams, it can become an important part of design review, library management, and CI workflows.