Picking the Right Universal Package Format for Ubuntu

Ubuntu ships with Snap already wired into the system, and most newcomers never have to think about how their software arrives. The moment a wanted application is missing from the Software store, three names appear in forums and chat groups: Snap, Flatpak, and AppImage. Each is a way of bundling an application so it can run on almost any Linux distribution without a long list of system libraries to satisfy first.

For Australians running Ubuntu on a laptop bought from JB Hi-Fi, a home office PC, or an older desktop, the choice between these formats affects download size, startup speed, security updates, and how well an app plays with the rest of the desktop. Picking one over the others is rarely about brand loyalty. It is about matching a format to the hardware, the internet connection, and the habits of the person at the keyboard.

What each format actually is

Snap is a package format developed by Canonical, the company behind Ubuntu. A Snap is a compressed filesystem that includes the application, its runtime libraries, and a manifest describing what the app is allowed to do. Because everything is bundled together, a Snap behaves the same way on a fresh Ubuntu install as on a community spin of Fedora or a rolling-release Arch system. The system that manages Snaps is called snapd, a background service that handles installs, automatic updates, and confinement rules.

Flatpak is a similar idea with a different origin. It grew out of the earlier Click format and the work of Red Hat developer Alexander Larsson. Flatpaks are built against shared runtimes, large bundles of common libraries that many applications can rely on at once. A newly installed Flatpak often downloads less on its first run, because the runtime may already be present from another app. The host only needs the flatpak daemon to launch these bundles.

AppImage is the oldest of the three in spirit, tracing back to tools like Klik and PortableLinuxApps. A single AppImage file is essentially a self-mounting ISO image. Download one file, mark it executable, and double-click to launch. There is no central daemon, no runtime to fetch, and no background service. The application runs from wherever the file is stored, which is why many users keep a folder of AppImages on a USB stick for portable use.

Updates and security

Snap was designed with automatic updates as a core feature. By default, snapd refreshes installed Snaps several times a day, quietly downloading new versions in the background. Most users never see this happen, and security patches reach the machine quickly. The trade-off is that updates are largely out of the user's hands. Some applications can hold back major version changes through channels, but routine patches are pushed on a schedule set by the snap store and the developer. Flatpak also supports automatic updates, but the experience is more flexible. The user can configure how often updates run, exclude specific applications, or trigger them manually from the command line. Security is handled through Portals, a set of interfaces that let a sandboxed app ask the desktop for permission to use the camera, microphone, or file system.

AppImage takes the opposite approach. There is no built-in update mechanism, although some applications bundle their own updater. If a developer ships a new version, the user is expected to download it and replace the old file. Security depends on the user trusting the source of the file and on the distribution's own mitigations like ASLR and seccomp. There is no central store to vet uploads, which is both the format's greatest strength and its biggest weakness.

Storage use

A fresh Snap often looks bigger than a traditional .deb package, because it includes its own runtime libraries. Visual Studio Code, for example, ships as a Snap weighing around 250 megabytes, while the equivalent .deb is closer to 80. Over time, multiple Snaps do not all duplicate the same libraries, and the difference narrows. Snap also uses loop devices to mount each package, which some users find unusual when inspecting disk usage.

Flatpak shares libraries between applications through runtimes, so a machine with many Flatpaks installed ends up using less disk than the equivalent collection of Snaps. The first Flatpak installed is heavy because the runtime must be downloaded, but every subsequent app that uses the same runtime reuses what is already there. On a system with a small SSD, where a few gigabytes of savings can matter, this is a meaningful advantage. AppImage has the smallest footprint per file, because nothing is installed in the traditional sense. The cost is that every AppImage carries its own dependencies inside the squashfs container, so ten different AppImages may duplicate libraries that a single Snap or Flatpak runtime would store once. For one application used occasionally, AppImage is the leanest option.

Performance and startup time

Startup speed is where AppImage often wins, because there is no daemon to talk to and no runtime to mount before the application launches. The binary inside the squashfs image runs almost as quickly as a natively compiled program. On older hardware, such as a refurbished ThinkPad from an office clearance sale, this can make a real difference for short-lived utilities that are opened and closed often.

