After that first install, you won't need the DMG again — Differentialis updates itself: Check for Updates… (or the update banner) downloads, verifies, installs, and relaunches the new version in place.

Features

• Text diff — a from-scratch Myers diff engine with character-level intra-line highlights, side-by-side and unified layouts, exact or whitespace-insensitive matching, line-ending/final-newline diagnostics, change bars, collapsible unchanged regions, next/previous-change navigation, and live insertion/deletion stats.

• Paste Text — compare snippets without saving files: paste or type into two side-by-side editors (⌘T) and the diff updates live as you edit, with synced scrolling and line numbers. Copy any change from one side to the other (⌥⌘→ / ⌥⌘←), with full undo, or flip to the split/unified Diff view.

• Image diff — four comparison modes with ⌘1–⌘4:

  • Two-Up (side-by-side, horizontal or vertical)
  • One-Up (A/B with auto-blink)
  • Split (draggable slider reveal)
  • Difference (false-color — only the changed pixels glow)
  • …with synced zoom/pan, explicit Fit/zoom controls, an accessible split divider, and a pixel-dimension readout.

• Folder diff — recursive scan classifying every file as Added / Removed / Modified / Identical, with changes-only, name, and status filters plus click-through to the right diff for each file.

• 3-way merge — base / left / right with an editable result, per-hunk take left / right / both / base, content and line-ending conflict resolution, and save-merged output.

• Git integration — open any repository to browse its commit history or flip to a changed-files view with correct reference/index/working-tree snapshots, grouped by folder and filterable by name, extension, or status. A persistent Projects sidebar keeps your opened repositories one click away. Uses the system git, no libgit2.

• Custom Comparison — a Liquid Glass popover to compare any Reference or Commit (pick from history or paste a commit hash) against the Working Copy, another Reference, or Commit — with swap, and Save to revisit named comparisons later.

• Appearance & themes — Light, Dark, or Auto (follows the system), with a theme per appearance: Differentialis, Mariana, Monokai, One Dark, Solarized, and GitHub. Build your own in the theme editor, import JSON or .tmTheme color schemes, and pick the code font family and size (⌘+ / ⌘− / ⌘0, or pinch). All in Settings (⌘,).

• Liquid Glass throughout — glass toolbars, mode switchers, popovers, and panels native to macOS 26 Tahoe.

• In-app updates — a quiet banner (Skip / Later / Update) offers new versions and installs them in place — download, EdDSA-verify, swap, and relaunch — without leaving the app, plus Check for Updates… in the app menu. Powered by Sparkle reading an appcast attached to the latest GitHub release.

Screenshots

Keyboard shortcuts

Every command is in the menu bar, and Help ▸ Keyboard Shortcuts (⌘/) shows the full cheat sheet.

Requirements

• macOS 26 (Tahoe) or later — the app uses the Liquid Glass APIs.
• Xcode 26 / Swift 6.
• XcodeGen to generate the project: brew install xcodegen.

Build & run

# 1. Generate the Xcode project from project.yml
xcodegen generate

# 2a. Open in Xcode and hit Run
open Differentialis.xcodeproj

# 2b. …or build & launch from the command line
xcodebuild -project Differentialis.xcodeproj -scheme Differentialis \
    -configuration Debug -derivedDataPath build build
open build/Build/Products/Debug/Differentialis.app

Command-line launcher

A thin differentialis shell script is bundled inside the app and opens a diff from any directory. Install it from the app menu: Differentialis ▸ Install Command Line Tool… — one password prompt, then it's on your $PATH forever. (The menu item toggles to Uninstall… once installed.)

Then:

differentialis <path>                       # open a git repository (error if not one)
differentialis fileA.txt fileB.txt           # compare two files (auto-detects text/image/folder)
differentialis folderA folderB               # folder diff
differentialis base.txt mine.txt theirs.txt  # 3-way merge
differentialis --wait fileA.txt fileB.txt    # …and wait until that comparison is closed

Paths are resolved against the current directory. The launcher talks to Differentialis by bundle id (app.differentialis.Differentialis), so it resolves to the registered release install — not a stale Debug build — and works whether the app is already running or not.

git difftool and git mergetool

Add --wait and the launcher blocks until you're done in the app, which is what git's tools need. Put this in ~/.gitconfig:

[diff]
    tool = differentialis
[difftool "differentialis"]
    cmd = differentialis --wait -- \"$LOCAL\" \"$REMOTE\"
[merge]
    tool = differentialis
[mergetool "differentialis"]
    cmd = differentialis --wait --output \"$MERGED\" -- \"$BASE\" \"$LOCAL\" \"$REMOTE\"
    trustExitCode = true

• git difftool opens each file and moves to the next one when you click Done (or close the comparison). git difftool --dir-diff opens one folder comparison. Added and deleted files show their missing side as absent.
• git mergetool opens a 3-way merge whose Save writes the result straight to the conflicted file (as UTF-8). Once no conflict markers are left, saving also closes the merge and git marks the file resolved; a save that still has markers keeps the merge open. Cancel Merge (or closing without a resolved save) leaves the file unresolved.
• git waits until you finish, even if you close the window; reopen it from the Dock to carry on.
• If you installed the command-line tool before --wait existed, uninstall and reinstall it from the app menu.

You can also launch straight into a comparison with open directly:

open Differentialis.app --args fileA.txt fileB.txt      # text or image diff
open Differentialis.app --args folderA folderB          # folder diff
open Differentialis.app --args base.txt mine.txt theirs.txt   # 3-way merge
open Differentialis.app --args /path/to/git/repo        # repository browser

Architecture

Differentialis/
├── Diff/        Myers diff (generic), line diff, char highlights, diff3 merge — pure Swift, unit-tested
├── Git/         system-`git` wrapper (Process): log, diff, blobs, refs, changesets
├── Models/      Comparison + ComparisonSource (file / git blob / working copy), saved-comparison store
├── Features/    Text · Image · Folder · Merge · Repo views
└── DesignSystem/ Liquid Glass components, theme, the app mark

The diff and merge engines have no dependencies — MyersDiff powers both line- and character-level diffs, and a diff3 algorithm drives the 3-way merge. Git is driven through the system git binary, so there is nothing to vendor.

Tests

xcodebuild -project Differentialis.xcodeproj -scheme Differentialis test

Covers Myers and line diff behavior, intra-line highlights, three-way merge, copying changes between pasted texts, folder scanning and filtering, git status parsing, and real temporary-repository checks for reference/index/working-tree comparisons.

CI runs the same suite on a macOS 26 runner for every push to main and every pull request, and checks the README and website: every local link and image resolves, and the site's structured data, FAQ, and sitemap are valid (python3 scripts/check-site.py runs that check locally).

Roadmap

The full, prioritized backlog is in docs/ROADMAP.md. Highlights:

• A diff-style command-line companion — shipped; see the command-line launcher above. A URL scheme is still planned.
• Git mergetool / difftool support — shipped; see git difftool and git mergetool above. Writing the ~/.gitconfig entries for you is still planned.
• PDF export of comparisons

License

MIT © Jenny Speelman