A fast, friendly git GUI for Linux. Stage and commit your changes,
then press Ctrl+H to browse the history as a graph in the same window, and
press it again to go back. It is a native
Qt 6 app written in Go, through the qute
bindings.
- It never makes you wait. Git runs in the background, never in the window's way, and reads that don't depend on each other run at once: a rescan reads the status, branches, stashes and last commits side by side, and diffs are worked out off screen. Quick work doesn't even flicker the progress bar.
- Changes and history in one place. Colour-coded circles show what happened to each file, the diff follows the file you choose (or drag over), and a double-click stages or unstages it. The history draws every branch and merge as a graph, reads more as you scroll, and starts with a row for what you haven't committed yet. In both, the diff is of one file at a time, the one you choose.
- Interactive rebase without the editor. Right-click a commit, then drag commits into order and pick, fixup, reword, edit, squash or drop each from a dropdown, with the message right below. When git stops, the Branch menu has Continue, Skip and Abort.
- The everyday fixes, built in.
- Quick Fix folds a forgotten change into the last commit, or the last commit into the one before.
- Uncommit takes the last commit back into your files.
- Finish Branch checks out
main, pulls, and deletes the branch you were done with, in one go. - Tag Release tags the next semantic version and pushes it with the branch, in one go.
- Safe by default. Anything that rewrites history or throws work away asks
first, with No as the answer, and says when what it rewrites has been pushed.
Force pushes use
--force-with-lease, and Discard All Changes tells you how many files it will put back and delete. - Stashes that explain themselves. Stash with a message and untracked files if you like. When applying a stash clashes, it keeps the stash, marks the conflicts in orange, and tells you what to do.
- Quick to get around. Every repository you open is a dropdown away, beside
a dropdown of branches. Running
deltaagain brings back the window that is open rather than starting a second copy, and opens the repository you named. - Yours to style. Light, dark or the system's theme, and any font for the code. Every colour, from the diff's lines to the change circles, starts as Solarized's and can be changed.
- It never hangs. Git and ssh never wait on a hidden password prompt: Delta uses your credential helper or ssh agent, or shows git's error.
- Easy to install. One program, released as an AppImage.
delta [folder]Only one copy of Delta runs at a time. Starting it again brings back the window there is, opening the repository the new copy would have opened, unless a command is running or a dialog is open, when the status bar says it was not opened.
It opens the repository holding the folder given. Without one, it opens the repository the current folder is in, or else the one you last opened, or else none, until you open one from File > Open Repository… or Repository in the toolbar. It always starts on the changes, with the first unstaged file chosen, if there is one, as it is whenever a repository is opened. No other repository is opened while a git command is running; the status bar says so.
The toolbar is part of the window's contents, under the menus, rather than docked in the window's header, with a line of its own along its bottom.
| Button | Does |
|---|---|
| Open | Opens a repository, as File > Open Repository… (Ctrl+O) does. |
| New Branch | Makes a branch, and checks it out if you like. |
| Checkout | Switches to another branch. |
| Finish | Finishes with the current branch: checks out main (or master), pulls into it, and deletes the branch, after asking. |
| Rescan | Reads the state of the repository again. |
| Pull | Pulls into the current branch. |
| Push | Pushes the current branch, setting its upstream on the first push. Its arrow opens a Force push option. |
| History | Shows the history in place of the changes until it is pressed again, as Branch > Show History (Ctrl+H) does. |
Under the toolbar, a progress bar the width of the window shows while anything takes more than a moment: a command, reading the status, a diff or the history, or a fetch.
At the toolbar's right, Repository lists every repository you have opened, including one Delta was started in, by the names of their folders in alphabetical order. Hover over one to see its whole path. Choosing one opens it. The list is saved with the settings, with each repository in it only once, and holds up to 20 (a setting), the one opened longest ago going first. The dropdowns grow to fit a long name, up to a limit, and narrow when the window does.
Branch lists the open repository's local branches, with the current one chosen. Choosing another checks it out.
-
Unstaged Changes and Staged Changes, in the sidebar, list the changed files, each with a circle in a colour for what happened to it, Solarized's to start with and set in Settings. The history's list of files has the same circles, and says what happened to a file when you hover over it.
Circle Change Blue Modified Green Added or untracked Red Deleted Violet Renamed Cyan Copied Yellow Type changed Orange In conflict -
Choose a file to see its diff, with added lines in green and removed lines in red, and without git's file headers. Drag over the list to see each file in turn. Double-click a file to stage or unstage it. Ctrl and shift select several.
-
The message pane holds the commit message, with Rescan, Stage Changes, Commit and Push beside it. Stage Changes stages everything listed; when everything is staged it is Unstage Changes, which unstages it all.
-
Force push, beside them and in the toolbar Push's menu, makes the Push buttons force the next push, after asking you first. The two are ticked together, it is remembered between runs, and a successful push clears it.
Ctrl+Palways pushes without forcing, and Remote > Force Push… always forces.
Commit > Quick Fix… (Ctrl+Shift+Q) folds a quick change into the last
commit. With changes not committed, it puts all of them, untracked
files included, into the last commit, keeping its message. With nothing to
commit, it folds the last commit into the one before it, keeping that one's
message. It asks first every time, naming the commits, as it rewrites the
branch's history, and says so if they have been pushed, as the branch will then
need a force push.
Commit > Uncommit… takes the last commit back, after asking: its changes are left in your files, unstaged, as if you had just made them, along with anything you had staged. It says so if the commit has been pushed, as the branch will then need a force push. The first commit of a branch is taken back to none, its files untracked, unless HEAD is detached there, when there is no branch to take it back from. A merge can't be uncommitted.
Forcing uses --force-with-lease: git refuses if the remote has commits you have
not fetched, so you can't overwrite someone else's work without seeing it.
Branch > Discard All Changes… puts the branch back as if it had just been checked out: every change not committed, staged or not, is undone, new files and folders are deleted, and a merge in progress is abandoned. Commits, and files git ignores, are kept. It asks first, saying how many files it will put back and delete, as it can't be undone.
The commits of the current branch are listed at the top, newest first, with a graph at the left drawing how they branch and merge, and any branches and tags at them in brackets. They are read 500 at a time (a setting), and more as you scroll to the end, or straight away while the end is in sight, as when they all fit. If anything is not committed yet, an Uncommitted changes row comes first, staged, unstaged and untracked together.
Below the commits, choose one to see the files it changed on the left, and the diff of one of them on the right: the first to start with, and whichever you choose after, as in the changes. A merge is shown as what it changed against its first parent.
A diff over 4 MiB, of the changes or in the history, is cut off with a note saying so.
Right-click a commit and choose Rebase from here… to rewrite it and the commits after it. A dialog lists them oldest first, as git applies them, each with a dropdown of what to do with it:
| Action | Does |
|---|---|
| Pick | Keeps the commit. |
| Fixup | Folds the commit into the one above, keeping only that message. |
| Reword | Keeps the commit with a new message: the message below the list becomes editable. |
| Edit | Stops after the commit, so that you can change it. |
| Squash | Folds the commit into the one above, keeping both messages. |
| Drop | Leaves the commit out, after asking you first. |
Drag commits into the order to apply them in, one or several at a time. Below the list is the chosen commit's message. The list shows only the start of each commit's first line, and its tooltip the start of its message, so that long messages fit; the message below has all of it. The dialog opens at the size it was last closed at.
Git needs a clean work tree, so commit or stash your changes first. A range holding a merge can't be rebased this way. When the rebase stops, at a commit to edit or one that doesn't apply cleanly, the status bar says so and how far it has got. Resolve and stage in the changes, then choose Continue Rebase from the Branch menu. Anything staged at a commit to edit goes into that commit. Skip Commit leaves out the commit it stopped at, and Abort Rebase puts the branch back as it was.
| Menu | Items | Shortcuts |
|---|---|---|
| File | Open Repository, Settings, Quit | Ctrl+O, Ctrl+,, Ctrl+Q |
| Branch | New Branch, Checkout, Finish Branch, Rename, Delete, Show History, Merge, Abort Merge, Continue Rebase, Skip Commit, Abort Rebase, Discard All Changes | New Branch Ctrl+N, Checkout Ctrl+B, Show History Ctrl+H, Merge Ctrl+M, Discard All Changes Ctrl+Shift+D |
| Commit | Rescan, Stage Changes, Stage Selected, Unstage Selected, Unstage All, Commit, Uncommit, Quick Fix | F5, Ctrl+Shift+S, Ctrl+S, Ctrl+U, Ctrl+Shift+U, Commit Ctrl+Return, Uncommit Ctrl+Shift+Return, Quick Fix Ctrl+Shift+Q |
| Stash | Stash Changes, Apply Stash, Pop Stash, Drop Stash | Stash Changes Ctrl+Shift+Z |
| Remote | Fetch, Pull, Push, Force Push, Tag Release, Add Remote, Rename Remote, Change URL, Remove Remote | Fetch Ctrl+Shift+F, Pull Ctrl+Shift+L, Push Ctrl+P, Force Push Ctrl+Shift+P, Tag Release Ctrl+T |
| Help | About | Ctrl+I |
Finish Branch… is for when you are done with a branch: it checks out main,
or master if there is no main, pulls into it, and deletes the branch you were
on. It asks first, and won't start with changes not committed. If the pull
fails, it stops there and keeps the branch. If git won't delete the branch, as
its commits are not merged, it asks whether to delete it anyway; any other
refusal, as of a branch checked out in another work tree, is told of.
Remote > Tag Release… (Ctrl+T) tags a release of the current branch with
the next semantic version. It reads the highest version
tagged, here and on the remote the branch goes to (its upstream's, or the only
remote), and starts at the next patch release. Change any of major, minor and
patch, as many as you like, but none below what keeps the version above the
latest, so that a release never goes backwards. Tags such as v1.2.3 or
1.2.3 count, and the new tag keeps their v; pre-releases and other tags are
ignored. The tag is annotated, with the message you give or else its name, and
pushed together with the branch, to its upstream's branch if that is on the
remote, or else to one of its own name, so that both arrive or neither does: if the
push is refused, the tag is deleted again. The dialog notes when the commit is
tagged already, and when you have changes not committed, which are not in the
release.
New Branch corrects a name git would refuse when you click OK: spaces become
hyphens, and what git doesn't allow in a branch's name is taken out, so
my new branch? becomes my-new-branch.
Checkout lists every local branch by name, with the current one chosen. Tick Include remote branches to fetch and list the remote ones too: checking one out makes a local branch that tracks it. Cancelling while it fetches lets the fetch finish, as a command, before anything else is started.
Deleting a branch asks first, and asks again if it has commits that have not been merged (merged into neither the current branch nor its upstream).
Stash > Stash Changes… puts everything uncommitted aside, staged or not, with a message if you like, and untracked files too if you tick Include untracked files. Apply Stash… and Pop Stash… put a stash's changes back, with what was staged staged again; Pop then drops the stash. Drop Stash… deletes one, after asking. None of them can be used during a merge or rebase.
If a stash clashes with what was committed since, what doesn't clash is applied, the files that do are left in conflict, shown in orange, and the stash is kept, even by Pop: resolve them and stage them, then drop it. If what was staged can't be put back as it was, Delta asks whether to apply it with everything unstaged. If changes or untracked files are in the way, nothing is applied and git's message says which.
The General tab of File > Settings… sets:
- How many commits of the history are read at a time: 500 to start with, from 50 to 10,000.
- How many repositories opened are remembered: 20 to start with, from 1 to 100.
The User interface tab sets:
- The theme: follow the system, light or dark.
- The font and size of the code (diffs and the commit message). Any installed font can be chosen.
Its table of colours sets every colour Delta gives itself, each starting as one of Solarized's:
- The diff's added lines, removed lines and hunk headers (the cyan
@@ -1,6 +1,7 @@). - The circle beside a changed file, for each thing that can happen to it.
- The progress bar under the toolbar.
The settings are kept in delta/settings.json under the system's configuration
folder (~/.config on Linux), along with the repositories you have opened and
the last of them, whether Force push is ticked, the size of the window and
its panes, which are saved when it closes, and the size of the interactive rebase
dialog. A value in it that can't be used, as one of the wrong type, gives its
default, keeping the rest; a file that is not JSON gives the defaults.
On Linux, Delta adds itself to the desktop's applications every time it
starts, so that it can be opened from the menu and kept in a dock. It writes
~/.local/share/applications/delta.desktop and its icon to
~/.local/share/icons/hicolor/256x256/apps/delta.png (or under
$XDG_DATA_HOME). The entry starts the copy that ran last, wherever it is, which
is the AppImage if it was run from one.
Delta never prompts for a password itself. Git and ssh run without a
terminal, so remote operations need a credential helper, an ssh agent or
SSH_ASKPASS; otherwise they fail with git's error rather than hanging.
Running it needs git 2.31 or later. Building it from source also needs:
- Go 1.27.3 or later
- A C++ compiler (GCC or Clang)
pkg-config- The Qt 6 development files of Qt Widgets, version 6.12 or later, which the bindings are made from
These commands install them:
# Arch, CachyOS, Manjaro
sudo pacman -S git go gcc pkgconf qt6-base
# Debian, Ubuntu
sudo apt install git golang-go build-essential pkg-config qt6-base-dev
# Fedora
sudo dnf install git golang gcc-c++ pkgconf-pkg-config qt6-qtbase-devel
# openSUSE
sudo zypper install git go gcc-c++ pkgconf-pkg-config qt6-base-develWhere the distribution's Qt is older than 6.12, install Qt's own build with
aqtinstall, as the AppImage workflow
does, and point PKG_CONFIG_PATH at its lib/pkgconfig.
If your distribution's Go is too old, get a newer one from
go.dev/dl. To check that Qt can be found, run
pkg-config --modversion Qt6Widgets, which should print 6.12 or later.
The first build compiles the C++ of the Qt bindings, which takes a few minutes.
Later builds take a few seconds. Nothing is built in the project's folder but
the program itself, ./delta, and the AppImage, both ignored by git.
make build # builds ./delta
make run # builds and runs it
make install # installs it in $GOBIN or $(go env GOPATH)/bin, to run from anywhere
make test # runs the tests, which need git and draw offscreen
make race # runs the tests with the race detector
make vet # runs go vet
make bench # measures what Delta asks of Qt most; compare runs with benchstat
make screenshots # redraws the pictures in docs/
make appimage # builds the AppImage in /tmp/delta-build, leaving it here
make clean # removes ./delta, the AppImage and /tmp/delta-buildTo change the icon, replace internal/appicon/appicon.png with another 256×256
PNG.
Pushing a tag starting with v runs the GitHub workflow, which builds the
AppImage and attaches it to a release of that name:
git tag v1.0.0 && git push origin v1.0.0It can also be run by hand from the repository's Actions tab, which leaves the AppImage as an artifact of the run to download.
Delta-*-x86_64.AppImage is one file with Qt inside it. Make it
executable and run it. It works under X11 and Wayland, on systems with glibc 2.35
or later, such as Ubuntu 22.04 and Debian 12. git is not included.
make appimage runs the same script locally, but the result only runs on systems
at least as new as the one that built it. The releases are built on Ubuntu 22.04
for that reason.
GNU General Public License version 3. See LICENSE.

