Flatpak, Snap, and AppImage

Your distribution's own package manager — apt on Debian and Mint, pacman on Arch and Manjaro, dnf on Fedora — is still the best way to install most software. It is fast, it is integrated, and the packages are tested against the rest of your system. But it has two limits: every distro ships its own set of packages, and the version you get is whatever your distro decided to freeze. Want a newer release than your distro packages? Want an app your distro does not package at all? Want to hand a friend on a totally different distro the same app? That is where the three tools in this guide come in.

Flatpak, Snap, and AppImage are three different answers to the same question: how do you ship one app that runs on any Linux distribution? Each bundles an app together with the libraries it needs, so it does not depend on exactly what your distro happens to have installed. They differ in how they sandbox the app, where they store its data, whether they auto-update, and how the apps are distributed — and those differences are exactly what this guide is about.

You do not need to read this top to bottom. Skip to whichever format you are dealing with using the table of contents, then read the comparison and the "which should I use?" section near the end to decide. The short version up front: try your native package manager first (the per-distro guides cover that); reach for these when the native package is missing, too old, or you want it sandboxed.

What these three actually are

A quick map before the details, because the names get muddled:

• Flatpak — the most widely adopted of the three, and fully open source (the Flatpak tooling is LGPL-2.1, and its main app store, Flathub, runs on open infrastructure). Apps are sandboxed by default and share common runtimes so they do not each ship a whole copy of every library. Best for everyday desktop GUI apps.
• Snap — Canonical's format, built around the snapd daemon. snapd itself is open source (GPL-3.0), but — being honest, because this site's whole theme is free software — the Snap Store backend that serves the apps is proprietary and single-vendor (only Canonical runs one). Snaps are sandboxed and auto-update. It is the default on Ubuntu.
• AppImage — the simplest idea of all: one file is the whole app. No installation, no daemon, no store. You download a single .AppImage file, mark it executable, and run it. The format and its tooling are open source (MIT). Best for a quick one-off or a portable app you carry on a USB stick.

Tip: these three are not mutually exclusive — you can have all of them installed at once, and many apps are offered in more than one format. Pick per-app based on what is available and what fits the job.

Flatpak: the popular, fully-FOSS option

Flatpak (free software, LGPL-2.1) is the one most desktop users reach for. Apps come from Flathub, a large community app store built on open infrastructure, and each app runs in a sandbox that limits what it can touch on your system. Shared runtimes (the GNOME and KDE platform libraries, for example) mean apps do not each re-ship the same libraries, so the second Flatpak you install is much smaller than the first.

Install Flatpak and add Flathub

First install the flatpak package, then add the Flathub remote so there is somewhere to install apps from. Fedora ships Flatpak preconfigured, but adding Flathub explicitly never hurts:

# Debian / Mint / Ubuntu
sudo apt install flatpak

# Arch / Manjaro
sudo pacman -S flatpak

# Fedora
sudo dnf install flatpak

Now add the Flathub remote. The --if-not-exists flag makes this safe to re-run:

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

Warning: after installing Flatpak for the first time, log out and back in (or reboot) once. This lets your desktop pick up the paths where Flatpak puts application menu entries and icons — otherwise newly installed apps may not show up in your launcher until you do.

Search, install, run

Flatpak apps are named by a reverse-domain application ID like org.videolan.VLC or org.gimp.GIMP. Search Flathub to find the right ID:

# search by name; the "Application ID" column is what you install by
flatpak search vlc

Install an app from the Flathub remote. The first install also pulls in the runtime it needs (a one-time download that later apps reuse):

# install by application ID, from the flathub remote
flatpak install flathub org.videolan.VLC

Run it from your application menu like any other app, or from the terminal:

flatpak run org.videolan.VLC

Tip: installing with plain flatpak install flathub org.videolan.VLC installs it for the whole system (it asks for your password). Add --user to install just for your own account with no password needed — handy on a machine where you are not the administrator: flatpak install --user flathub org.videolan.VLC.

Update and remove

