How to Install GitHub Desktop on Debian 13, 12 and 11

GitHub Desktop fills a practical gap on Debian when you want GitHub pull requests, branch switching, commits, and conflict review in a graphical workflow instead of doing every Git task from a terminal. To install GitHub Desktop on Debian, use the community-maintained shiftkey/desktop Linux fork; GitHub’s own Desktop builds are still only supported on Windows and macOS.

The package source matters. The MWT APT mirror keeps updates inside APT but currently publishes only an amd64 package and may lag the newest GitHub release. Direct GitHub release packages cover more Debian architectures, while Flatpak and AppImage are useful alternatives when you prefer Flathub delivery or a portable test copy.

Install GitHub Desktop on Debian

Choose a GitHub Desktop Installation Method

Choose one install method and keep its update and removal path separate. Mixing the APT repository with direct packages can leave you unsure which source owns future updates.

Method	Source or Channel	Update Behavior	Best For	Trade-offs
APT repository	MWT mirror	Updates through APT	amd64 systems that prefer package-manager updates	Repository currently trails the newest GitHub release and does not publish ARM packages
Direct .deb	shiftkey GitHub releases	Manual re-download when a new release appears	Users who need the latest release or arm64/armhf assets	No automatic repository updates
Flatpak	Flathub	Updates through Flatpak	Users who already manage desktop apps through Flathub	Flathub lists the app as unverified and potentially unsafe because it needs broad desktop permissions
AppImage	shiftkey GitHub releases	Manual replacement	Portable testing without installing a package	No automatic updates or normal desktop menu integration unless you add that separately

Check Your Debian Architecture

Check your architecture before choosing a method. Debian package assets use Debian architecture names such as amd64, arm64, and armhf; AppImage assets use x86_64, arm64, and armv7l.

dpkg --print-architecture

amd64

The commands that change packages or system sources use sudo. Configure a Debian sudo user first if your account cannot run administrative commands.

Install GitHub Desktop from the MWT APT Repository

The MWT mirror is the best fit when you want GitHub Desktop to update through APT with your other packages. Use this method only on amd64 systems because the current repository metadata publishes only an amd64 package.

Install APT Repository Prerequisites

Update package metadata and install the tools used to fetch HTTPS sources and process the repository signing key. Minimal Debian installs often lack curl and gpg.

sudo apt update
sudo apt install curl gpg ca-certificates

Add the MWT Signing Key and Source

Import the MWT signing key, then create a DEB822 source file that points APT at the mirror. The source is pinned to amd64 because that is the architecture currently published by the repository.

if [ "$(dpkg --print-architecture)" = "amd64" ]; then
  curl -fsSL https://mirror.mwt.me/shiftkey-desktop/gpgkey | sudo gpg --dearmor --yes -o /usr/share/keyrings/mwt-desktop.gpg

  printf '%s\n' \
  'Types: deb' \
  'URIs: https://mirror.mwt.me/shiftkey-desktop/deb/' \
  'Suites: any' \
  'Components: main' \
  'Architectures: amd64' \
  'Signed-By: /usr/share/keyrings/mwt-desktop.gpg' | sudo tee /etc/apt/sources.list.d/mwt-desktop.sources > /dev/null
else
  printf 'The MWT APT repository currently publishes GitHub Desktop packages for amd64 only.\n'
fi

Refresh APT and check that the package candidate comes from the MWT mirror before installing it.

sudo apt update
apt-cache policy github-desktop

github-desktop:
  Installed: (none)
  Candidate: 3.4.12-linux1
  Version table:
     3.4.12-linux1 500
        500 https://mirror.mwt.me/shiftkey-desktop/deb any/main amd64 Packages

If your output shows Candidate: (none), do not continue with the install. Recheck your architecture and source file first.

Install and Verify the APT Package

Install the package from the configured repository.

sudo apt install github-desktop

Verify the installed package with Debian package metadata instead of launching the graphical app in a terminal-only session.

