How to easily manage AppImage packages in Linux

If you use Linux and have come across files with the extension . .AppImageYou've probably wondered what exactly .deb or .rpm files are, how they work, and whether they're safe. While at first glance they may not look much like typical .deb or .rpm files, the reality is that they're an incredibly convenient way to test and use applications on virtually any GNU/Linux distribution.

In the following lines we will look at this calmly How to manage AppImage packagesWhat they are, where to download them safely, how to grant them permissions, run them, integrate them into the system menu, update them, run them in a sandbox, and of course, what their strengths and weaknesses are compared to other formats like APT, Snap, Flatpak or the traditional packages.

What exactly is an AppImage package?

An AppImage file is, essentially, a single self-contained binary which includes the application and all the essential libraries for it to function, in a way very similar to what portable applications would be in Windows or a .dmg file on macOS. Instead of ending in .exe or .dmg, these binaries end in .AppImage.

When you double-click on one of these files, what the system does internally is Mount a compressed ISO image using FUSEThe program and its libraries are contained within that image. Once mounted, the main binary is executed and the application opens as if it had been installed in the traditional way.

An important detail is that Each AppImage contains a single applicationIt's not a "mega installer" with several programs, but a closed drive: you double-click on the file and it launches exactly that program, nothing more.

Thanks to its included dependencies, an AppImage can be run in virtually any modern GNU/Linux distributionProvided the system has the minimum base libraries the developer expects, you don't need to install additional packages from the distro's package manager to resolve dependencies, because they are included within the package file itself.

Another key point is that They do not require administrator privilegesYou can download an AppImage to your home folder, mark it as executable, and use it without touching anything in the system or requesting root permissions. This makes them ideal for testing software without "cluttering" your installation.

AppImage versus APT, Snap, Flatpak and other formats

In distributions like Ubuntu, Linux Mint, Debian, or similar, it is common to install software with APT and .deb packagesIn others, such as Fedora or RHEL, .rpm packages are used. And in recent years, other formats have emerged. “universal” like Snap (powered by Canonical) and Flatpak, which also package applications with their dependencies.

The main difference between AppImage and these formats is that It is not "installed" in a conventional way. With a .deb Or an .rpm file, files are copied to various system directories, the package database is updated, and root privileges are generally required. Snap and Flatpak also offer centralized management, specific installation environments, and more or less strict sandboxing mechanisms.

In AppImage, however, the model is different: downloads a single file, give it execute permissions and you're doneThere is no package manager involved, system directories are not touched, and to "uninstall" you simply delete the file.

Regarding dependencies, AppImage and Snap They are similar in that They do not depend on the distro's libraries To function, Flatpak also packages much of what's needed, although it relies on common runtimes. APT, however, does install shared dependencies using the traditional package system.