Flatpak does not auto-update by default (your desktop's software center may, if you use one). Update everything yourself in one command:

# update every installed Flatpak app and runtime
flatpak update

Remove an app you no longer want, then clean up runtimes nothing uses any more:

# remove a single app
flatpak uninstall org.videolan.VLC

# remove every runtime that no installed app still needs (reclaims disk space)
flatpak uninstall --unused

To see what you have installed:

flatpak list

Where apps and their data live

Each Flatpak app keeps its own settings and files under your home directory, in a per-app folder. This is tidy — uninstalling and deleting that folder removes every trace — but it does mean a Flatpak app's config is not in the usual ~/.config place:

# per-app data, config, and cache live here, one folder per application ID
ls ~/.var/app/

So VLC's settings, for example, live under ~/.var/app/org.videolan.VLC/. The apps themselves and their shared runtimes are stored separately (system-wide installs under /var/lib/flatpak, per-user installs under ~/.local/share/flatpak).

Permissions and sandboxing

The sandbox is Flatpak's headline feature: an app only gets the access it declares, not free rein over your whole system. Sometimes that is too tight (an app cannot see a folder you want it to) and sometimes you want it tighter. See what an app is allowed to do:

flatpak info --show-permissions org.videolan.VLC

Adjust those permissions with flatpak override. For example, to grant an app access to a folder the sandbox normally hides, or to take an access away:

# give the app read/write access to your Videos folder
flatpak override --user --filesystem=~/Videos org.videolan.VLC

# revoke an access (here, network) from an app
flatpak override --user --unshare=network org.videolan.VLC

If editing permissions on the command line is not your idea of fun, install Flatseal (free software, GPL) — a graphical app that lists every Flatpak you have and lets you toggle its permissions with checkboxes. It is itself a Flatpak:

flatpak install flathub com.github.tchx84.Flatseal

Snap: open daemon, proprietary store

Snap is Canonical's cross-distro format. The client and daemon, snapd, are free software (GPL-3.0), and on Ubuntu Snap is installed and used out of the box (some Ubuntu apps, like the Firefox package, are snaps by default). Snaps are sandboxed and update themselves automatically in the background.

Warning: here is the honest caveat, since this site is about free software. While snapd is open source, the Snap Store backend — the server side that hosts and serves snaps — is proprietary, and Canonical runs the only one. You cannot stand up your own independent snap store the way anyone can host a Flatpak remote or publish an AppImage. Snaps also auto-update on Canonical's schedule, which you cannot fully turn off (only delay). If a fully community-controlled supply chain matters to you, prefer Flatpak or AppImage and reach for Snap mainly when it is the only packaging an app offers.

Install snapd

On Ubuntu it is already there. Elsewhere, install the snapd package and enable its service:

# Debian / Mint
sudo apt install snapd

# Fedora
sudo dnf install snapd

# Arch / Manjaro (from the AUR; e.g. with an AUR helper)
# build and install the snapd package, then enable its socket:
sudo systemctl enable --now snapd.socket

On distros where snaps need a symlink for the classic confinement path to work, create it once (Ubuntu does this for you):

# needed on some non-Ubuntu distros so classic snaps work
sudo ln -s /var/lib/snapd/snap /snap

Tip: after installing snapd for the first time, log out and back in (or reboot) so the snap application menu entries and paths are picked up — same idea as with Flatpak.

Find, install, run

Search the store, then install by the snap's name:

# search for an app
snap find vlc

# install it (asks for your password)
sudo snap install vlc

Run it from your application menu, or just type its name in a terminal — snaps put their commands on your PATH:

vlc

Some apps need broader access than the strict sandbox allows (full development tools, for instance). Those are published as classic snaps, and you must opt in with --classic, which acknowledges the app runs largely outside the sandbox:

# install a snap that needs classic (unsandboxed) confinement
sudo snap install code --classic

Channels: choosing how new (and how stable)

Each snap is published on channels that trade freshness against stability — stable, candidate, beta, and edge. stable is the default; choose another with --channel:

# install the candidate channel instead of stable
sudo snap install vlc --channel=candidate

# switch an already-installed snap to a different channel
sudo snap refresh vlc --channel=stable

Update, list, remove

Snaps refresh themselves automatically, but you can force a check now, list what you have, and remove apps:

# update everything now (snaps also auto-update on their own)
sudo snap refresh

# list installed snaps
snap list

# remove a snap
sudo snap remove vlc

A snap's per-user data lives under ~/snap/<name>/ (with a current symlink pointing at the active revision), so each app keeps its files in one place much like Flatpak does.

AppImage: one file, no install

AppImage is the no-install option, and its tooling is free software (MIT). There is no daemon, no store, and no package database — a single .AppImage file is the entire application, libraries and all. You download it, make it executable, and run it. Delete the file and the app is gone, leaving nothing behind in system folders. This is the same pattern the SD-card checker guide uses to ship its graphical tool.

Download, make executable, run

You get AppImages straight from a project's website or its releases page — there is no central command to search. Once you have the file, mark it executable and run it:

cd ~/Downloads

# mark the file runnable (the chmod step is the one people forget)
chmod +x SomeApp-1.2.3-x86_64.AppImage

# run it
./SomeApp-1.2.3-x86_64.AppImage

That is the whole lifecycle. To "update", you download the newer .AppImage and delete the old one. To "uninstall", you delete the file. To move the app to another machine, you copy the file.

Tip: keep your AppImages in one folder you control — say ~/Applications — rather than leaving them scattered in ~/Downloads. It makes them easy to find, back up, and clean out later.

If it will not start: libfuse2

Most AppImages mount themselves using FUSE, and on newer distros the older library they expect (libfuse2) is no longer installed by default. If an AppImage refuses to run with an error mentioning fuse or libfuse.so.2, install that library:

# Debian / Mint / Ubuntu
sudo apt install libfuse2

# Arch / Manjaro
sudo pacman -S fuse2

# Fedora
sudo dnf install fuse-libs

Tip: as a quick workaround without installing anything, you can extract and run the app without FUSE: ./SomeApp.AppImage --appimage-extract-and-run. Installing libfuse2 is the cleaner long-term fix.

Desktop integration

By itself an AppImage will not appear in your application menu — you launch it from the file. To get a proper menu entry and icon, use a small helper that registers AppImages with your desktop. The modern, friendly choice is Gear Lever (free software, GPL), itself distributed as a Flatpak:

# install Gear Lever from Flathub to manage your AppImages
flatpak install flathub it.mijorus.gearlever

Drop an AppImage into Gear Lever and it moves it to a tidy location, adds it to your menu, and can even check for updates. The older AppImageLauncher (free software) does a similar job and prompts to integrate any AppImage the first time you run it.

The trade-off: minimal sandboxing

Warning: be aware that an AppImage is not sandboxed by default — it runs with the same access as you do, just like any program you download and execute. That is the price of its simplicity. Only run AppImages from sources you trust, exactly as you would any downloaded executable. If sandboxing matters for a given app, prefer its Flatpak (or Snap) instead.

Flatpak vs Snap vs AppImage, side by side

The same app can often be installed all three ways; this is how the formats differ in practice:

Which should I use?

A simple way to decide, in order:

• Try your native package manager first. If apt, pacman, dnf, or pamac has the app at a version you are happy with, install it that way — it is the lightest, best-integrated option, and the per-distro guides cover it. The three formats here are for when the native package is missing or too old.
• Reach for Flatpak for most desktop GUI apps you want sandboxed and kept current. It is fully open source, has the largest catalog (Flathub), and its permission model is the most flexible. For the typical "I want this app and I want it isolated," Flatpak is the default answer.
• Grab an AppImage when you want a quick one-off, a portable app to carry on a USB stick, or to try something without installing anything. Remember it is not sandboxed and will not auto-update.
• Use a Snap when it is the only packaging an app offers, or you are on Ubuntu where it is already set up. Just go in knowing the store backend is proprietary and updates are automatic — the one place this guide's free-software lens flags a caveat.

Quick reference

• Native package first — apt / pacman / dnf; use these three only when it is missing or too old.
• Flatpak setup: flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
• Flatpak: flatpak search NAME, flatpak install flathub APP.ID, flatpak run APP.ID, flatpak update, flatpak uninstall --unused.
• Flatpak permissions: flatpak info --show-permissions APP.ID, flatpak override, or the GUI Flatseal. Data lives in ~/.var/app/.
• Snap: snap find NAME, sudo snap install NAME (add --classic if needed), sudo snap refresh, sudo snap remove NAME. Open daemon, proprietary store, auto-updates.
• AppImage: chmod +x App.AppImage then ./App.AppImage. No install; not sandboxed. Need libfuse2? Install it. Menu entries via Gear Lever.