One of the great things about Linux-based operating systems is that they offer users a lot of choice when it comes to which tools and configurations they use. However, in some respects, too much choice can become a bad thing. It can create inconsistency between platforms and tools, and cause user confusion.
Case in point: installing software on Linux. Different Linux distributions offer different software installation tools and packaging formats, making it hard for users of one distribution (such as Ubuntu) to install software designed for another distribution (like Fedora).
Fortunately, there's a solution to this conundrum: AppImage. AppImage is an open source tool for running Linux applications in a consistent way across all Linux distributions, regardless of how they are configured or which applications users want to run. In addition, AppImage offers benefits like the ability to install and run applications without having root or sudo privileges.
Keep reading for a dive into how AppImage works, which problems it solves, and how to get started using and creating AppImages for any Linux distribution.
What Is AppImage?
Again, AppImage is a tool that lets you run applications in a consistent way across any Linux distribution. It also works on Windows if you install Windows Subsystem for Linux, although AppImage is not designed for use on Windows and may not always prove stable or reliable in Windows environments.
This means that, using AppImage, you can run any software package that is designed to work with AppImage, regardless of which Linux distribution you are using or how your local environment is configured.
What Are the Benefits of Using AppImage?
The main benefits of AppImage include the following:
- AppImage provides a universal means of distributing and running Linux software that works on any Linux-based computer.
- Users can run AppImage apps without having root or sudo privileges. This makes AppImage especially useful if you're using a public or shared computer where you don't have permission to install software the traditional way.
- With AppImage, all of the dependencies that an application may require are bundled into a single file and run from that file. This eliminates the need to download and install additional packages in order to run an app.
- Packaging all dependencies within a single file also allows AppImage apps to run without changing system libraries or configurations in ways that could cause problems for other applications (which may depend on different libraries or configurations). Put another way, AppImage apps run in a sandboxed environment that doesn't disrupt other applications.
Of these benefits, the most important is AppImage's ability to offer a universal means of running software on Linux-based operating systems. This matters because, as noted above, different Linux distributions rely natively on different tools and software package forms to run software. Ubuntu uses the apt package manager and Debian packages to manage and install software, for example. (Modern versions of Ubuntu can also use snap packages, but that only exacerbates the problem because it adds another package manager and package format to the mix.) In contrast, Fedora Linux uses a package management tool called dnf and packages formatted as RPM files.
As a result, you can't install a package designed for Fedora on Ubuntu, or vice versa. (Tools like alien can sometimes convert packages from one format to another, but the conversion process is clunky and doesn't always yield packages that actually work.) Nor can you use the same package management tools across distributions. If you move from one distribution to another, you have to familiarize yourself with different tools and different package types. And if you are a developer who wants to release software for Linux, you need to release it in multiple formats if you want to make it available for all distributions.
AppImage solves these problems because any AppImage package can run on any Linux distribution, without requiring a package manager or other tool.
How Do You Use AppImage?
Using AppImage to run an application is simple. It boils down to three steps:
- Download an AppImage package for the application you want to run.
- Make sure the application package has executable permissions on your system.
- Run the package by calling it on the command line or right-clicking its icon and selecting Run.
That's it. You don't even need to install a particular tool or special runtime to run AppImage apps because — unlike applications formatted using tools like Docker — they run as standard Linux executables.
To illustrate how to use AppImage in more detail, let's walk through an example.
1. Download an AppImage package
For the purposes of this tutorial, let's download the AppImage for Firefox, which you can find on this page. I downloaded the file and saved it inside my /tmp directory (if you want to use the package on a recurring basis, store it somewhere other than /tmp, since files in /tmp are periodically deleted by the system):
2. Make your package executable
Now, we need to make sure it's executable. Do that by right-clicking on the icon, selecting Properties, and using the Permissions tab to set the permission that allows the execution of the file as a program. (Note that the exact wording you see may vary depending on your system's configuration.)
You can also set executable permissions on the command line using chmod:
chmod +x Firefox-81.0_20200930150533-x86_64.AppImage
3. Run your AppImage
Finally, right-click on the icon and select run, and the application will start:
(As you can see, my AppImage instance of Firefox complains about crashing tabs, but that's because I am also running a separate instance of Firefox on the same system that I installed the traditional way. It's not AppImage's fault.)
If you prefer to launch the app directly from the command line, you can do that, too:
How Do You Update an AppImage?
Unlike traditional package managers, AppImage itself doesn't provide functionality for automatically updating software. But you can still update AppImages.
One way to perform updates is to download a newer AppImage package for the software you are running. This approach is simple, but it requires you to keep track of the latest application versions manually.
Alternatively, you can use AppImageUpdate, a free tool that automatically downloads updated versions of AppImage files when they become available. In addition to making it easier to find and install updates, AppImageUpdate works in such a way that it only downloads the parts of an AppImage file that have actually changed. That means you don't waste time and bandwidth downloading an entirely new file. Plus, AppImageUpdate is itself an AppImage, so you can run it easily on any Linux distribution.
That said, AppImageUpdate is still in beta, so you may run into some issues using it. It also doesn't support all types of AppImage files. Your AppImage files must embed update information, which not all AppImages do.
There are several tools available for streamlining the process of using AppImage:
- AppImageUpdate: As explained above, this tool helps update AppImages efficiently and automatically.
- AppImageLauncher: This tool automatically integrates AppImage packages into your desktop environment so that you can find and run them using launchers, instead of having to launch them manually. It also provides automatic updates.
- AppMan: A tool that adds package management features to AppImage, with the goal of making it similar to apt.
- Appimagetool: This tool lets you create your own AppImage files.
These tools aren't required if you just want to run AppImage software, but they provide valuable features that aren't part of AppImage itself — which is, again, just a way to run applications, not manage or package them.
Disadvantages of AppImage
AppImage is a powerful tool, but it has some downsides:
- Limited app availability: Not all applications are available as AppImages, so you may find that you need to use different tools for running certain software.
- Limited support: AppImage is an open source project, and as such it offers no official support services. Users must rely on community-based support.
- No automatic updates: As explained above, AppImage doesn't automatically update packages to the latest versions. You can update them manually or use tools like AppImageUpdate, but that doesn't always work.
- No application organization: AppImage doesn't store apps in a central location or provide an easy way to access them. You have to keep track of where apps live manually, or use a tool like AppImageLauncher to create launchers.
How to Create an AppImage
The process for creating an AppImage file — meaning a file that other people can use to launch an application via AppImage — varies depending on which type of application you are trying to package for use with AppImage.
Typically, however, you can create an AppImage using these steps:
- Move all of the binaries and dependencies for your application into a directory of your choosing.
- Use appimagetool to generate an AppImage based on the contents of that directory.
You can optionally add metadata such as update information (to help track AppImage app versions) or signatures (to verify application authenticity) when you generate the AppImage.
AppImage solves one of the core challenges faced by Linux users: the need for a simple and consistent way to distribute and run software across any Linux-based operating system. Although AppImage has some drawbacks, like lack of a native way to integrate applications into a desktop environment, it is a user-friendly tool that makes it simple to run hundreds of applications on any Linux system.
About the authorChristopher Tozzi is a technology analyst with subject matter expertise in cloud computing, application development, open source software, virtualization, containers and more. He also lectures at a major university in the Albany, New York, area. His book, “For Fun and Profit: A History of the Free and Open Source Software Revolution,” was published by MIT Press.