dpkg-query -W -f='${binary:Package} ${Version}\n' github-desktop

github-desktop 3.4.12-linux1

Install GitHub Desktop with the Direct .deb Package

The direct .deb method uses the current release assets from the shiftkey GitHub repository. It is useful when you want the newest package, need an ARM Debian package, or do not want to add a third-party APT source.

Download the .deb Package and Checksum

Install download prerequisites, set the current release version, and download the package plus its SHA-256 sidecar for your Debian architecture. The current direct release package is 3.4.13-linux1.

sudo apt update
sudo apt install curl ca-certificates

VERSION="3.4.13-linux1"
ARCH="$(dpkg --print-architecture)"

case "$ARCH" in
  amd64|arm64|armhf)
    curl -fLO "https://github.com/shiftkey/desktop/releases/download/release-${VERSION}/GitHubDesktop-linux-${ARCH}-${VERSION}.deb"
    curl -fLO "https://github.com/shiftkey/desktop/releases/download/release-${VERSION}/GitHubDesktop-linux-${ARCH}-${VERSION}.deb.sha256"
    ;;
  *)
    printf 'No matching GitHub Desktop .deb asset is published for this Debian architecture.\n'
    ;;
esac

Continue only after both the package and checksum files download successfully. The upstream sidecar contains only the hash, so pair it with the local filename before running sha256sum -c.

printf '%s  %s\n' "$(cat GitHubDesktop-linux-${ARCH}-${VERSION}.deb.sha256)" "GitHubDesktop-linux-${ARCH}-${VERSION}.deb" | sha256sum -c -

GitHubDesktop-linux-amd64-3.4.13-linux1.deb: OK

Install and Verify the .deb Package

Install the local package with APT so Debian can resolve dependencies from your configured repositories.

sudo apt install "./GitHubDesktop-linux-${ARCH}-${VERSION}.deb"

Confirm the installed version after APT finishes.

dpkg-query -W -f='${binary:Package} ${Version}\n' github-desktop

github-desktop 3.4.13-linux1

Install GitHub Desktop from Flathub

The Flatpak method installs the Flathub build io.github.shiftey.Desktop. Use it when you already manage desktop applications through Flatpak or want a package that updates independently of APT.

Flathub currently marks this app as unverified and potentially unsafe because it requires broad desktop permissions, including filesystem and device access. Treat this method as a Flathub packaging choice, not as a stronger isolation or official-support path.

Install Flatpak first if it is not already available. For a deeper setup walkthrough, use the Flatpak installation guide for Debian.

sudo apt update
sudo apt install flatpak

Add Flathub using its current remote descriptor.

sudo flatpak remote-add --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo

Install GitHub Desktop from the Flathub remote.

sudo flatpak install flathub io.github.shiftey.Desktop

Verify the installed Flatpak version with a stable metadata field.

flatpak info --show-version io.github.shiftey.Desktop

3.4.13-linux1

Run GitHub Desktop with AppImage

Use AppImage for a portable test copy or a temporary run without installing a Debian package. It is less convenient for daily use because you must replace the file manually when a new release appears.

Install the FUSE Runtime Dependency

AppImage needs the FUSE 2 compatibility library. Debian 11 and 12 use libfuse2; Debian 13 uses the renamed libfuse2t64 package.

. /etc/os-release

case "$VERSION_ID" in
  11|12)
    sudo apt install libfuse2
    ;;
  13)
    sudo apt install libfuse2t64
    ;;
  *)
    printf 'Check the FUSE 2 compatibility package for this Debian release before continuing.\n'
    ;;
esac

Download, Verify, and Run the AppImage

Map Debian’s package architecture name to the AppImage asset name, then download the current release and checksum.

VERSION="3.4.13-linux1"

