I review a lot of dev tools on this site, and most of them earn a paragraph of praise and then quietly fall off my machine inside a month. Difftastic is different. I installed it as an experiment, meant to write it up in a week, and instead it silently became the thing I reach for every time I want to actually understand a change instead of squinting at a wall of red and green.
Difftastic is a structural diff tool written by Wilfred Hughes. The pitch is one sentence: it parses your code into syntax trees and diffs those trees, instead of diffing lines of text. That sounds like a small distinction. In practice it changes what a diff feels like, because it stops lying to you about what changed.
The Problem With Line Diffs
Git’s default diff is a line diff. It compares your old file and your new file as sequences of lines and shows you which lines were removed and which were added. This has worked for fifty years and it will keep working, but it has a fundamental blind spot: it does not know anything about code. It knows about lines.
That blind spot shows up constantly. You wrap a long function call across three lines to satisfy your formatter, and git shows the entire statement deleted and re-added, even though not a single token changed. You add an if block around existing code and re-indent the body, and git reports every line of that body as changed because the leading whitespace moved. You rename a variable and the diff is clean, but you reflow a JSX prop list and the diff is a bloodbath of noise that hides the one real edit buried in the middle.
The result is a diff where the amount of red and green has almost no relationship to the amount of actual change. You end up doing the parsing in your head, mentally subtracting the reformatting to find the two tokens that actually matter. Every code reviewer alive has trained themselves to do this, and it is a tax we all pay on every pull request.
What Difftastic Does Instead
Difftastic uses tree-sitter grammars to parse both versions of a file into concrete syntax trees, then it diffs the trees. It treats the whole thing as a graph problem and walks it with Dijkstra’s algorithm to find the minimal set of structural changes.
Because it is comparing trees, it understands that an expression which got wrapped across more lines is the same expression. It understands that code which got re-indented because you nested it inside a new block did not itself change. It understands that reordering two independent statements is a move, not a delete-plus-add of everything in between.
So when you reflow that JSX prop list, difftastic shows you nothing, because nothing changed. When you wrap a function call, it shows you nothing. When you rename a variable inside a reformatted block, it highlights exactly the renamed identifier and stays quiet about the surrounding whitespace churn. The signal-to-noise ratio flips. Suddenly the highlighted parts of the diff are the parts that actually changed, and you can trust that.
The output is side by side by default, old on the left, new on the right, with the changed sub-expressions highlighted inline rather than whole lines painted. On a dense change it is dramatically easier to follow than a unified diff, because your eye goes straight to the highlighted tokens instead of scanning line-by-line to find them.
Installing It
Difftastic is a single Rust binary called difft, and installing it is a one-liner on most platforms:
# macOS
brew install difftastic
# Arch
pacman -S difftastic
# Cargo, anywhere Rust runs
cargo install difftasticThere is no runtime, no config file it demands, no daemon. You get a binary. Run difft old.rs new.rs and it prints a structural diff of two files immediately, which is a nice way to confirm it works before you touch your git config.
Wiring It Into Git
The way you actually live with difftastic is as git’s external diff tool. You do not replace git diff wholesale, you teach git to route through difft when you ask it to. The cleanest approach is a dedicated alias plus the GIT_EXTERNAL_DIFF environment variable so your plain git diff stays fast and scriptable.
Add this to your git config:
[diff]
external = difft
[core]
pager = less -RFXThat makes git diff, git show, and git log -p all render through difftastic. If you would rather keep the default diff as the default and opt in explicitly, skip the [diff] external line and use an alias instead:
[alias]
dft = "!GIT_EXTERNAL_DIFF=difft git diff"
dlog = "!GIT_EXTERNAL_DIFF=difft git log -p --ext-diff"Now git dft gives you the structural view on demand and plain git diff stays exactly as it was. I run it this way, because there are moments when I want the raw line diff, and there are far more moments when I want to understand the change, and keeping both a keystroke apart is the right trade.
One important note: tools that programmatically parse git diff output expect unified diff format, and difftastic does not emit that. So keep difft off the path that scripts and CI use. The --ext-diff flag and the environment-variable approach both keep the structural rendering scoped to interactive use, which is exactly where you want it.
Where It Earns Its Keep
The place difftastic paid for itself immediately was code review of refactoring pull requests. A colleague opened a change that, in plain git diff, touched four hundred lines across six files. The diff looked terrifying. Reviewed through difftastic, it was three actual logic changes and a formatter pass, and difft showed me the three logic changes and stayed silent on the reformatting. A twenty minute review became a five minute one, and I was more confident at the end, not less.
The second place is my own work, right before I commit. Running the change through difft is a sanity check that catches the accidental edit, the stray character, the thing I did not mean to touch, because those show up as highlighted structural changes instead of hiding in a sea of whitespace noise. When difft shows me a change I did not intend to make, I catch it before it ships.
It is also genuinely good at languages I do not write often. Because the grammars come from tree-sitter, difftastic understands the structure of code in dozens of languages, so when I am poking at a Go service or a Terraform config I rarely touch, the diffs are still meaningful.
Where It Falls Short
I am not going to oversell this. Difftastic has real limits, and honesty about them is the whole point of a review.
It is slower than a plain line diff, because parsing two syntax trees and running a graph search is more work than comparing lines. On normal source files you will never notice. On very large generated files it will notice for you and fall back to a text diff rather than grind, which is the right call but means it is not a universal replacement.
It is not a merge tool. Difftastic shows diffs, it does not resolve conflicts, so your three-way merge tool stays exactly where it is. This trips people up who expect it to slot into git mergetool. It does not, and it does not try to.
Its output format breaks anything that expects unified diff. Some review bots, some patch-applying scripts, some editor integrations assume the classic format and choke on difft’s side-by-side rendering. This is why I keep it scoped to interactive use and never let it near CI.
And the language coverage, while broad, is uneven. Mainstream languages parse beautifully. Reach for something obscure and difftastic degrades gracefully to a word-level diff, which is still better than nothing but is not the full structural experience.
Difftastic vs Delta
The obvious comparison is git-delta, which I reviewed earlier and still like a lot. They are not really competitors, they solve different problems, and I run both.
Delta is a syntax-highlighting pager for the standard unified diff. It makes the line diff beautiful, with proper language colors, line numbers, and side-by-side layout, but it is still fundamentally showing you line changes. Difftastic changes what a diff means by parsing structure. Delta makes the existing diff prettier and more readable; difftastic computes a different, smarter diff.
In practice I use delta as my everyday pager because it is fast and it makes everything readable, and I reach for difft with my alias when a change is confusing and I want to know what genuinely moved. They coexist happily. If I had to keep only one, I would keep delta for its speed and universality, but the days difftastic saves me are the hard days, and those are the ones worth optimizing.
The Bottom Line
Difftastic is the first diff tool in years that changed how I read code, not just how it looks. By diffing syntax trees instead of lines, it stops reporting reformatting as change and starts showing me what actually moved, and once you have reviewed a gnarly refactor through it you do not want to go back to squinting past whitespace noise ever again.
Install the difft binary, wire it in as an opt-in git alias with GIT_EXTERNAL_DIFF, and keep plain git diff for scripting and CI. Do not expect it to merge your conflicts or feed your review bots, because that is not what it is for. Use it for the one thing it is spectacular at, which is helping a human understand a change, and it will quietly become the tool you reach for on every hard pull request. It is free, it is a single binary, and it is the highest-signal upgrade I have made to my git workflow since I started using delta.