How To Use And Install FlatPak On Linux

Note: Commands and app store behavior can vary a little by distribution and desktop environment, but the workflow below follows current official Flatpak and Flathub guidance.

Installing software on Linux can feel like shopping at five different grocery stores just to make one sandwich. One app is in the distro repo, another is only available as a .deb, a third wants you to compile from source, and a fourth acts like your operating system is a suggestion. That chaos is exactly why Flatpak became such a popular option. It gives Linux users a more universal way to install desktop apps across distributions, while also adding sandboxing and cleaner dependency handling.

If you have ever wanted the latest version of an app without waiting for your distribution to catch up, Flatpak is worth learning. It is especially handy for users on Ubuntu, Debian, Fedora, Linux Mint, Arch, Pop!_OS, and other desktops where app availability can vary. In this guide, you will learn what Flatpak is, how to install it, how to add Flathub, how to use core commands, and how to avoid the classic “why is my app acting weird?” moment.

What Is Flatpak?

Flatpak is a universal Linux package format designed mainly for desktop applications. Instead of tying an app to one specific distribution or version of a distribution, Flatpak packages apps so they can run on many Linux systems with fewer compatibility headaches. In plain English, it is a way to install software on Linux that does not care quite so much whether your machine speaks Fedora, Debian, Ubuntu, or Arch.

Flatpak apps run in isolated environments called sandboxes. That means an app does not automatically get full access to your whole system, your files, or every device plugged into your computer. When access is needed, Flatpak often uses portals, which are controlled pathways that let apps do things like open files, print documents, or access desktop services more safely. Think of portals as the polite version of permission requests: the app asks nicely instead of kicking down your front door.

Flatpak also uses runtimes. A runtime is a shared base layer of libraries and components that multiple apps can use. This reduces the need for every app to carry every dependency inside its own package, while still keeping software more self-contained than traditional distro packages.

Why Use Flatpak on Linux?

1. It works across distributions

One of the biggest benefits of Flatpak is consistency. A Flatpak app can usually be installed on many Linux distributions without needing different package formats. That is a big deal when Linux has historically split the software world into .deb, .rpm, and “good luck compiling it yourself.”

2. You often get newer app versions

Distribution repositories are great for stability, but they are not always fast. Flatpak often gives users access to newer versions of desktop applications, which is especially useful for browsers, creative tools, communication apps, and utilities that update frequently.

3. Sandboxing adds safety

Flatpak apps are sandboxed by default, which can reduce the damage a buggy or over-curious app can do. That does not make Flatpak magically invincible, but it is still a smart layer of protection for desktop software.

4. Dependency drama is reduced

Traditional package management sometimes turns into dependency archaeology. Flatpak avoids a lot of that mess because apps rely on runtimes and bundle what they need in a more controlled way. Less “library mismatch,” more “it just works.” Usually. Linux still likes to keep us humble.

5. Great for immutable or container-focused desktops

Flatpak fits especially well on systems like Fedora Silverblue and Kinoite, where the operating system is more locked down and desktop apps are expected to come from Flatpak-style workflows.

Flatpak vs Traditional Packages

Flatpak is not a replacement for every package manager. It is a strong option for desktop apps, but native packages still matter. If you are installing low-level system tools, drivers, kernels, shells, or services that tightly integrate with the operating system, your distro package manager is still the better choice.

A simple way to think about it is this:

• Use native packages for system-level software and tight OS integration.
• Use Flatpak for desktop apps when you want convenience, cross-distro compatibility, sandboxing, or newer versions.

Flatpak apps can also use more disk space than traditional packages in some cases, especially if you install several runtimes. But the shared runtime model means that storage use is not always as bad as people fear. It is more “roomy backpack” than “moving truck.”

How To Install Flatpak on Linux

The exact method depends on your distribution. Some distros already include Flatpak support out of the box, while others require one or two commands.

Ubuntu

On Ubuntu 18.10 and newer, install Flatpak with:

If you want graphical support through GNOME Software, also install:

One important detail: recent Ubuntu releases do not natively support Flatpak through the default Snap-based software storefront, so installing the GNOME Software Flatpak plugin may add a separate Software app.

Debian

Optional graphical integration:

For KDE Discover:

Fedora

Flatpak is already installed by default on Fedora Workstation, Fedora Silverblue, and Fedora Kinoite. In many cases, the main step is simply enabling Flathub.

Arch Linux

Red Hat Enterprise Linux

On RHEL Workstation 9 and newer, Flatpak is available by default. On older versions, you may need:

Linux Mint and Pop!_OS

Both Linux Mint and Pop!_OS already include Flatpak support in newer releases, so you may not need to install anything at all before using it.

How To Add Flathub

Flatpak can work with multiple repositories, known as remotes. The most popular remote is Flathub, which is the main app catalog most users rely on.

To add Flathub, run:

After that, restarting your session or rebooting is a good idea on many systems so app centers and menus pick up the new source properly.

How To Use Flatpak

Once Flatpak is installed and Flathub is enabled, daily use is straightforward. Here are the commands that matter most.

Search for an app

This searches your configured remotes for matching apps.