case "$(dpkg --print-architecture)" in
  amd64)
    APPIMAGE_ARCH="x86_64"
    ;;
  arm64)
    APPIMAGE_ARCH="arm64"
    ;;
  armhf)
    APPIMAGE_ARCH="armv7l"
    ;;
  *)
    APPIMAGE_ARCH=""
    printf 'No matching GitHub Desktop AppImage asset is published for this architecture.\n'
    ;;
esac

if [ -n "$APPIMAGE_ARCH" ]; then
  curl -fLO "https://github.com/shiftkey/desktop/releases/download/release-${VERSION}/GitHubDesktop-linux-${APPIMAGE_ARCH}-${VERSION}.AppImage"
  curl -fLO "https://github.com/shiftkey/desktop/releases/download/release-${VERSION}/GitHubDesktop-linux-${APPIMAGE_ARCH}-${VERSION}.AppImage.sha256"
fi

Continue only after both AppImage files download successfully. Verify the AppImage, mark it executable, and launch it from the current directory.

printf '%s  %s\n' "$(cat GitHubDesktop-linux-${APPIMAGE_ARCH}-${VERSION}.AppImage.sha256)" "GitHubDesktop-linux-${APPIMAGE_ARCH}-${VERSION}.AppImage" | sha256sum -c -
chmod +x "GitHubDesktop-linux-${APPIMAGE_ARCH}-${VERSION}.AppImage"
./GitHubDesktop-linux-${APPIMAGE_ARCH}-${VERSION}.AppImage

GitHubDesktop-linux-x86_64-3.4.13-linux1.AppImage: OK

Launch GitHub Desktop on Debian

Launch from the Terminal

APT and direct .deb installations provide the github-desktop launcher.

github-desktop

Flatpak installations use the application ID.

flatpak run io.github.shiftey.Desktop

AppImage runs from the directory where you downloaded it unless you move the file to a permanent location.

Launch from the Application Menu

Package and Flatpak installations export a desktop launcher on normal Debian desktop sessions. Open the applications menu, search for GitHub Desktop, and launch it from there.

Complete First-Use Setup

Sign in to GitHub from the welcome screen if you want repository cloning, pull requests, and publishing to use your GitHub account. If commit authorship looks wrong, configure your Git username and email before creating new commits.

Update GitHub Desktop on Debian

Update an APT Repository Installation

APT repository installations update through the normal Debian package workflow.

sudo apt update
sudo apt install --only-upgrade github-desktop

Update a Direct .deb or AppImage Installation

Direct .deb and AppImage installations do not track a repository. Return to the current GitHub release, download the newer asset and checksum, verify the file, then repeat the matching install or launch steps.

A small helper script removes most of that repeat work while keeping the release URL and checksum check visible. The script resolves the latest shiftkey release through the GitHub API, selects the correct Debian or AppImage asset for your architecture, verifies the SHA-256 sidecar, and then updates either the installed .deb package or a managed AppImage file.

Install the helper prerequisites first. The script uses Python only to parse the GitHub release JSON safely, avoiding fragile text parsing.

sudo apt update
sudo apt install curl ca-certificates python3

Create the helper in your user account. The script supports deb, appimage, and an optional --download-only check that verifies the current asset without installing or replacing anything.

install -d "$HOME/.local/bin"

cat <<'EOF' | tee "$HOME/.local/bin/update-github-desktop-direct" > /dev/null
#!/usr/bin/env bash
set -euo pipefail

usage() {
  printf 'Usage: %s deb|appimage [--download-only]\n' "$(basename "$0")" >&2
}

mode="${1:-}"
download_only=0

if [ "${2:-}" = "--download-only" ]; then
  download_only=1
elif [ -n "${2:-}" ]; then
  usage
  exit 2
fi

case "$mode" in
deb | appimage) ;;
*)
  usage
  exit 2
  ;;
esac

need_cmd() {
  if ! command -v "$1" >/dev/null 2>&1; then
    printf 'Missing required command: %s\n' "$1" >&2
    exit 1
  fi
}

for cmd in curl python3 sha256sum dpkg mktemp install; do
  need_cmd "$cmd"
