Skip Navigation
101 comments

  • 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.

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

  • 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.

    • I’ve rarely had issues with App Images, but they are clunky and messy.

      How so?

      • You have to use a separate application to manage them, otherwise they act as portable .exe files in windows, just laying around in a folder you have to manually link to or navigate to to run. You have to set them as executable manually otherwise you can't run them in certain distros, or they force you to click through the prompt. They aren't listed in the general packages installed on your system.

        They are often bulky in size, and depending on the distro and software, sometimes they don't work properly. And again, without independent management software, they have to be manually updated independently.

        They aren't bad, they just arent as good as other options IMO. I like App Images for random small programs, or some games too, they aren't a problem. But for large programs I want to use frequently, they are just less convenient.

  • 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.

  • 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.

  • 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.

  • 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.

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

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

  • Flatpaks are insecure by design as they don't cryptographically verify their authenticity after download. Snaps too.

    Install with a proper package manager that was designed doe security. Most OS package managers are designed with this.

  • tbh never looked into snaps flatbacks or appimages. However my instinct as a staunch linux is that anything besides apt-get or apt or aptitude is utter trash. we already have apt, why do people feel the need to divert energies to these unneccessary packagemanagement-fads?

    • The problem here is that there are so many linux distros that are trying to do their own thing. Sure, a Debian-based distro would use apt, but a lot of the other distros like Void and Fedora use different package managers to suit their needs. I personally use Arch Linux, and that uses pacman which is my manager of preference. There are packages that I cannot find and/or install via pacman and the AUR due to them either not being built as an Arch binary, or being left abandoned by the developer who couldn't bother supporting multiple distros and their package managers, or not having a compatible dependency built for my system.

      Flatpaks and AppImages allow for a developer to place an application and all its dependencies in a neatly packaged group. This allows developers to only need to create one package that works on many distros and won't be affected by dependency changes. I use a Flatpak package for Steam because, due to the rolling-release-nature of my distro, sometimes the native install breaks and/or doesn't open properly.

      In theory, Snap works in a similar way as the other two, but that is a proprietary package manager that doesn't work on my distro without far much more effort than needed for any proprietary software should ever need to get working ever.

      The only real downside to these package managers that I've seen is that the package size is larger than any native install. I am personally fine with this tradeoff however, as I have gotten quite used to building Python container environments recently.

101 comments