ExDiff

English | 简体中文

Visual Studio Marketplace · GitHub source

Review Git changes in VS Code without losing your editor smarts. ExDiff opens any two revisions of a file as real files on disk, so hover, Go to Definition, Find References, Find Implementations and diagnostics keep working on both sides of the diff.

Why ExDiff

VS Code's built-in Git diff shows the older revision as a virtual git: document. It is not on disk and does not belong to any workspace folder, so the language server ignores it:

• no hover, no F12, no Find References;
• no lint or type diagnostics;
• no navigation into the old version of the code.

ExDiff materializes each revision as a real snapshot inside the repository and adds it to the workspace. Both sides of the diff become ordinary file:// documents, and your language server treats the old revision exactly like normal source code.

Built-in diff:  [ virtual git: document ]  →  no language server  →  [ working file ]
ExDiff:         [ real snapshot file    ]  →  language server ✅  →  [ working file ]

ExDiff only reads Git objects. It never modifies your working tree, index, refs or reflog.

Features

• Language features on both sides — hover, Go to Definition, Find References, Find Implementations (where supported) and diagnostics.
• Review a single-commit branch — compare against a configurable base (HEAD~1 by default), or exactly HEAD~1 ↔ HEAD.
• Amend-friendly — see what the last git commit --amend actually changed.
• Rebase review — git range-diff commit pairs with per-pair patches, including how conflicts were resolved.
• Staged-only review — HEAD ↔ index with no unstaged noise.
• Any two refs — branches, remote branches, tags, recent commits and reflog entries.
• Changes view — statuses, line counts, renames and automatic refresh.
• Read-only and offline — no telemetry, no network access, no background Git mutations.

Requirements

• VS Code 1.85 or newer.
• Git on PATH (or point exdiff.gitPath at the executable).
• A language server that supports multi-root workspaces. TypeScript/JavaScript, Go and Python work out of the box; see Limitations for Rust, C/C++ and others.

Install

• Marketplace: install ExDiff from the Visual Studio Marketplace.
• VSIX: code --install-extension exdiff-0.2.6.vsix

Reload the window after installing.

Quick start

1. Open a Git repository in VS Code.
2. Open a file, right-click it, and choose ExDiff: Open Changes with Base (or run it from the Command Palette).
3. Hover, press F12, or press Shift+F12 on the left-hand (old) side.

The first time, VS Code asks whether to add the snapshot folder to the workspace. Choose Add — this is what makes language features work on the old revision. The answer is remembered.

Commands

Where to find the commands

• Command Palette — press Ctrl+Shift+P and type ExDiff.
• Editor title bar — compare with base, open the base version.
• Editor context menu — the ExDiff group.
• Explorer context menu — on files: compare with base.
• Activity Bar — the ExDiff icon opens Changes and Rebase Changes views.

Views

Changes

Lists every file changed since the fork point (the merge-base of exdiff.baseRef and HEAD), with its status (added, modified, deleted, renamed…), line counts and rename mapping. Click a file to open a diff whose two sides are real files. The view refreshes on save, window focus, configuration changes and Git ref/index updates.

Rebase Changes

After a rebase, lists the commit pairs reported by git range-diff:

Select a pair to read its patch, or open the full range diff.

Settings

Typical workflows

Review a branch since it diverged

Open Changes with Base compares from the fork point — git merge-base <baseRef> HEAD — so it shows only the commits on your branch, not changes that landed on the base branch after you diverged.

1. Run ExDiff: Open Changes with Base.
2. The left side is a real checkout of the fork point; the right side is your working file.
3. Use hover, F12 and Find References on either side.

With the default auto, ExDiff reads the current branch's creation entry (branch: Created from …), falls back to the nearest merge-base among local and remote branches, then HEAD~1. This works for any parent branch (for example team/feature-a), not just main or master. Set exdiff.baseRef to a branch to override.

If you want to ignore uncommitted changes, set exdiff.rightSide to ref.

Review exactly the latest commit

Run ExDiff: Open Changes with Previous Commit. This compares HEAD~1 and HEAD only, regardless of your settings or uncommitted edits.

Work with an amend loop

1. git commit --amend.
2. Run ExDiff: Open Changes with Previous Amend.
3. The left side is the pre-amend commit (HEAD@{1}); the right side follows exdiff.rightSide.

Review a rebase

1. git fetch upstream && git rebase upstream/master.
2. Run ExDiff: Show Rebase Changes.
3. Open a commit pair to see how the patch changed. Pairs marked ! were rewritten — often because of conflict resolution.

The detected ranges are cached per repository, so the review survives a window reload.

Review only staged changes

Run ExDiff: Open Changes with HEAD (staged only). The index is materialized with git write-tree, so unstaged edits are excluded.

Compare arbitrary revisions

Run ExDiff: Compare Two Refs… and pick two branches, tags, commits or reflog entries. The Changes view switches to that comparison.

How it works

• ExDiff materializes a revision into <repoRoot>/.exdiff/<snapshot> using a temporary index and git checkout-index. The snapshot contains no .git, so it is not treated as another repository.
• The snapshot folder is added to the workspace with vscode.workspace.updateWorkspaceFolders(). That is what makes the language server index it.
• Snapshots are updated incrementally when the revision changes, and reused when it does not.
• The .exdiff folder carries its own .gitignore, so the snapshots, sidecars and temporary files never appear in git status.
• Base comparison uses the merge-base (fork point) of exdiff.baseRef and HEAD; auto derives the base from the branch reflog creation point or the nearest branch fork, so upstream commits do not leak into the diff.
• ExDiff never writes to your working tree, index, refs or reflog. git write-tree only creates an unreachable tree object for the staged-only comparison.

Limitations

1. Duplicate Find References — the snapshot and the real repository both contain the code, so references appear twice. Run Detach Snapshots when you are not reviewing.
2. Multi-root language servers — TypeScript/JavaScript, Go and Python work well. Rust (linkedProjects), C/C++ (compile_commands.json) and some JVM/Kotlin servers need extra configuration, and cross-snapshot navigation is not guaranteed.
3. Disk and memory — each snapshot is roughly the size of the tracked files, and every attached snapshot adds another LSP index. Use Detach Snapshots or Delete Snapshots to reclaim space.
4. First materialization is slow on large repositories. Later updates are incremental, and an unchanged revision is reused.
5. Submodules are not materialized; their entries appear as empty directories.
6. Single-folder workspaces — adding the first snapshot folder may restart the extension host (VS Code behavior when a single-folder workspace becomes multi-root). The diff tab is restored; re-run the command if it was interrupted. Saving a multi-root .code-workspace avoids this.
7. Diff editor features — peek, some rename refactorings and some code actions are still more limited than in a normal editor. Use Open Base Version of This File for the full experience.
8. Snapshots are disposable — manual edits are not detected. Delete the snapshots to rebuild them.
9. Cleanup — temporary ref-* snapshots are pruned at startup after exdiff.snapshotRetentionDays (default 7). Prune Stale Snapshots removes all expired snapshots. Detach only changes the workspace; Delete removes files from disk.
10. Snapshots inside the repository — tools that scan the whole working tree (some linters, test runners or build scripts) may also visit .exdiff. Add .exdiff to their ignore configuration if necessary, or point exdiff.snapshotDir at a folder outside the repository.

Troubleshooting

Language

ExDiff ships with English and Simplified Chinese UI strings. It follows VS Code's display language; switch with Configure Display Language and restart. Other languages fall back to English.

Privacy

ExDiff has no telemetry, makes no network requests, and never uploads your code. Everything runs locally.

License

MIT © 2026 xaxys. See LICENSE.