done

repo_api="https://api.github.com/repos/shiftkey/desktop/releases/latest"
deb_arch="$(dpkg --print-architecture)"

case "$mode:$deb_arch" in
deb:amd64 | deb:arm64 | deb:armhf)
  asset_arch="$deb_arch"
  asset_ext="deb"
  ;;
appimage:amd64)
  asset_arch="x86_64"
  asset_ext="AppImage"
  ;;
appimage:arm64)
  asset_arch="arm64"
  asset_ext="AppImage"
  ;;
appimage:armhf)
  asset_arch="armv7l"
  asset_ext="AppImage"
  ;;
*)
  printf 'No GitHub Desktop %s asset is published for Debian architecture: %s\n' "$mode" "$deb_arch" >&2
  exit 1
  ;;
esac

workdir="$(mktemp -d)"

cleanup() {
  rm -rf "$workdir"
}
trap cleanup EXIT

release_json="$workdir/latest.json"
curl -fsSL "$repo_api" -o "$release_json"

IFS=$'\t' read -r tag version asset_name asset_url checksum_name checksum_url < <(
  python3 - "$release_json" "$asset_arch" "$asset_ext" <<'PY'
import json
import sys

path, asset_arch, asset_ext = sys.argv[1:]
with open(path, encoding="utf-8") as handle:
    data = json.load(handle)

tag = data.get("tag_name", "")
if not tag:
    raise SystemExit("GitHub API response did not include tag_name")

version = tag[len("release-"):] if tag.startswith("release-") else tag
asset_name = f"GitHubDesktop-linux-{asset_arch}-{version}.{asset_ext}"
checksum_name = f"{asset_name}.sha256"
assets = {
    asset.get("name"): asset.get("browser_download_url")
    for asset in data.get("assets", [])
}
missing = [
    name for name in (asset_name, checksum_name)
    if not assets.get(name)
]
if missing:
    raise SystemExit("Missing release asset(s): " + ", ".join(missing))

print(
    tag,
    version,
    asset_name,
    assets[asset_name],
    checksum_name,
    assets[checksum_name],
    sep="\t",
)
PY
)

printf 'Latest GitHub Desktop release: %s\n' "$tag"
printf 'Selected asset: %s\n' "$asset_name"

if [ "$mode" = "deb" ] && [ "$download_only" -eq 0 ]; then
  installed_version="$(dpkg-query -W -f='${Version}' github-desktop 2>/dev/null || true)"
  if [ "$installed_version" = "$version" ]; then
    printf 'Installed .deb package is already current: %s\n' "$installed_version"
    exit 0
  fi
fi

if [ "$mode" = "appimage" ] && [ "$download_only" -eq 0 ]; then
  app_dir="${GITHUB_DESKTOP_APPIMAGE_DIR:-$HOME/Applications}"
  target="$app_dir/GitHubDesktop.AppImage"
  version_file="$target.version"
  if [ -f "$version_file" ] && [ "$(cat "$version_file")" = "$version" ]; then
    printf 'Managed AppImage is already current: %s\n' "$version"
    printf 'Path: %s\n' "$target"
    exit 0
  fi
fi

asset_path="$workdir/$asset_name"
checksum_path="$workdir/$checksum_name"

curl -fsSL --retry 3 --retry-delay 2 -o "$asset_path" "$asset_url"
curl -fsSL --retry 3 --retry-delay 2 -o "$checksum_path" "$checksum_url"

checksum="$(tr -d '[:space:]' <"$checksum_path")"
if [[ ! "$checksum" =~ ^[0-9a-fA-F]{64}$ ]]; then
  printf 'Unexpected checksum format in %s\n' "$checksum_name" >&2
  exit 1
fi

printf '%s  %s\n' "$checksum" "$asset_path" | sha256sum -c -

if [ "$download_only" -eq 1 ]; then
  printf 'Download-only check completed in: %s\n' "$workdir"
  trap - EXIT
  exit 0
