delta: a syntax-highlighting pager that sits between git and your terminal

The problem delta solves is reading, not reviewing

Plain git diff output is a stream of plus and minus lines with no notion of the language inside them. A renamed variable and a changed string literal look identical. delta's premise is that the pager is the right place to fix this: instead of asking you to open an editor or a web UI, it intercepts the text git would have printed and re-renders it. The README describes it as a pager for git, diff, grep, rg --json and blame output, and the feature list is a catalogue of reading aids rather than review workflow: syntax highlighting using bat's themes, word-level diff highlighting via a Levenshtein edit inference algorithm, side-by-side view with line wrapping, line numbering, and n and N keybindings to jump between files in a large diff or between diffs in a log -p view. The audience is narrow and specific. If you already use bat as a cat replacement and diff-so-fancy as a diff filter, delta is the consolidated version of both. If you review code primarily in a browser or an IDE, delta changes nothing about your day.

How the pager intercepts git output

delta is a filter, not a git plugin. Git writes its diff to the pager process's standard input, delta parses that text, and delta writes styled output to the terminal. That is why the configuration lives under core.pager and interactive.diffFilter rather than in any git extension mechanism. Two entry points matter. core.pager = delta handles normal diff, show, log -p and blame output. interactive.diffFilter = delta --color-only handles the interactive staging path, where git add -p needs to parse what it displays; the --color-only flag tells delta to emit colour without restructuring the output into side-by-side or line-numbered form, which would otherwise break git's own hunk selection. The README's example config sets both, plus delta.navigate and delta.dark. Because delta is a stdin filter, it also works outside git: the feature list includes syntax-highlighting grep output from rg, git grep and grep, and rg --json. Commit hashes can be rendered as terminal hyperlinks to the hosting provider page, with GitHub, GitLab, SourceHut and Codeberg named as supported providers, and file paths can be rendered as hyperlinks for opening in the OS. The Rust implementation is what makes the lexing fast enough to sit in the interactive path; the README does not publish latency figures, so treat that as a design rationale rather than a measured claim.

Getting it running takes five git config lines

The README notes the package is called git-delta in most package managers while the executable is just delta, which is the first thing that trips people up. The documented setup is a gitconfig block under [core], [interactive], [delta] and [merge], or the equivalent one-liners: git config --global core.pager delta, git config --global interactive.diffFilter 'delta --color-only', git config --global delta.navigate true, git config --global delta.dark true (or delta.light true, or omit for auto-detection), and git config --global merge.conflictStyle zdiff3. The merge.conflictStyle setting is not delta itself; it changes how git writes conflict markers, and delta's improved merge conflict display is built around that style. Beyond the defaults, features are toggled with delta.* keys: side-by-side = true, line-numbers = true, and navigate = true. Style strings for foreground colour, background colour and font attributes are supported for more than 20 stylable elements using git's own colour and style language, so anything you already know from color.diff applies. delta -h gives short help and delta --help gives the full manual, which is the honest place to look given the README only samples the option space.

Side-by-side, navigate and the interactive filter are the real trade-offs

The defaults are conservative on purpose, and each opt-in changes the shape of the output rather than just its colour. Side-by-side = true splits the terminal into two panels and wraps long lines automatically; the README states that line numbers are on by default in that mode and both panels get syntax highlighting. On a narrow terminal this is the wrong setting, because wrapping in two panels halves the usable width for the code itself. delta.navigate adds n and N to move between files in a large diff and between diffs in a log -p view, which is useful exactly when a diff is too long to scroll, and useless when it is not. The interactive.diffFilter line is the one to get wrong carefully: if you set the filter to delta without --color-only, git's interactive staging has to parse restructured output, and the README's own config uses --color-only precisely to avoid that. The emulation modes for diff-highlight and diff-so-fancy are a migration path rather than a feature: they exist so you can swap delta in without relearning the look, and if you stay in emulation mode you are not using most of what delta does.

Where delta is the wrong tool

delta renders what git produces. It does not summarise, rank or filter it. A diff of a regenerated lockfile, a compiled bundle or a vendored dependency is still thousands of lines of noise, now in colour, and syntax highlighting actively works against you there because a lockfile is one language-shaped blob with no meaningful structure to highlight. The README makes no claim to handle that case. The second limit is the pager boundary itself: because delta is a display layer, anything that needs to inspect the diff programmatically (a CI check, a lint over changed lines, a script that counts added tests) must bypass it entirely and read git's raw output. The third is configuration surface. More than 20 stylable elements plus layout options means a personal config that grows and then breaks subtly on upgrade; the README points at delta --help and the online manual rather than documenting the full option set inline, so the manual is effectively part of the install. Finally, the README does not state a minimum git version, so if you are pinning an older git, verify the interactive and merge settings behave before rolling the config out across a team.

Compared with diff-so-fancy and plain git

The obvious alternative is diff-so-fancy, and delta ships an emulation mode for it. The difference in approach is scope. diff-so-fancy rewrites diff output into a cleaner format: it removes the +/- markers, cleans up hunk headers and adds colour to changed lines. delta does that and then adds language syntax highlighting, word-level diff highlighting, a side-by-side layout engine, line numbering and commit hyperlinks. If your only complaint about git's default output is the noise around the diff, diff-so-fancy addresses it with a much smaller configuration surface. If your complaint is that you cannot tell a string change from a structural change at a glance, delta's syntax layer is the part diff-so-fancy does not attempt. The other alternative is doing nothing: git's built-in colour plus merge.conflictStyle = zdiff3 already improves conflict readability on its own, and the README lists support for git's --color-moved feature, which means git's own move detection still does work that delta renders rather than replaces. Choosing delta is choosing a heavier pager in exchange for language awareness; that exchange is not obviously worth it for everyone.

Licence, maintenance and what an upgrade costs you

delta is MIT licensed, which permits commercial and closed-source use and modification with the licence and copyright notice retained. That is a permissive, low-friction choice, and it is the same licence family as the surrounding tooling; this is a description of the licence text, not legal advice, and if you redistribute delta inside a product you should read the MIT terms yourself. On maintenance, the repository is not archived, the default branch is main, and the recent release history shows 0.19.0, 0.19.1 and 0.19.2 within roughly a week in March 2026, with repository activity recorded as recently as September 2026. That pattern of point releases suggests active upkeep rather than a stable frozen interface, which has a practical consequence: delta is installed as a binary and invoked through core.pager, so an upgrade changes how every diff in every repository on your machine looks. A regression in the parser or a changed default is not scoped to one project. The cheap mitigation is to pin the version your package manager installs and re-read delta --help after upgrading, since the README does not enumerate the full option set and behaviour changes will show up there first. Version numbers and dates here come from the release list and repository metadata, not from any test run.

Editorial conclusion

Adopt delta if you read diffs in a terminal daily and want syntax highlighting, line numbers or side-by-side layout without leaving git. Skip it if your diffs are mostly generated files, lockfiles or vendored code, where syntax highlighting adds nothing and the extra pass over the diff only costs latency. Before committing to the config above, verify three things on your own machine: that your terminal renders the hyperlink escape sequences used by --hyperlinks, that the theme you pick is readable against your actual background (delta --show-syntax-themes --dark and --light print the options), and that interactive.diffFilter behaves correctly when you stage partial hunks with git add -p.

Official sources

1. dandavison/delta on GitHub
2. License: MIT
3. Project website
4. README
5. Releases