Flatpak performance is usually very close to native, because the runtime libraries are already extracted on disk and the application starts through a thin launcher. There is a small overhead for setting up the sandbox, but for most desktop programs the difference is imperceptible. Heavy applications like GIMP or Kdenlive launch only a fraction of a second slower than their .deb counterparts in normal use.

Snap has historically been slower at startup, particularly in the early days of the format, when loop device setup and confinement checks added noticeable delay. The gap has narrowed as snapd has matured, and most recent versions launch as quickly as other formats. On a low-spec machine with a mechanical hard drive, users occasionally report a half-second pause before a Snap app appears.

Integration with GNOME and Ubuntu

Ubuntu uses GNOME as its default desktop, and Snap was built with this environment in mind. The Software centre, the file manager, and the application menu are all wired to interact with snapd. When a Snap is updated, the system tray and the application launcher reflect the change without extra configuration. Ubuntu Touch, the mobile variant of the operating system that runs on a handful of community devices, also uses Snap as its primary package format.

Flatpak integrates with GNOME as well, particularly through the GNOME Software centre, which can display and install Flatpaks from Flathub once the Flatpak plugin is enabled. KDE users get equally smooth integration through Discover. On Ubuntu, the experience is a touch less automatic than Snap, but most users only notice the difference when they first install the Flatpak plugin and add the Flathub remote. AppImage relies on the file manager for integration. Double-clicking an AppImage in Nautilus works out of the box on Ubuntu, and tools like AppImageLauncher can move downloaded files into a central folder, generate a desktop entry, and offer a simple update interface. Without such a helper, AppImage behaves like a portable program.

Where Australian conditions change the decision

Internet access in Australia is famously uneven, and that shapes how these formats feel in practice. A household in Sydney, Melbourne, or Brisbane on a fibre-to-the-premises NBN plan can pull down a 300 megabyte Snap without thinking about it, but a property on satellite broadband through Sky Muster has strict monthly data caps that make large downloads painful. For someone on a Sky Muster plan in outback Queensland or a regional wheatbelt town in Western Australia, a small AppImage or a system package is friendlier than a heavyweight Snap that auto-refreshes in the background. The Australian mirror network, with providers like AARNet, Internode, and several university mirrors, helps reduce the bandwidth cost of installing the base system.

Universal packages, however, are usually fetched from overseas stores such as snapcraft.io or flathub.org, so the full weight of each download crosses international links. Local Linux user groups in Sydney, Melbourne, Perth, and Brisbane often keep DVDs and USB drives of common applications at their monthly meetups, which is a workaround for users who would rather not chew through a monthly allowance to install something like GIMP. There is also a cultural note. Australians tend to call software "apps" or "programs" interchangeably, and that habit matches the way universal packages are presented in the Software centre. The community-oriented tone of the local LUG scene also fits AppImage's portable approach, and shapes which format feels most natural at a Perth hack night or a Brisbane installfest.

When to reach for each format

Snap is the right choice when convenience matters and the user is happy for updates to happen on their own. It is also the right choice for proprietary software distributed through the Ubuntu Store, including some commercial applications that only ship in Snap form. For someone running Ubuntu on a recent laptop and wanting the least amount of fiddling, sticking with Snap keeps things uniform.

Flatpak is the right choice when an application is available on Flathub but not in the Snap store, or when the user wants more control over update timing. It is also the better option on distributions other than Ubuntu, because the runtime model keeps disk use efficient across many applications. For a developer or power user who likes to pin specific versions, Flatpak's command line tools feel comfortable.

AppImage is the right choice for portable, occasional, or experimental software. A student carrying work between computers on a USB stick, a technician running a diagnostic tool, or a hobbyist testing the latest beta of a niche application will appreciate the simplicity. The format also shines on older hardware where every second of startup time counts, and on connections where downloading a fresh package on demand is cheaper than maintaining a background service.

A useful habit is to think of the three formats as tools rather than rivals. The same Ubuntu machine can host a core set of system packages, a handful of Snaps for proprietary applications, several Flatpaks from Flathub, and a folder of AppImages for portable utilities. Mixing them is what most long-term Ubuntu users end up doing once they understand the strengths of each.