# Hunk vs delta

> Hunk vs delta. delta restyles git diff output in your pager. Hunk turns the same changeset into a review UI. Capability table, setup for running both, and how to choose.

Source: https://hunk.dev/compare/hunk-vs-delta/ · Last checked: 2026-09-01

delta is a pager. It restyles the text `git diff` already printed and hands it to `less`. Hunk is a review UI. It turns the same changeset into one scrollable stream with a file sidebar, split and stack layouts, mouse support, watch mode, and agent notes beside the hunks they explain. Keep delta for everyday diffs. Open Hunk when you sit down to review.

## Choose Hunk if

- You review whole changesets and want a sidebar and per-hunk navigation.
- You want to change layout, wrapping, or theme while reading, not in `.gitconfig`.
- You want more context around a hunk without re-running the diff.
- An agent wrote the change and you want its reasoning next to the code.
- You want the diff to reload as the working tree changes.

## Choose delta if

- You want every diff you print to look better, with no change to how you work.
- You want `git blame`, `git grep`, and `git log` styled too, not just diffs.
- You want the lowest startup cost on a diff you will glance at and close.
- You already tuned delta and you like reading in a pager.

## What delta is

delta is a pager. Git prints a unified diff and pipes it to whatever `core.pager` points at. delta sits in that pipe and rewrites the text on the way through. Two lines of `.gitconfig` and every diff you print looks better, including the ones inside `git add -p`, `git log -p`, and `git show`.

It does the job well. Syntax highlighting with bat syntax themes plus its own theme collection, word-level highlighting inside changed lines, an opt-in side-by-side view with wrapping, line numbers, opt-in `n`/`N` navigation between files, hyperlinked commit hashes, and styled `git blame` and `git grep`. Written in Rust, MIT-licensed, with a `--help` that runs to about 110 options.

What it does not do is hold a model of your changeset. It sees a stream of text and emits a prettier one. No file list, no selected hunk, no state that survives from one line to the next.

## What Hunk does differently

Hunk parses the changeset into a document, then draws a UI over it. Every visible file becomes one continuous review stream, and the sidebar indexes that stream instead of hiding the rest of the change. `[` and `]` walk hunks across the whole changeset, `,` and `.` walk files, and the selection is real state that the sidebar, note cards, and context expansion all follow.

Holding the model in memory makes things easy that a pager cannot do at all. Press `z` to expand unchanged context around a hunk without re-running the diff. Press `1`, `2`, or `0` for split, stack, or responsive layout. Press `w` for wrapping or `t` for another theme, mid-review. `hunk diff --watch` reloads as you keep editing.

The part with no delta equivalent is agent context. An agent that wrote the change can attach its reasoning to specific hunks through `hunk session`, and Hunk renders those notes inline, next to the code, instead of in a pane you correlate by hand.

## Use both

There is no conflict. delta is a good default pager, Hunk is a good review session. Leave delta configured and reach for Hunk deliberately.

If you would rather have Git open Hunk for diffs too, point `core.pager` at `hunk pager`. Non-patch output still falls through to your normal text pager. Either way `hunk diff` is the native entry point, and it is the only one that can pull untracked files into the review.

Keep delta as the pager, add Hunk as the review step:

```bash
curl -fsSL https://hunk.dev/install.sh | sh

# delta stays exactly as you configured it
git config --global core.pager "delta"

# Hunk is what you open to review
hunk diff          # working tree, including untracked files
hunk show HEAD     # the last commit
hunk diff --watch  # reload as you keep editing
```

## Hunk vs delta, capability by capability

delta is written in Rust and licensed MIT. Hunk is TypeScript, MIT, and ships as a standalone binary for macOS, Linux, and Windows.