fi

case "$mode" in
deb)
  sudo apt install "$asset_path"
  dpkg-query -W -f='${binary:Package} ${Version}\n' github-desktop
  ;;
appimage)
  app_dir="${GITHUB_DESKTOP_APPIMAGE_DIR:-$HOME/Applications}"
  target="$app_dir/GitHubDesktop.AppImage"
  version_file="$target.version"

  install -d "$app_dir"
  if [ -e "$target" ] && [ ! -f "$target" ]; then
    printf 'Refusing to replace non-file path: %s\n' "$target" >&2
    exit 1
  fi
  if [ -f "$target" ]; then
    cp -a "$target" "$target.previous"
    printf 'Previous AppImage saved as: %s\n' "$target.previous"
  fi

  install -m 0755 "$asset_path" "$target"
  printf '%s\n' "$version" >"$version_file"
  printf 'Updated AppImage: %s\n' "$target"
  printf 'Run it with: %s\n' "$target"
  ;;
esac
EOF

chmod +x "$HOME/.local/bin/update-github-desktop-direct"

Run the helper with no arguments once to confirm it is executable and shows its usage text.

"$HOME/.local/bin/update-github-desktop-direct"

Usage: update-github-desktop-direct deb|appimage [--download-only]

Use --download-only when you want to verify the latest release asset before changing the system. This mode leaves the verified files in a temporary directory so you can inspect or remove them manually.

"$HOME/.local/bin/update-github-desktop-direct" deb --download-only

Latest GitHub Desktop release: release-3.4.13-linux1
Selected asset: GitHubDesktop-linux-amd64-3.4.13-linux1.deb
/tmp/tmp.xxxxx/GitHubDesktop-linux-amd64-3.4.13-linux1.deb: OK
Download-only check completed in: /tmp/tmp.xxxxx

Run the deb mode to update a direct .deb installation. If the installed package already matches the current release, the helper exits before downloading anything.

"$HOME/.local/bin/update-github-desktop-direct" deb

Latest GitHub Desktop release: release-3.4.13-linux1
Selected asset: GitHubDesktop-linux-amd64-3.4.13-linux1.deb
/tmp/tmp.xxxxx/GitHubDesktop-linux-amd64-3.4.13-linux1.deb: OK
github-desktop 3.4.13-linux1

Run the appimage mode to manage a stable AppImage path at ~/Applications/GitHubDesktop.AppImage. Set GITHUB_DESKTOP_APPIMAGE_DIR first if you prefer a different directory.

"$HOME/.local/bin/update-github-desktop-direct" appimage

Latest GitHub Desktop release: release-3.4.13-linux1
Selected asset: GitHubDesktop-linux-x86_64-3.4.13-linux1.AppImage
/tmp/tmp.xxxxx/GitHubDesktop-linux-x86_64-3.4.13-linux1.AppImage: OK
Updated AppImage: /home/username/Applications/GitHubDesktop.AppImage
Run it with: /home/username/Applications/GitHubDesktop.AppImage

Update a Flatpak Installation

Update the Flathub app and any required runtimes with Flatpak.

sudo flatpak update io.github.shiftey.Desktop

Remove GitHub Desktop from Debian

Remove an APT Repository Installation

Remove the package first, then remove the source and key only if you added them for GitHub Desktop.

sudo apt remove github-desktop
sudo apt autoremove

sudo rm -f /etc/apt/sources.list.d/mwt-desktop.sources
sudo rm -f /usr/share/keyrings/mwt-desktop.gpg
sudo apt update

Confirm the mirror no longer provides the package candidate.

apt-cache policy github-desktop

github-desktop:
  Installed: (none)
  Candidate: (none)
  Version table:

Remove a Direct .deb Installation

A direct .deb installation uses the same installed package name but has no repository source to clean up.

sudo apt remove github-desktop
sudo apt autoremove

Remove a Flatpak Installation

Uninstall the Flathub app by application ID.