Install an app

You can also install from a .flatpakref file or, in some cases, let Flatpak search interactively with a simpler command such as:

Run an app from the terminal

Most desktop apps will also appear in your applications menu after installation, so you usually do not need to launch them from the terminal unless you enjoy feeling dramatic.

List installed apps

To list apps and runtimes together:

Update everything

This updates installed Flatpak apps and runtimes to the latest available versions.

Uninstall an app

Remove unused runtimes

This is one of the best housekeeping commands in Flatpak. It clears out runtimes and extensions that are no longer needed. In other words, it takes out the digital trash without asking you to separate paper from plastic.

System-Wide vs User Installations

By default, Flatpak installs apps system-wide, which makes them available to all users on the machine. That is the recommended default for normal desktop use. You can also install apps per-user by adding the --user option. That installs the app only for the current account.

Example:

User installs are useful for testing, development, or machines where you do not want every account sharing the same apps.

How Flatpak Permissions Work

Flatpak’s sandbox is one of its best features, but it also introduces a little complexity. Some apps need access to files, network connections, audio devices, printers, or USB hardware. Good Flatpak apps request only what they need, and many interactions happen through portals instead of broad permanent permissions.

If you want to inspect portal permissions, Flatpak includes commands such as:

You can also use tools like Flatseal, a graphical app for viewing and adjusting Flatpak permissions. It is especially useful if you want more control without memorizing commands or pretending you enjoy reading terminal output like a bedtime story.

Common Flatpak Problems and Fixes

App does not show up in the menu

Log out and back in, or restart your computer. Desktop caches and software centers sometimes need a refresh after enabling Flatpak or Flathub.

Graphical app store does not show Flatpak apps

Make sure you installed the appropriate plugin or backend for your desktop environment, such as GNOME Software or KDE Discover support.

Something feels broken after updates

Try:

This helps fix inconsistencies in the local Flatpak installation.

Too many leftover runtimes

Run:

App cannot access a folder or device

Check the app’s permissions. It may be sandboxed correctly and simply not have access yet. This is not Flatpak being broken. This is Flatpak being suspicious, which is honestly a healthy personality trait for software.

Best Practices for Using Flatpak

• Prefer Flathub or other trusted remotes instead of random unofficial sources.
• Use Flatpak mainly for desktop applications, not deep system components.
• Review permissions for apps that need filesystem, microphone, USB, or network access.
• Run flatpak update regularly.
• Clean up with flatpak uninstall --unused once in a while.
• Choose native packages when you need tight integration with your distribution.

Real-World Experience Using Flatpak on Linux

After using Linux across different distributions, Flatpak starts to feel less like a bonus feature and more like a peace treaty. On Ubuntu, it helps you escape the version lag that sometimes shows up in the standard repositories. On Fedora, it fits neatly into the desktop workflow, especially if you prefer modern app delivery. On Linux Mint and Pop!_OS, it is often already there, quietly waiting for you to stop overthinking and install something useful.

One of the best experiences with Flatpak is getting the same app behavior across multiple machines. Maybe you run Fedora on a laptop, Debian on a mini PC, and Pop!_OS on a desktop. Normally that setup invites package inconsistencies, missing dependencies, and random differences in app versions. With Flatpak, your app installation process becomes much more predictable. You add Flathub, install the same application ID, and move on with your life. That might not sound glamorous, but in Linux land, predictable software is basically luxury real estate.

Flatpak is also a relief when helping less technical users. Instead of explaining repository priorities, third-party package sources, or why one package name changes between distributions, you can give a single set of instructions. Search, install, update, done. That simplicity matters. It lowers the barrier to entry for new Linux users who do not want their weekend consumed by package manager anthropology.

There are also nice practical wins for creative and productivity software. Apps like image editors, note-taking tools, chat clients, and media apps often arrive faster through Flatpak than through native repositories. If you want current features without replacing your whole operating system every six months, Flatpak feels like a smart compromise. You keep the stability of your distro while still getting fresher desktop apps.

Of course, Flatpak is not perfect. Some apps may launch a little slower on first run. Some need extra permission tweaks. A few users dislike the extra storage used by runtimes. Those are fair complaints. But in day-to-day use, the tradeoff is usually worth it. The security model is better than “everything can touch everything,” and the cross-distro convenience is hard to ignore.

The biggest mindset shift is learning when Flatpak is the right tool. Once you stop expecting it to replace every native package and start using it where it shines, it becomes incredibly useful. For desktop apps, especially third-party apps, it often saves time, reduces friction, and keeps your system cleaner. That alone makes it one of the most practical tools in the modern Linux ecosystem.

Conclusion

If you want an easier way to install and manage desktop apps on Linux, Flatpak is one of the best tools available today. It offers cross-distribution support, sandboxed applications, access to newer software, and a cleaner way to avoid dependency chaos. Add Flathub, learn a handful of commands, and you are ready to use Flatpak like it has been part of your workflow forever.

For many Linux users, Flatpak is not about replacing the distro package manager. It is about making desktop software easier, safer, and more portable. And honestly, anything that reduces package-related drama deserves at least one polite round of applause.