| Capability | Hunk | delta |
| --- | --- | --- |
| Syntax highlighting | Yes | Yes |
| Themes — Hunk ships 65 bundled themes and takes custom ones. delta pairs bat syntax themes with its own collection, browsable via `delta --show-themes`. | Yes | Yes |
| Side-by-side / split view — delta opts in with `--side-by-side`. Hunk's `auto` layout picks split on wide terminals and stack on narrow ones. | Yes | Yes |
| Word-level highlighting inside a changed line | Yes | Yes |
| Moved-line detection — Both build on Git's `--color-moved`. Hunk honors `diff.colorMoved` from your Git config. | Yes | Yes |
| File sidebar you can jump from — delta emits a linear stream, so navigation is whatever your pager offers. | Yes | No |
| Hunk-by-hunk navigation across the whole changeset — With `delta.navigate` enabled, `n`/`N` jump the pager between files, and between commits in `log -p`. Hunk tracks a selected hunk that the rest of the UI reacts to. | Yes | Partly |
| Mouse: click, wheel, scrollbar, menus — delta leaves scrolling to your pager, which has no file list or clickable chrome. | Yes | Partly |
| Change layout, wrapping, and theme mid-review — delta's options are fixed for the invocation, set in `.gitconfig` or on the command line. | Yes | No |
| Expand unchanged context in place — More context around a delta hunk means re-running the diff with a larger `-U`. | Yes | No |
| Watch mode that reloads the review | Yes | No |
| Inline agent and human annotations on a hunk | Yes | No |
| Programmatic session control for coding agents — `hunk session` lets an agent read and navigate the review you have open. | Yes | No |
| Works as a Git pager (`core.pager`) | Yes | Yes |
| Works as a Git difftool | Yes | Yes |
| Styles `git blame` and `git grep` output — Hunk's pager mode opens the review UI for patches and falls back to a plain-text pager for everything else. | No | Yes |
| Native Jujutsu and Sapling support — delta works wherever a VCS lets you set a pager. Hunk detects jj and Sapling workspaces and takes native revsets. | Yes | Partly |
| TypeScript extension API | Yes | No |

## Questions people ask

### Can I use Hunk and delta at the same time?

Yes. They sit in different slots. delta goes in `core.pager` and styles everything Git prints. Hunk is a command you run, `hunk diff` or `hunk show`, when you want to review. Nothing has to be uninstalled.

### Is Hunk a drop-in replacement for delta?

Not quite. `hunk pager` covers the diff half: set it as `core.pager` and patch-like output opens in the review UI, while everything else falls through to your plain-text pager. Hunk does not style `git blame` or `git grep`, so keep delta if that output matters to you.

### Does Hunk support side-by-side diffs like `delta --side-by-side`?

Yes, and it is the default on wide terminals. Hunk's `auto` layout picks split on wide terminals and stack on narrow ones. `1` forces split and `2` forces stack, at any point in the review.

### Which is faster, Hunk or delta?

delta starts faster, and that is structural: it is a Rust stream filter doing one pass over text. Hunk builds a review model and mounts a terminal UI, which costs more up front and buys navigation, state, and annotations. The experimental `hunk --fast` offloads eligible syntax highlighting to cut that cost.

### Does Hunk need configuration to be useful?

No. `hunk diff` works with no config file. You can save preferences on quit, and a repository can carry its own `.hunk/config.toml`, but none of that is required to start.

## Sources

- [delta, GitHub repository](https://github.com/dandavison/delta)
- [delta manual: side-by-side view](https://dandavison.github.io/delta/side-by-side-view.html)
- [Hunk: Git pager and difftool](https://hunk.dev/docs/workflows/git-pager-and-difftool/)
- [Hunk: keyboard and mouse](https://hunk.dev/docs/start/keyboard-and-mouse/)

## Other comparisons

- [Hunk vs difftastic](https://hunk.dev/compare/hunk-vs-difftastic/) — difftastic changes what the diff says. Hunk changes how you read the changeset. Different problems, both worth solving.
- [Hunk vs diff-so-fancy](https://hunk.dev/compare/hunk-vs-diff-so-fancy/) — diff-so-fancy tidies Git's diff output. Hunk replaces the reading experience. The gap is bigger than it looks.
- [Hunk vs git diff](https://hunk.dev/compare/hunk-vs-git-diff/) — git diff prints the patch. Hunk renders the same patch as something you can navigate. Git stays the source of truth.
- [Hunk vs Plannotator](https://hunk.dev/compare/hunk-vs-plannotator/) — Both exist because agents write more code than you can read. Plannotator reviews it in the browser and covers plans. Hunk stays in the terminal.