Dependencies for Building .deb, .rpm, and AppImage Packages for Claude Desktop

Building Claude Desktop for Linux requires only standard packaging tools: dpkg-dev for Debian/Ubuntu, rpm-build for Fedora/RHEL, and appimagetool (auto-downloaded) for AppImage, plus common GNU core utilities available on any Linux distribution.

The aaddrick/claude-desktop-debian repository extracts the official Windows Claude Desktop client, patches it for Linux Cowork mode, and repackages it into three native distribution formats. Understanding the specific dependencies for building .deb, .rpm, and AppImage packages ensures you can produce installable artifacts on any supported Linux distribution without unnecessary bloat.

Package Format Overview

The build system uses format-specific scripts triggered by a top-level orchestrator. Each script constructs the appropriate filesystem layout, generates metadata files, and invokes the native packaging tool.

Package	Build Script	Primary Build Tool	Runtime Target
Debian/Ubuntu (.deb)	scripts/build-deb-package.sh	dpkg-deb (from dpkg-dev)	apt/dpkg-based distros
RPM (Fedora, RHEL, CentOS)	scripts/build-rpm-package.sh	rpmbuild (from rpm-build)	dnf/yum-based distros
AppImage	scripts/build-appimage.sh	appimagetool (downloaded automatically)	Distribution-agnostic portable binary

All formats share a common launcher library (scripts/launcher-common.sh) that provides the --doctor diagnostics, Electron environment setup, and desktop entry generation.

Build Dependencies by Package Format

Debian/Ubuntu (.deb) Dependencies

The Debian package build requires minimal tooling. The script scripts/build-deb-package.sh constructs the DEBIAN/ control directory and uses dpkg-deb to assemble the final archive.

• Required package: dpkg-dev (provides dpkg-deb binary)
• Standard utilities: mkdir, rm, cp, install, chmod (GNU coreutils, present by default)
• Runtime note: No external library dependencies are declared; Electron is fully bundled, and the post-install script only adjusts chrome-sandbox permissions.

Install the build tool on Debian or Ubuntu:

sudo apt update && sudo apt install dpkg-dev

RPM (Fedora/RHEL) Dependencies

The RPM build in scripts/build-rpm-package.sh prepares the RPM build environment, writes a .spec file, and invokes rpmbuild.

• Required package: rpm-build (provides rpmbuild binary)
• Standard utilities: Same GNU coreutils as the Debian flow
• Runtime note: Like the .deb, the resulting RPM embeds the full Electron runtime and declares no external dependencies.

Install the build tool on Fedora:

sudo dnf install rpm-build

On RHEL/CentOS:

sudo yum install rpm-build

AppImage Dependencies

The AppImage build is the most self-contained but requires downloading the packaging tool if not present locally. The script scripts/build-appimage.sh (lines 295-313) handles this automatically.

• Required tool: appimagetool (downloaded from official AppImageKit releases if not in PATH)
• Optional tool: zsyncmake (used only in GitHub Actions to generate .zsync update metadata; the script attempts installation via apt-get, dnf, or zypper)
• Download utility: wget (used to fetch appimagetool)

Pre-install optional tools for local builds:

# Debian/Ubuntu

sudo apt install wget zsync

# Fedora

sudo dnf install wget zsync

# Arch Linux

sudo pacman -S wget zsync

The Build Process Workflow

The top-level build.sh orchestrates the entire pipeline, detecting the host distribution and invoking the appropriate format-specific script. The workflow follows these stages:

1. Download and extract the official Windows installer (handled in build.sh).
2. Patch the Electron bundle to replace the macOS-only native module with the Linux Cowork VM client.
3. Stage the application (app_staging_dir) containing node_modules/electron, app.asar, and app.asar.unpacked.
4. Create package-specific filesystem layout (e.g., DEBIAN/ for .deb, SPECS/ and BUILD/ for .rpm, AppDir for AppImage).
5. Generate metadata files (control for .deb, .spec for .rpm, .desktop for AppImage).
6. Copy shared launcher library (launcher-common.sh) into the package.
7. Create post-install scripts (sets Chrome-sandbox permissions).
8. Run the packaging tool (dpkg-deb --build, rpmbuild -bb, or appimagetool).

The scripts are deliberately lightweight, relying only on standard GNU core utilities plus the specific packaging tool listed for each format.

Practical Build Commands

# Clone the repository

git clone https://github.com/aaddrick/claude-desktop-debian.git
cd claude-desktop-debian

# Build a .deb package (auto-detects distro)

./build.sh --build deb

# Build an .rpm package

./build.sh --build rpm

# Build an AppImage (portable)

./build.sh --build appimage

All three commands produce the final artifact in the build/ directory, named using the convention <package-name>-<version>-<arch>.<ext> (e.g., claude-desktop-1.1.799-amd64.deb).

Verifying Cowork-Mode Runtime Dependencies

The launcher’s --doctor flag prints distro-specific install hints for the Cowork back-ends (bubblewrap, QEMU/KVM, etc.):

./claude-desktop-*.AppImage --doctor

The output uses helper functions in scripts/launcher-common.sh to map each required tool to the appropriate package manager command.

Summary

• Debian/Ubuntu builds require only dpkg-dev (providing dpkg-deb) plus standard GNU coreutils.
• RPM builds need rpm-build (providing rpmbuild) and the same core utilities.
• AppImage builds download appimagetool automatically but optionally use zsyncmake and wget for local builds or CI metadata generation.
• All formats share the scripts/launcher-common.sh library and produce self-contained packages with no external runtime dependencies.
• The top-level build.sh script orchestrates the entire workflow, detecting the host distribution and invoking the appropriate format-specific script.

Frequently Asked Questions

What is the minimum toolset required to build the Debian package?

You only need the dpkg-dev package, which provides the dpkg-deb binary used by scripts/build-deb-package.sh to assemble the .deb archive. Standard utilities like mkdir, cp, and chmod from GNU coreutils are also used, but these are present by default on virtually all Linux systems.

Does the AppImage build require internet access?

Internet access is required only if appimagetool is not already in your PATH. The scripts/build-appimage.sh script checks for the tool locally; if missing, it automatically downloads the appropriate binary from the official AppImageKit releases using wget. Once appimagetool is present, subsequent builds can run offline.

Are there any runtime dependencies for the resulting packages?

No. All three package formats (.deb, .rpm, and AppImage) bundle the complete Electron runtime and the patched Claude Desktop application. The only post-installation action performed is setting the correct permissions on the chrome-sandbox binary. The separate --doctor diagnostic flag can identify optional Cowork-mode back-ends (like bubblewrap or QEMU), but these are not required for the base application to function.

How do I verify my build environment is correctly configured?

Run the top-level build script with the --build flag for your target format. The individual scripts (scripts/build-deb-package.sh, scripts/build-rpm-package.sh, scripts/build-appimage.sh) will fail early with a clear error if the required tools (dpkg-deb, rpmbuild, or appimagetool) are missing. For runtime verification, execute the built AppImage or installed package with the --doctor flag to check Cowork-mode readiness.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}