None. I prefer native packages. AUR usually has me covered and hasn't broken my system...ever, really. Yet, anyways. (Well, it might have broken my Manjaro install, but it is Manjaro, so i probably sneezed wrong)

....but, if I had to pick one? Flatpaks. Outta the three, they've given me the least trouble and just work right out the gate. Still prefer native packages tho

As far as I know, Flatpaks have the best foundation currently, there are a number of issues, but they are fixable and not entirely by design. And with Fedora Silverblue/Kinoite and OpenSUSE MicroOS you can really see how native debs/rpms/whatever isn't really that good of an idea for the average user and Flatpak is a solution to that.

Appimages at a glance seems like a perfect solution for apps that for some reason or another needs to be kept outdated. But there is (was?) an issue of it not really bundling everything it needs, it looks and behaves as it is portable, but as far as I'm aware, it really isn't.

And then there's Snap. Yeah, that one is just weird, it honestly just doesn't feel like a proper solution to any of the problems it tries to fix.

Flatpak -- It's not without it's own issues, of course, but it does the job. I'm not fan of how snaps are designed, and I don't think canonical is trustworthy enough to run a packaging format. Appimages are really just not good for widespread adoption. They do what they are designed to do well, but I don't think it's wide to use them as a main package format.

Flatpak is my preference since it supports multiple remotes (repos) and sandboxing. With flatseal tweaking the sandbox is also easy.

Snaps work great on Ubuntu and support cli tools as well as system components. But their sandboxing doesn't work on many distros and the one and only repo is controlled by one company. If I'm not on Ubuntu, I don't see any reason to choose it over flatpak.

Appimages are great for putting on a USB stick or keeping a specific version of software. But I want to install software from a trusted repository, which Appimages support at best as an afterthought.

Snaps is too well controlled by Canonical and does have it's limits.

Flatpaks can be very secure, and works in most distros. It is one of my favorites.

AppImages are real easy, and is designed to work on most distros. The only problem is that many apps aren't current. So I don't recommend it unless an app provides it on their own sites. AppImages are often made by somebody else.

Flatpaks. On Mint, the GUI update tool updates both Flatpaks and natively installed packages. It's fantastic.

I prefer flatpacks. There's nothing wrong per se about snaps, it's just that they are kinda slow, and Canonical is untrustworthy.

Appimages are to be avoided, imo. They are no better than downloading random crap like on Windows.

Flatpak and Appimages. Flatpaks are the best solution IMO, just better than snaps in about every setting except servers. Appimages are great simply because of their easy portability, just being a single executable. I like having GUI apps in Flatpaks because it separates the updates for those applications from my package manager.

pacman or from source 😎 (i am superiour because i make it harder for myself)

Real talk? I genuinely don't care. I have actual work that needs to get done. I'm going to use whatever I can to make that faster/easier. Of all the decisions I need to make in a day, this is a pretty inconsequential one.

Flatpaks are quickly becoming my favorite. I've rarely had issues with App Images, but they are clunky and messy. Flatpaks are where it's at IMO.

Snaps are pewpy.

None of the above. Native debs/rpms/whatever for desktops, docker images for servers.

Flatpacks give me the least trouble so I guess those. All though appimages seem alright too. Snaps however seem to never want to install. I like the idea of easy one click installs for every distro but I think we are a few years away from that.

Flatpak is the best one imo. Never used appimages, and snap is pure trash (close source, slow, made by canonical). Overall, native packages are imo the way to go, but flatpak is also fairly good.

Flatpaks because their updating works (compared to my experience with Appimages) and the Apps starting instantly (compared to my limited experience with snaps). But sadly, a lot of production software doesn't want to support either of this package formats? I haven't seen support from Davinci Resolve or Mari, as an example.

Although I mostly use native software, I find AppImages useful for testing beta software, since they're one file and easy to try out.

For example: I've been using it with the Krita 5.2 beta and I have also used it before for Godot betas.

I use Flatpak when the native package doesn't work properly or isn't updated at the rate I'd like, although there are cases where I will use it for other reasons, like sandboxing when I don't want an app to have access to everything.

I have never used snaps.

none of them. I don't like the idea of putting security updates in the hands of the developers of each individual application I use.

Oh your app only works with an old broken insecure version of the library? Fuck you then, you can't just decide to install and use the insecure version.

debs

I prefer Flatpaks by a wide margin. This presentation by openSUSE's Richard Brown is a great watch for those looking for a thorough comparison.

AppImage is a nice idea, and avoids some of the performance overheads from containerised systems, but lacks a reasonable self update mechanism, lacks code signing and the desktop integration (having icons show up in the start menu) is poorly implemented.

Snap is essentially a Canonical-proprietary apt replacement with some very serious drawbacks around performance and desktop integration (themes).

Flatpak has some drawbacks but it largely achieves it's design goals, and actually provides some advantages over installing things via the system package manager.

IME Appimages often don’t work cause they don’t actually bundle everything they need (not sure if this is a fault of application developers, or some limitation). When they do work I actually prefer them to Flatpaks, which are honestly too complex IMO.

Snap kinda sucks

Appimage, but only if I can't get the program to compile from source first.

Flatpaks for graphical apps and guix for CLI programs and libraries.

Out of the three, I prefer Flatpaks. Mainly because they have a nice centralized-capable model for performing updates (but not locked centralized like Snaps are), and I can't say I've personally run into a distro where Flatpaks didn't work.

I haven't taken a look at them from a developer standpoint, but from what I hear the development experience isn't bad? If that isn't the case though, I'd love to hear more about why.

I've used Flatpak, it feels somewhat sluggish;
I had once upon a time used Snap (unwittingly), never again;
Appimages... with a lack of options, they seem to run well, although the two I've used seem to take away quite the chunk of memory.

But if it's a reasonable choice, I'll always go with natively distributed or locally compiled binaries. They may be janky sometimes, but in my opinion they beat the "just ship the entire computer br0" philosophy that clearly comes from the Windows ecosystem.

If I'm not using the package manager, I use mostly Flatpak. I will use a random AppImage here and there.

I prefer those two because I can pick when I update them, and I've not had a lot of issues so far. I don't like Snap because it reminds me too much of Windows Update. I know it can all be adjusted to my taste, but I already have an option that works out of the box.

For personal use, Flatpak when there's no native option, in most cases. They always seem to work and with Flatseal, you can more finely control permissions and local filesystem access of them.

For servers, if it's a single-purpose VM (like I do with my PiHole/AdGuard servers), I'll also go native. Otherwise, Docker for compatibility and ease of management.

Appimages are good for downloading off sketchy websites, Snaps are good for server CLI apps, Flatpaks are good for GUIs

But honestly they all solve the main issue pretty well

Nix.

Makefile

Definitly Flatpaks. Although snaps have improved since I last used them. But of all I still prefer the good old shell based Package manager.

Appimages could've been great if they had a store front like Flatpak, so while I do not always prefer Flatpak (because of how big the first download is) I use it the most.

I prefer the AUR, but if I have to use one of the three it's gotta be an AppImage these days.

I used to swear by flatpak, but because I'm on nvidia it just turns into a stupidly bloated mess since it never removes older driver versions. They're certainly not "bad" though, and I use them on my SteamDeck for sure.

I prefer AppImages on my Debian desktops as they normally simply work out of the box (download, start) and I had (many years ago) trouble with snap and flatpak.

Neither. I exclusively use Nix packages. If I had to pick, AppImage because I can easily extract it to package for Nix :P

i use arch just so i don't have to use any of these