sudo flatpak uninstall io.github.shiftey.Desktop

List installed apps afterward if you want absence proof.

flatpak list --app --columns=application,origin,installation | grep '^io.github.shiftey.Desktop' || true

Remove unused runtimes separately after reviewing the prompt.

sudo flatpak uninstall --unused

Remove an AppImage File

Delete the AppImage file from the directory where you stored it.

rm -f GitHubDesktop-linux-*.AppImage
rm -f "$HOME/Applications/GitHubDesktop.AppImage"
rm -f "$HOME/Applications/GitHubDesktop.AppImage.previous"
rm -f "$HOME/Applications/GitHubDesktop.AppImage.version"

Remove the Direct-Asset Update Helper

If you created the direct .deb and AppImage update helper, remove the user-local script as well.

rm -f "$HOME/.local/bin/update-github-desktop-direct"

Remove Local GitHub Desktop Data

Removing user data deletes local GitHub Desktop preferences, cached state, and account-related application files. Keep your repository working directories unless you intentionally want to remove those projects too.

For APT and direct .deb installations, remove the native application data paths from your user account.

rm -rf "$HOME/.config/GitHub Desktop"
rm -rf "$HOME/.cache/GitHub Desktop"

For Flatpak installations, remove the sandbox data path from your user account.

rm -rf "$HOME/.var/app/io.github.shiftey.Desktop"

Troubleshoot GitHub Desktop on Debian

APT Shows No GitHub Desktop Candidate

If apt-cache policy github-desktop shows Candidate: (none), check your architecture and source file. The MWT APT method currently publishes only amd64.

dpkg --print-architecture
cat /etc/apt/sources.list.d/mwt-desktop.sources

The source should include the MWT URI, Suites: any, Components: main, Architectures: amd64, and the Signed-By path used when importing the key.

Shiftkey APT Repository Fails TLS Verification

The upstream Shiftkey APT hostname currently presents a certificate that does not match apt.packages.shiftkey.dev. Do not bypass certificate verification with -k or --insecure. Use the MWT mirror or the direct .deb release asset instead.

curl -I https://apt.packages.shiftkey.dev/gpg.key

Direct .deb Installation Has Dependency Errors

Install local .deb files with APT, not plain dpkg -i, so Debian can resolve dependencies from your configured repositories.

sudo apt install "./GitHubDesktop-linux-${ARCH}-${VERSION}.deb"

If an earlier dpkg -i attempt left a broken transaction, let APT finish dependency repair.

sudo apt --fix-broken install

AppImage Does Not Start

If the AppImage does nothing when double-clicked or reports a FUSE error, confirm it is executable and that the correct FUSE 2 compatibility package is installed for your Debian release.

chmod +x GitHubDesktop-linux-*.AppImage
./GitHubDesktop-linux-*.AppImage

Flatpak Cannot Find the Flathub Remote

If Flatpak reports that no flathub remote exists, list configured remotes and add Flathub again with the canonical descriptor URL.

flatpak remotes --system
sudo flatpak remote-add --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo

Retry the install after the remote appears.

sudo flatpak install flathub io.github.shiftey.Desktop

Sign-In, SSH, or Clone Operations Fail

GitHub account sign-in and repository access depend on GitHub authentication, your browser handoff, and any SSH keys used for private repositories. Check the GitHub Desktop documentation for account-specific sign-in problems, and verify SSH key setup on Debian if your repository uses SSH remotes.

If terminal Git commands also fail, confirm Git is installed and can reach GitHub before blaming the desktop client.

git ls-remote https://github.com/octocat/Hello-World.git

Network failures at this step point to DNS, proxy, certificate, or Debian firewall configuration outside GitHub Desktop.

Conclusion

GitHub Desktop is installed on Debian with a clear update owner: APT, direct release assets, Flatpak, or AppImage. For terminal workflows alongside the desktop client, install Git on Debian, then review common tasks such as switching Git branches or undoing the last Git commit.