Chapter 5: AppImage — Portable Single-File Applications

An AppImage is a single executable file that contains an application and all its dependencies. You download it, make it executable, and run it — no installation, no root access, no package manager. When you are done, delete the file and it is gone without a trace.

This simplicity makes AppImage a popular choice for software that targets all Linux distributions equally, especially creative tools, game engines, and independent software.

Running an AppImage

Three steps:

# 1. Download the .AppImage file (from the developer's website)
wget https://example.com/MyApp-1.0-x86_64.AppImage

# 2. Make it executable
chmod +x MyApp-1.0-x86_64.AppImage

# 3. Run it
./MyApp-1.0-x86_64.AppImage

That is the entire workflow. No sudo, no package manager, no uninstaller.

Organising AppImages

There is no standard install location for AppImages. A common convention is to keep them in ~/Applications/:

mkdir -p ~/Applications
mv MyApp-1.0-x86_64.AppImage ~/Applications/
chmod +x ~/Applications/MyApp-1.0-x86_64.AppImage

This keeps them out of your home directory clutter while keeping them accessible.

Desktop Integration

By default, AppImages do not appear in your application launcher. You can integrate them in two ways:

Option 1 — Let the AppImage do it. Some AppImages prompt you on first run:

Would you like to integrate MyApp with your system? [Y/n]

Answering yes creates a .desktop entry and extracts the icon automatically.

Option 2 — Do it manually. The code/install-appimage.sh script in this book automates the process. In brief, it:

1. Extracts the app icon from the AppImage
2. Copies it to ~/.local/share/icons/
3. Creates a .desktop file in ~/.local/share/applications/
4. Runs update-desktop-database to register the entry

After integration, the app appears in your launcher like any other application.

The FUSE Requirement

AppImages use FUSE (Filesystem in Userspace) to mount the embedded filesystem at runtime. On modern Ubuntu (22.04+), the required libfuse2 library is available but may not be installed:

sudo apt install libfuse2

If FUSE is unavailable or you prefer not to use it, extract the AppImage contents to a directory instead:

./MyApp.AppImage --appimage-extract

This creates a squashfs-root/ directory. Run the app from there:

./squashfs-root/AppRun

You can then create a desktop file pointing to squashfs-root/AppRun.

Updating AppImages

AppImages do not auto-update. Updating means downloading a new file. However, some AppImages support delta updates via appimageupdatetool:

# Install appimageupdatetool (itself an AppImage)
wget https://github.com/AppImage/AppImageUpdate/releases/download/continuous/appimageupdatetool-x86_64.AppImage
chmod +x appimageupdatetool-x86_64.AppImage

# Update an AppImage that supports it
./appimageupdatetool-x86_64.AppImage MyApp.AppImage

Not all AppImages include update metadata. Check the developer’s documentation.

Security Considerations

AppImages have no sandboxing. When you run an AppImage, it runs with your full user permissions — the same as any binary you download and execute. This is fundamentally different from Snap or Flatpak.

Practical implications:

• Only run AppImages from sources you trust. The developer’s official website, GitHub releases pages with verified checksums, or well-known mirrors.
• Verify checksums when provided. Many developers publish SHA256 checksums alongside their AppImage:

sha256sum MyApp.AppImage
# Compare output to the checksum on the download page

• AppImages do not receive automatic security updates. You must check for new versions manually or subscribe to the developer’s release notifications.

AppImage vs Snap vs Flatpak

Key Takeaways

• Download, chmod +x, run — three steps, no package manager needed.
• Keep AppImages in ~/Applications/ for organisation.
• Install libfuse2 if AppImages fail to launch; use --appimage-extract as a fallback.
• AppImages are not sandboxed — only run them from trusted sources.
• Verify checksums when the developer provides them.