This topic seems to be a merry go round, do what suits your use case, there is no real answrr to this question except what you decide works for you
You only win if you use nothing but snaps.
Of course, what you win is a different question… ![]()
The only thing I agree with you is the readability of the manifest because the dependencies are “embedded” and it’s time consuming, but you have to do the same with any PKGBUILD of dependency to install/upgrade.
Anyway, if you want to do it the AUR way, you can build your flatpak release using the manifest with flatpak-builder. Something like :
flatpak-builder build_directory io.github.foo_manifest.yml
IMO, it is pointless to build it yourself unless you have thoroughly reviewed the entire contents of the repo. That is a herculean effort compared to a reviewing most PKGBUILDs.
Also, a good AUR helper integrates that process directly into the upgrade process in a highly consumable way. When I upgrade an AUR package I get a clear color coded diff that typically has less than 10 lines that changed. It is directly in the path of the upgrade. Unless something changed drastically, I can review a dozen packages for changes in less than a minute.
With flatpak, I would have to create some manual process where I get a list of the flatpaks that want to be updated, locate each repo and then somehow look at all the commits since the last time I was there. That isn’t even remotely the same. That would be a manually laborious and time consuming process.
But I am not here to tell anyone else what they should use or how to run their system. If you prefer flatpaks, then that is great.
However, I do want to share my opinion on some of the risks associated with flatpaks though. I want people to make a thoughtful decision based on reviewing all sides of the conversation. The idea that “flatpaks are more secure” is false. With any consideration like this, there are trade-offs in both directions and you need to look at all those trade-offs and decide which are most important to you personally.
To me flatpaks are not more secure, it’s just that they’re not full of malware, because the maintainers are not reliable according to some people, and the manifests are not complex, their syntax is almost as easy to read than PKGBUILDs.
It’s interesting to see that in the more mainstream linux forums and in the space of linux youtubers, flatpak is lauded almost as a miracle, as the “future”; yet dig around a little bit deeper than surface level, and ask real people using linux, and you’ll see it in a different light. I myself use flatpak for things like steam and my browser but only because of flatseal. Otherwise, I’d use my distro’s official repo primarily for most things
I don’t think flatpak is seen as a miracle, but as the future, I can understand. With flatpak you don’t care about the package format, it can be installed on any distro.
- I am exaggerating a bit. But wouldn’t you say it’s 99% correct?
- Care to share what those programs are? I am just curious if it’s not a privacy issue.
I’m not a bean-counter, but I’m sure you can find many applications that are not in the AUR, browse Github or Gitlab. Among those apps, some have a flatpak, Appimage or snap release because their dev decided to distribute them in these formats.
I didn’t make a list, if I remember, they were video or subtitles tools.
I see. It’s just that I never came across such a scenario. Even the most obscure software, for whatever reason, has an AUR package.
I’m pro flatpak.
advantages:
-Easy and fast to update
-Nigh impossible to break your system with them
-I may not know what’s in the Steam flatpak, but I can remove all the bullshit folder permissions with ease at least.
-The huge userbase & flathub usage data is more useful to me, than installing something really important from AUR, while it only having thirty-something votes. (xiccd is super important for me, but I’m a little worried about its current future in AUR)
-looking at the build file is important & not very hard, but how useful is that without looking at the source code itself, but is that really realistic from a normal user? (I’m still somewhat new to Arch, so I could be off base with this one)
If the packager is the owner of the source code, it useful in that you can ensure that they aren’t using any out of date or insecure software. Remember, a flatpak for an application doesn’t only contain that application, it contains lots of other stuff as well.
On the other hand, if the packager is an unknown entity, it is much more useful. It also tells you the source of the package is correct and that there is nothing else being added.
The same as checking an AUR package that has other AUR packages as dependencies.
Which is pretty uncommon honestly. I don’t have a single AUR package installed that has other AUR packages as dependencies.
My filter is considerably more blunt. I presume flatpaks are “statically linked” and, therefore, have a larger footprint. Therefore, I’ll go to the AUR first and flatpak if I must.
Right, but it happened to me few weeks ago, cemu emulator with fmt9 as dependency.
Same here, the “if I must” being old release compared to flatpak or AUR not reliable (no checksums).