You also have to keep in mind that AppImage is distribution agnosticThe same file should work on Ubuntu, Debian, Fedora, Arch, openSUSE and many more, which greatly simplifies life for the developer (who doesn't need to compile for a thousand different formats) and for the user who jumps between several distros.

Key features and benefits of AppImage

AppImage follows a series of design principles Designed to simplify life for users and developers. Among their most interesting features are several that should be understood before you start using them seriously.

First, each application you want to run is distributed as a single self-contained fileThere's no need to download dozens of packages or struggle with external libraries. Everything travels together in that "image".

The “installation process” is virtually nonexistent: Files are not extracted from the entire file systemNor are there any assistants with endless questions. You download, mark it as executable, and run it. End of story.

Another strong advantage is that You don't need to use sudo or administrator accounts This is completely unrelated to the normal use of AppImages. Everything is managed from your user account, which reduces the risk of breaking the system or opening unnecessary security vulnerabilities.

Furthermore, the software's behavior is consisting of different distributionsThis is especially convenient if you work with several distributions at the same time or if you distribute an app to users whose exact environment you don't know: the AppImage runs the same everywhere, as long as they meet certain minimum requirements.

Finally, many applications distributed in this format incorporate mechanisms for incremental updateThese options allow you to download only the changes compared to the previous version. When used effectively, this feature saves bandwidth and speeds up the update process.

Where to download AppImages safely

One of the most important things when it comes to running binaries downloaded from the internet is their source. With AppImage, the sensible recommendation is Always download from the developer's official website or from its official repository (for example, GitHub, GitLab, etc.). This greatly reduces the risk of encountering manipulated or malicious files.

Many well-known applications offer AppImage directly on their website or in their repositories: Krita, Kdenlive, LibreOffice, Nextcloud, Inkscape, DigiKam, MuseScore, LMMS, Scribus, some messaging clients, etc. You will usually see a “Linux” or “Downloads” section where the download in AppImage format is clearly displayed.

There are also catalogs or “shops” of apps AppImage, being one of the most popular AppImageHubIt acts as a centralized repository where you can search for applications, although it's worth keeping in mind that it's still just an aggregator and that, if in doubt, it's always best to check the link to the project's official website.

There are also platforms and tools such as PortableLinuxGames (oriented towards games packaged as AppImage) or managers like AppImagePool, which behave as a kind of "app store" where you browse, download and even integrate AppImages into the system semi-automatically.

In any case, when searching, a very simple trick is to type it into your favorite search engine. “program_name appimage”Many projects link their AppImage from there. Just make sure you end up downloading it from a reliable source, preferably the official website.

How to use an AppImage file step by step

Using an AppImage file is quite simple, and although it may vary visually depending on the desktop environment you use (GNOME, KDE, XFCE, etc.), the idea is the same in all of them: download, grant permissions and run.

1. Download the AppImage file
First, locate the application you're interested in, go to its official website or a trusted repository, and download the .AppImage file. It's a good idea to save all your AppImages in an easy-to-remember location, for example ~ / AppImages in your personal folder, or a directory like /opt/AppImages if you want something “more global”.

2. Make the file executable
By default, the downloaded file will not have execute permissions. To grant them, you have two options. From the graphical environment, right-click on the file, and go to Properties → Permissions and check the box equivalent to “Allow the file to be executed as a programFrom that moment on, you can double-click to launch it.

If you prefer the terminalYou can use a command like chmod +x package_name.AppImage Or, if you want to give permission to all users, chmod a+x package_name.AppImageYou don't need sudo for this if the file is in your home folder.

3. Run the AppImage
Once you have execution permission, simply double-click from the file manager or run it from the terminal with ./package_name.AppImageAt that moment, the image is mounted internally and the program opens.

In some distributions, mainly from Ubuntu 22.04 onwards, you may need to have libraries such as installed. FUSE and libfuse2 for certain AppImages to function correctly. On Debian/Ubuntu-based systems, something like this would suffice. sudo apt install fuse libfuse2 to cover that need.

Integrate AppImages into the system and the application menu

If you're only going to use an AppImage very occasionally, running it from the folder where you saved it might be enough. But when you start using several daily, it's much more convenient. integrate them into the applications menu from your desktop environment, just as if they were programs installed via APT or Snap.

A classic way to do this is to manually create a file .desktop en / usr / share / applications (for the entire system) or in ~ / .local / share / applications (For your user only). This file describes the shortcut: application name, command executed, icon, category, etc.

For example, for an AppImage called notesnook.AppImage located in /opt/AppImagesYou could create something like:


Name=NotesNook
Exec=/opt/AppImages/notesnook.AppImage
Icon=/opt/AppImages/icons/notesnook.svg
Comment=Aplicación de notas sin rastreo
Type=Application
Terminal=false
Encoding=UTF-8
Categories=Utility;

After saving this file with a name like notesnook.desktop In the corresponding directory, the application will appear in the system menu, and you can pin it to the launcher, search for it by name, etc. If your desktop includes tools like MenuLibreYou can also edit and create launchers graphically without touching plain text.

Another possibility is to use specific applications such as AppImageLauncherThis tool is responsible for automatically integrate AppImageYou simply double-click an .AppImage file, and AppImageLauncher moves it to your configured folder, creates the launcher in the menu, and manages its deletion. It even includes a console utility. ail-cli, to automate tasks from scripts.

There are also third-party utilities such as appimage2desktop (which generates a launcher with an icon for a specific AppImage), appimagehelper (to create and delete launchers) or specific desktop projects such as AppImage to GNOME, which monitor and integrate AppImages directly into GNOME.

Associating file types with an AppImage application

Once you have your AppImage up and running, you might be interested in associate certain file types so that they open with it by default. For example, that .kdenlive projects open with Kdenlive in AppImage format instead of with any other installed version.

The exact procedure depends on the desktop environment, but the general idea is always similar: you choose a file of the type you want to associate, right-click, and access something like “To open with…" or "Open with another application…".

In the window that opens, select the AppImage (or the launcher you created for it) and check the "Type" option.Use as default for this file typeFrom that moment on, every time you double-click on a file of that extension, it will open with the AppImage application you have chosen.

In environments like XFCE, KDE Plasma, or GNOME, the specific options may have slightly different names, but you'll always find a section for associating MIME types or default applications. The good news is that this setting is usually per user, so You don't need administrator privileges to change this preference.

Running AppImages in a sandbox environment

By default, applications in AppImage format They are not isolated in a sandbox.In other words, they have access to your home directory with your user's usual permissions, just like an application installed via APT, unless you add layers of isolation yourself.

If you want to increase security a bit more, a very interesting option is to use firejail, a sandboxing tool that is quite widespread in the Linux ecosystem and also offers specific support for AppImage.

To start using it, you must first install it from your distribution's repositories. On Debian/Ubuntu systems, for example, a simple installation would suffice. sudo apt-get install firejailOnce installed, you can launch your AppImage in a controlled environment.

The typical command would be something like firejail –appimage package_name.AppImageThis causes the application to run within the Firejail sandbox, with additional restrictions on access to the file system, network, etc., depending on the configured profile.

So, if you want to open, for example, Kdenlive packaged in kdenlive-18.08.3-x86_64.AppImage Within an isolated environment, you would use: firejail –appimage kdenlive-18.08.3-x86_64.AppImageThis way you maintain the portability advantages of AppImage but with an extra layer of security.

Updating and version management in AppImage

Update management is one of the areas where AppImage It deviates considerably from the traditional model. from the distribution's repositories. There's no APT here to handle everything, nor an official "store" integrated into the system to update your applications in bulk.

In some cases, there are applications that They implement their own self-update system within the AppImage, or they use tools such as AppImageUpdate, which allows downloading only the changes (thanks to delta updates) using the information embedded in the file itself.

AppImageUpdate is also distributed as an AppImage, and its purpose is to be simple, decentralized and fastIt doesn't rely on a central repository, but rather on the metadata the developer has included in the application. However, its actual functionality depends on the app creators having implemented it correctly.

In practice, many users end up opting for a more "manual" but effective method: Download the new version from the official website.Give it execution permission and replace the old file with the new one, making sure the filename is the same as the one used in your launcher or desktop integration.

AppImage managers have also emerged along the lines of commands , the appimage-manager, Zap or AppManThese tools allow you to search for, install, update, and remove AppImages in a way that's more like a classic package manager (such as APT or pacman). They're useful if you manage many applications in this format or if you want to automate the process with scripts.

How to uninstall or delete an AppImage

One of the most convenient things about this format is that, by not installing packages throughout the entire system, Uninstalling an AppImage is literally deleting the file. There is not databases no packages to update or dependencies to clean up.

If you save your AppImages, for example, in /opt/AppImages or in ~ / AppImagesSimply delete the file from the file explorer or from the terminal with a rm package_name.AppImage so that the application disappears.

However, if you have manually created desktop integration (.desktop files, icons in /opt/AppImages/icons, etc.), it is advisable erase those remains as well. To prevent broken shortcuts from appearing in the menu, simply remove the corresponding .desktop extension and, if you were using it, its associated icon.

In the case of tools like AppImageLauncher AppImagePool, or AppImagePool, usually offer options from their own interface to dismantle or delete the application, taking care of cleaning not only the binary, but also the launchers and icons that they have created.

The important thing is that you won't run into waste that is difficult to dispose of distributed throughout the system as sometimes happens with traditional packages; everything is quite limited to a few easy-to-locate files.