Appimages totally suck, because many developers think they were a real packaging format and support them exclusively.
Their use case is tiny, and in 99% of cases Flatpak is just better.
I could not find a single post or article about all the problems they have, so I wrote this.
This is not about shaming open source contributors. But Appimages are obviously broken, pretty badly maintained, while organizations/companies like Balena, Nextcloud etc. don’t seem to get that.
I’m a Flatpak user myself, but a lot of those arguments against AppImage are outdated or invalid. Here are my counterpoints:
Usability issues
GearLever solves all the problems mentioned.
Updates
There are AppImages out there that self-update , but GearLever also solves the update issue. And if you don’t want to use GearLever, there are other updaters like AppImageUpdate.
The lack of repositories
Appimages don’t even have a central place where you can find them, not to mention download them.
This is blatantly wrong - AppImageHub exists for this very reason. There are also GUI frontends like AppImagePool which makes it easy to discover/download/install them.
Lack of Sandboxing
That is a fair point, however, AppImage never claimed to be a sandboxing solution, and for some use-cases this can even be seen as an advantage (any Flatpak user would’ve at some point run into annoying sandboxing limitations - such as password manager and browser integration, or themeing woes). But there are other sandboxing options out there, such as using containers, and IMO, using a proper container is a better option for sandboxing. Or even better, use a VM if you’re actually running an untrusted app.
Random location
[…] A necessary step would be mounting the entire /home non-executable. This is no problem for system apps, or Flatpaks, but where do you put Appimages now?There would need to be a standard directory to put such files in, which is normally the PATH. But this is also the easiest attack goal for malware, so PATH would be non-executable as well.
I completely disagree with making the entirety of /home as non-executable, when $HOME/.local/bin is recommended by the XDG standard as a place to store executables. As long as $HOME/.local/bin is in the XDG spec, I’ll continue storing my executables there. If you disagree, go argue with the XDG guys.
Duplicated libraries
This is a fair point but “they include all the libraries they need” is the entire point of AppImage - so mentioning this is pointless.
If users would really install every Software as Appimages, they would waste insane amounts of storage space.
Then it’s a good thing that they don’t right? What’s the point of making hypothetical arguments? Also, this is 2024, storage is cheap and dedicating space for your applications isn’t really a big deal for most folks. And if storage space is really a that much of a concern, then you wouldn’t be using Flatpak either - so this argument is moot and only really valid for a hypothetical / rare use-cases where storage is a premium. And again, in such a use case, that user wouldn’t be using Flatpaks either.
Finally, some distros like Bazzite already have the above integrations built-in (GearLever/AppImagePool), so you don’t even need to do anything special to get AppImages integrated nicely in your system, and there’s nothing stopping other distros adding these packages as optional dependencies - but it’s kinda moot at this point I guess since Flatpak has already won the war.
Personally, I’m pro-choice. If AppImage doesn’t work for you, then don’t use it, as simple as that. Stop dictating user choice. If AppImage is really as bad as you claim, then it’ll die a natural death and you don’t have to worry about it. What you really need to worry about is Snap, which has the backing of Canonical, and some dev houses new to the Linux ecosystem seem to think packing stuff as Snap is an acceptable solution…
I agree with you on all but one point: I detest the argument that “storage is cheap”.
While true, it’s of no value to have 10 times the storage when all your apps grow 10 times in size. You can still only do as much as before but had to upgrade in between. This also means, it leaves behind people who simply can’t afford an upgrade and who have an otherwise running system.
On top of that, we live in a time where we should not waste resources, since the world already suffers enough.
I am therefore still a fan of optimizing software to be as efficient as possible.
That being said: carefully used AppImages solve one such issue for me. Not every application I use needs constant updates. I want to stay at a specific version. That’s easy with AppImages.
GearLever
Download from Flathub
Hehe.
Duplicated libraries
This is a fair point but “they include all the libraries they need” is the entire point of AppImage - so mentioning this is pointless.
“Bloat” is one big topic around these newer packaging formats so definitely not a pointless thing to bring up imo. I don’t think it should be as big of a topic as it is (the actual issue here is fairly minor imo) but it is definitely talked about.
And flatpak (and snap I think) have much better tools to mitigate the space use issues.
GearLever](https://github.com/mijorus/gearlever) solves all the problems mentioned.
Sceptical but I will try it for sure.
It makes appimages less worse than Flatpaks though, so its only “badness reduction” for me.
There are AppImages out there that self-update , but GearLever also solves the update issue. And if you don’t want to use GearLever, there are other updaters like AppImageUpdate.
The first is what I mentioned, such updates can be perfectly done by a central package manager. Did you ever try to seal off a Windows install using Portmaster, where every installed app needed network access for their individual update services? Just no…
Ans to the repos, yeah maybe, havent looked if they are as secure as a linux repo. But the concept of “it is acceptable to download software from random websites” allows for malware to fit in there. Only if you will never find a .flatpak file it is possible to be sure its malware.
But there are other sandboxing options out there, such as using containers, and IMO, using a proper container is a better option for sandboxing. Or even better, use a VM if you’re actually running an untrusted app.
All worse than bubblewrap. Containers are either manual af (like with bubblejail) or if you refer to Distrobox/Toolbox, unconfined by default. They have no portal integration and no GUI configuration apps. So it may work somehow but probably worse, more resource heavy and there simply already is something better.
Same for VMs. Keep an eye on Kata containers, but this is about least privilege, not some QubesOS system that will not run in a tablet, for example. Android uses containers, is damn secure, and runs on phones.
[non executable stuff]
This is about protecting against malware. Linux Desktops are built on a different logic. Any unconfined software can download a binary to localbin, copy a random desktop entry from usrshareapps to your local folder, edit the exec line and add that binary to it.
Or just manipulate your .bashrc, change the sudo command to read input, save to file, pipe input to sudo. Tadaa, sudo password stolen.
That concept of “users can change their home but not the system” is poorly pretty flawed. So any directory that is writable without any priveges is insecure, if you dont trust every single piece of software you run.
Agree that Snaps are a problem. Its only really problematic when repackaging is illegal though, of course annoying but the Spotify flatpak is a repackaged snap. Same as with appimages.
I should write the same about snaps, but I feel they are covered WAY better.
This tool also good
(any Flatpak user would’ve at some point run into annoying sandboxing limitations - such as password manager and browser integration, or themeing woes)
While I overall do prefer Flatpak over AppImage these days, the sandboxing has indeed been giving me more trouble than I think it is worth so far.
I agree with this, but as an app developer, can I just say, Flathub’s documentation is an absolute abomination. It is so bad, that I’ve tried 3 times to publish an app and have given up each time. I can build a local Flatpak just fine, but getting it on Flathub is just so convoluted and bad.
AppImages are ridiculously easy to build and distribute, just a pain to actually use. And even then, they’re not that much of a pain.
If worst comes to worst you can just distribute your .flatpak file directly, as you would with your app image
Try getting Creality Print to run without manually updating components of the appimage. I’ll wait.
AppImage is great at what it does - provide an ultra-low effort packaging solution for ad-hoc app distribution that enables a developer who won’t spend the time to do rpm/deb/flatpak packaging. There are obvious problems, security and otherwise, that arise if you try using it for a large software collection. But then again some people use things like Homebrew and pacstall unironically so …
Great, now tell me why your appimage is complaining about not having some .so file on my system
No, the problem is more subtle, the developer assumed I have the same libs in the same locations as a mainstream distro like Ubuntu, but I do not
I actually have several versions of each library in different hashed folders (my distro does this) and I just steam-run normal Linux executables
Except I can’t do that when using this appimage thing so it doesn’t directly work on my system
But then again some people use things like Homebrew and pacstall unironically so …
Thank you for mentioning this! Unfortunately a quick search on the internet didn’t yield any pointers. Would you mind elaborating upon the security problems of Homebrew(/Linuxbrew)? Thanks in advance 😊!
Post about homebrew by Jorge Castro
I am not sure how secure it is.
I am aware that Homebrew has become the go-to solution for installing CLI applications on Bluefin. Which is exactly why I feel compelled to ask the question in my previous comment.
Btw, I don’t really understand why you felt the need to share Jorge Castro’s blog post on Homebrew? AFAIK it doesn’t go over any security implications. Sharing the article would only make sense if Jorge Castro is regarded as some authority that’s known to be non-conforming when security is concerned. While I haven’t seen any security related major mishaps from him or the projects he works on, the search for the CLI-counterpart to Flatpak seemed to be primarily motivated by facilitating (what I’d refer to as) ‘old habits’; which is exactly what Homebrew allows. It’s worth noting that, during the aforementioned search process, they’ve made the deliberate choice to rely on Wolfi (which is known for upholding some excellent security standards) rather than Alpine (which -in all fairness- has also been utilized by Jorge for boxkit). IIRC, people working on uBlue and related projects have even contributed to upstream (read Distrobox) for patches related to Wolfi. So, there’s reason to believe that the uBlue team takes security seriously enough to work, contribute and deliver on more secure alternatives as long as it doesn’t come with a price to be paid by convenience. Which, in all fairness, is IMO exactly why Homebrew is used for in the first place (besides their recent utilization of technologies that have similarities to the ‘uBlue-way’ of doing things)…
I learned quite some things from this talk
https://youtube.com/watch?v=4WuYGcs0t6I&t=456
Appimages are damn broken
I mean, I’m not saying they aren’t. I think the original argument is valid. I just think they’re better than the alternative, which isn’t Flatpak but self-extracting .sh files.
Yes thats true. But that talk specifically mentioned the horrible security practice of appimages, and that they dont run everywhere at all
Here is an alternative Piped link(s):
https://piped.video/watch?v=4WuYGcs0t6I&t=456
Piped is a privacy-respecting open-source alternative frontend to YouTube.
I’m open-source; check me out at GitHub.
oh boy here we go I strongly disagree with this article
While complex .tar archives (like firefox) may seem messy, they integrate many different things. An installer script takes care of placing a .desktop entry, you can have an updater script, a LICENSE, README and more. Those are all missing with Appimages.
.tar ARE messy, sometimes they don’t work right, dep conflicts, etc. An installer script can be shipped with an appimage anyways. Moot point IMO
Apps installed with the system package manager get their .desktop Entry in /usr/share/applications, installed Flatpaks get their entry linked to ~/.local/share/flatpak/exports/share/applications/, user overrides and other installs can be put in ~/.local/share/applications/.
Appimages have no desktop entry, so they have (currently) no icon on Wayland and they don’t appear in your app list. Desktop entries are a standard, used by everytthing but Appimages.
see above
Instead users follow strange habits like placing the files on their desktop, which is a highly discouraged “Windows workflow” (symbolic image) and not even supported on many Desktop Environments, most notably GNOME.
Who discourages it? I personally prefer this myself, lack of desktop icons is a common complain for stuff like GNOME…
This is both a usability and a security issue. Traditional Linux apps, even if they are cross platform, don’t have updater services, as package managers are way better at doing that.
I disagree that this is better. A personal issue but I Much prefer when apps can update themselves.
This means, packing as an Appimage either requires to implement an updating service, on a platform that doesn’t need that, or to have no updates at all.
Instead users need to follow an RSS feed, get a mail, or manually check for updates, which is horrible UX. Then how do they update?
Is this really a massive issue? There have been appimage stores in the past. Self updating appimages really isn’t that hard either. If this was a massive issue, you could do something like obtanium for android which could easily automate the process.
Appimages don’t even have a central place where you can find them, not to mention download them. This is extremely insecure. Modern Application stores and every well made Linux repository uses cryptographic (mostly gpg) verification, which secures the authenticity of the software. You can be sure you downloaded the real package.
I’d argue it makes little difference. But yes, Downloading things from the internet is more unsafe then downloading from a repo or a “curated” service. So we can grant one here.
There is no updating mechanism. On Android you may also update by downloading .apk files, but once installed, the .apk needs to be signed with the same key, otherwise updates are blocked. With Appimages… you just delete the old .appimage file, download the new one, change the name to remove the version and hope your .desktop entry didn’t break.
This is how you get malware.
the risks seem blown out of proportion here. As long as you are downloading from the same place, the risks are significantly smaller in reality, not gone, but smaller.
They are not well maintained
There is a well known “bug” on modern Ubuntu, where Appimages lost their “works on every Linux Distro”, because they are built for the outdated libfuse2, while Ubuntu now uses libfuse3. The fix is to install the outdated version of libfuse (!), and this is still not fixed.
An application format, that is incompatible with the latest version of its core dependency, is broken.
This is a very minor issue, i’ve had way more issues with traditional repo packages then I have had with appimages.
Lack of Sandboxing …
I find this to be a benefit myself, I have had countless headaches with flatpak applications and their sandboxing. everything from devices not being recognized, weird storage issues and more.
Random location …
Another moot issue. $HOME/.local/bin is an XDG standard, so unless we pretend that XDG standards aren’t “one of the major standards” this is just wrong. https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
Duplicated libraries
Appimages bloat the system. They include all the libraries they need, and unlike system packages or Flatpaks, they don’t share a single libary. If users would really install every Software as Appimages, they would waste insane amounts of storage space.
This also completely discourages efficient and up to date packaging, and the attached risk of outdates libraries is hidden away in that .appimage archive.
and? When you need only a couple appimage files, space I find is smaller then flatpak, it only becomes when you need a lot of applications.
Appimages are not needed Flatpak solved many Linux desktop issues at once …
None of these provide reasons as to why appimages aren’t needed. Appimages still offer a lot, for one I can just download and run it I don’t need to worry about installing and uninstalling application when I just want to try it, I don’t need to muck about trying to get an app into flathub or starting my own repo, when a user has a problem, I can just tell them to run the new appimage instead of trying to get them to compile it.
Appimages also let me do fine grained control over the dependencies. No unexpected runtime updates, I can compile the deps with flags/features I want to support, and disable flags/features I don’t want to support, Users don’t need to download a stupid appstore or use CLI (not a single appstore i’ve used to date isn’t hot garbage, I hope cosmic-store will be different).
I agree with much of this. However, regardless of which platform you’re on. it’s best to follow the design patterns of that platform.
Putting binaries on your desktop is not in keeping with Linux design patterns, nor are self-updating apps. I think those are fair points.
Having dozens of apps all using their own update mechanism introduces unnecessary complexity, which can be exploited. This has been a problem on Mac and Windows over the years. On Mac, for example, a common solution to this is the Sparkle framework, which devs can use in their app to manage self-updating; but Sparkle itself has been exploited, so then you have apps out there running god-knows-what-version of Sparkle in their bundles, leaving users vulnerable with no good way to identify or remediate it. This is why I typically disable any self-updating feature in any apps I use.
Dont know where user installed tar archives (with statically linked binaries or including deps) would have dep conflicts, maybe if they are not statically linked.
The self updating stuff and desktop icons is personal opinion and not the common way on Desktop Linux, so I skip that.
you could do something like obtanium for android which could easily automate the process.
That is called a package manager, with a repo, with gpg signing etc. On Android (which I mentioned) updates are secure. Let alone the point that appimages are not updated in a regular way, they are just replaced.
I’d argue it makes little difference. But yes, Downloading things from the internet is more unsafe
No the difference is huge. If you are used to downloading software from websites, a faked website can easily lead to downloaded malware. Flathub can be added with a click and flatpak is included in distros, which means no hunting on the internet and no accidental clicks.
And as I said, until nobody downloads .flatpak packages online, and there may be an occasion where this is normal behavior, people will believe malware links are legit.
the risks seem blown out of proportion here. As long as you are downloading from the same place, the risks are significantly smaller in reality, not gone, but smaller.
Appimages are distributed everywhere, just as .exe files for Windows. This means they are favored by developers used to Windows and Mac, and those will not add them to a repo instead.
So a faked website of whatever etcher or something is easy.
The fact that Linux malware is not a thing, while Appimages clearly give the headstart for that, is a miracle.
I find this to be a benefit myself, I have had countless headaches with flatpak applications and their sandboxing. everything
Flatpaks are not secure because their sandboxes are weakened to not have such issues. This is due to apps not following secure standards, and until that is fixed they are insecure or broken or both. (Apps need to write configs in the container, they should use portals etc.)
I maintain a list of flatpak apps following modern standards, which is a small portion but getting better.
Linux is only somewhat secure because everything is FOSS and comes from repos.
This is broken by appimages, that can easily distribute malware and thus fix the “my malware is not running on that distro” issue.
Every software that can write to your .bashrc can easily catch your sudo password.
Another moot issue. $HOME/.local/bin is an XDG standard, so unless we pretend that XDG standards aren’t “one of the major standards” this is just wrong.
Yes linux experts would put them there. As mentioned in that text malware would also install itself there, so on secure systems this should be only writable by root/ some elevated group privilege.
But apart from that users put them on the desktop, or in some random folder, I mean that dir is hidden for a reason.
Or put it in that PATH and then link to the desktop, resulting in a broken link when you remove the app.
When you need only a couple appimage files, space I find is smaller then flatpak, it only becomes when you need a lot of applications.
If something is not scaleable its not a good concept. The fact that you will only install a couple of appimage apps is enough proof.
On modern atomic distros users can rely purely on flatpak.
Btw see the linked dedup checker. You may download more dependencies but they are linked between each other and not actually take up so much space.
I don’t need to worry about installing and uninstalling application when I just want to try it
We need to overthink those habits. You dont just “try an app”, you run unsandboxed code from an unverified origin. As mentioned above, this could be totally fine, and also add a function to your bashrc that catches your sudo password (the next time you use it) and sends it to a server.
The secure way to do that is completely unpractical.
- Get a GPG app or use the cli, create a personal key. Secure the access permissions, as gpg always complains on Fedora for example.
- Hunt the internet for the gpg key of the dev
- Look for at least another source of that key like GrapheneOS does it
- Compare those keys hashes using cli or some app
- When correct, load the key into gpg/kleopatra/kgpg
- Verify the key with your internal key (yeah gpg is overcomplicated)
- Download the appimage, and a signed hash (most of the time its done like that)
- Verify the signed hash
- Sandbox the appimage using bubblejail (doesnt work) or firejail (no idea if it works, and its insecure)
- Repeat on every damn update (if it doesnt have a builtin updater)
This is unusable. And repositories do this automatically without anything you need to do. For sure you could “extra check the website” and say "
Also app data will be everywhere, often in its traditional location, while there is no package manager at all to delete them. Flatpaks store all their stuff (when devs care and not just ignore that, cough Cryptomator) in their container and data can be easily removed during uninstallation, GUI stores show a popup to delete data and I also made a small script to do that.
And that “try it out” app will either have no desktop entry or that entry needs to be manually and will be still there after uninstalling.
I don’t need to muck about trying to get an app into flathub or starting my own repo, when a user has a problem, I can just tell them to run the new appimage instead of trying to get them to compile it.
This may be a reason, but this is only for testing then. But for sure, when its a small project, getting it on Flathub may be much efford.
I can imagine the developer experience is easiser. Flatpaks are simply very “defined” and need all that metadata and more to be complete. But needing to use available runtimes is a good thing mostly, its basically supporting a specific distro.
Flatpak through CLI is fine (I would like to have a standalone small store just for flatpak), Discover is nice too. The Linux Mint store also seemed fine but not much experience. (Linux Mint has some Wayland support now, so there is a secureblue Cinnamon spin, have to try that). The Cosmic store is just a stub currently, lets see!
Cheers!
Odd, this random github rant didn’t seem to sway my opinion.
To hell with user choice, only flatpak
I’m not going to weigh in on the specifics of Flatpak vs AppImage, because I don’t know enough about the particulars.
However, I think the “user choice” argument is often deployed in situations where it probably shouldn’t be.
For instance, in this case, it’s not the user’s choice at all, but a developer’s choice, as a normal user would not be packaging their own software. They would be merely downloading one of a number of options of precompiled packages. And this is the thrust of the argument. If we take the GitHub rant at face value, some developers seem to be distributing software using AppImage, to the exclusion of other options. And then listing ways in which this is problematic.
I, for one, would be rather annoyed if my only option were either AppImage or Flatpak, as I typically prefer use software packaged for my package manager. That is user choice, give me the option to package it myself; hopefully it’s already been done for me.
There are some good things to be said about trust and verification, and I’m generally receptive to those arguments way more than “user choice.”
