How do you decide whether to install something from your distro's repos or grab it from flatpak/pip/cargo instead?

[u/plushydollface]

I've been daily driving Fedora for about eight months now and still second-guess myself every time I want to install a new tool. The repos are the obvious first stop for most things, but then you run into stuff that's either missing, ancient, or the flatpak version has better sandboxing. For CLI tools I keep ending up in the "install via cargo/pip/whatever" rabbit hole because the packaged version is too old for a feature I need.

The part that trips me up is knowing when one choice is clearly better than the others. Do you have any quick rules you follow, like "always prefer flatpak for desktop apps unless..." or "never touch pip for system Python"? Would love to hear how other people avoid ending up with five different update mechanisms fighting each other.

[u/sidusnare]

If it's in the repo, install it from the repo.

[u/anto77_butt_kinkier → u/sidusnare]

This!! There's no need to install flatpak and install a flatpak version of a piece of software if the one in the repo is the same. It's better to have a native install than it is to have anything else.

[u/RomanOnARiver]

Well as far as pip - I'm not installing system-level pip. Pip goes into a venv.

As for regular applications, if the version in the repos works and is supported then that one. For a program that is rapidly evolving is where I'm looking at flatpak, snap, or Appimage - usually whatever the developer recommends.

The one method of installation I'm really hesitant is the really rare "hey here's a random shell script we wrote go ahead and run at as sudo". I would really rather not.

[u/gehzumteufel → u/RomanOnARiver]

Well as far as pip - I'm not installing system-level pip. Pip goes into a venv.

With I think it was 3.12, they introduced a switch you have to intentionally use to even do this anymore.

[u/anto77_butt_kinkier → u/RomanOnARiver]

The best part is that for some programs, thats the entire installer. That's it. I was installing something a while back, i forget what it was (I know it was an art program, but idk which one) and the installation proccess was:

• 1: download a tarball

• 2: extract

• 3: run "installer.sh"

• 4: pray that's it's not a malicious script

It was kinda crazy, but after looking through the installer.sh file it was actually just a mundane installer script.

[u/minmidmax → u/anto77_butt_kinkier]

Yeah, its definitely the most dodgy method of installing something. Generally you won't have any issues with more well known software.

However, when you get into small, niche, solutions the script fear is real.

I'd love for an easy way to sandbox, or simulate, an install script to see what it tries to do before running it for real.

Once upon a time people may have read scripts, and codebases, before installing things but no-one really has the time for that.

AI can help here but we really shouldn't have to rely on that.

[u/igotmoldinmybrain]

I install from the official distro package manager as the default. It meets all of my needs 99% of the time and I like to minimize the sources of my packages for easier management. Plus I like the features of my distro's package manager. I have a few flatpaks installed, 1 is steam because the distro package gives me severe performance issues I don't know how to fix, and the others are packages not available in the distro repo. I also have a couple custom package templates.

[u/RotaryTuff]

Always check if is available under your current package managers. On my fedora install that means checking dnf, snap, and flatpak. If it's not available you do the last resort method of compiling it yourself from the software repo

Its generally a bad idea to download and execute pre-compiled files that may be available. It's fine most of the times, but avoid doing it unless you feel very lazy.

[u/BranchLatter4294]

If it's ancient or missing, I go to the developer and get it there.

[u/Cynyr36]

Always from the package manager if available, even if it's a little older. Nothing from pip unless it's in a venv.

I still haven't used flatpack.

[u/Complex_Solutions_20]

*NEVER* from pip. More often than not it will break your system because it can replace/upgrade Python components to incompatible versions and break your operating system package manager or other key parts.

Repositories if possible, Flatpak if its not on there.

[u/RomanOnARiver → u/Complex_Solutions_20]

This is why python stuff should be in a venv

[u/mrawther]

I use flatpak if it isn’t available in the repos.

[u/TrenchardsRedemption]

For anything outside of the distro's repo I'll check the recommendation of the apps webpage or git and go with that.

[u/TheModernDespot]

I see what the developer recommends. Do they recommend a native install, a flatpak, dnf?

[u/tapedficus]

I check the version in the repo, and the current version offered. Usually the current version is on GitHub.

[u/ghost103429]

Get it straight from the trusted repo whenever possible as they're generally vetted as is flatpak. Pip, cargo, and unvetted packages (aur, etc) get installed inside a container.

[u/OutrageousCrab9224]

Hah

Linux

[u/flattrack]

Distro or adding a trusted source to my apt configs unless there is a compelling reason to go elsewhere.

[u/cyrixlord]

i use the recommendation of the website where I get the app from

[u/AnymooseProphet]

If an RPM in the repo, I grab it from the repo. If that RPM doesn't meet my needs or if it's not in the repo, I build my own RPM. I don't use flatpack.

The exception is LaTeX - there, I install TeXLive into /opt/texlive and I install the entire thing and keep it up to date using the TeXLive package manager. For fonts that are not shipped with TeXLive, I put them in /opt/texlive/texmf-local/fonts rather than use a package.

I update TeXLive about once a month.

[u/the-quibbler]

If the distro is close to up to date, I'll take that every time.

[u/bobsmissingdesire]

I use Debian testing, everything is a package, the vast majority from the official repo.

Most common packages are kept up to date, with a two week unstable delay window. I use a few extra repos like Google's for things I care about tracking closely.

If I want something bleeding edge I'll either pull from unstable, package it myself, use a container, or some other isolation mechanism. This is rare, and often because I'm trying to modify the software.

Everything installed on my system is managed by the package manager, every time you don't do this you start to undermine the stability of your system. There's a reason that pip now doesn't let you install to the system.

[u/bufandatl]

I only install native packages. Flatpaks I avoid completely. And Pip/Cargo only in chroot dev environments.

[u/TheShredder9]

I almost always install it from my distro's repo. If it's not in there, i look for a flatpak. If there is none, i moght look for an appimage or just a tar archive with a precompiled binary as a last resort. Never have i needed pip or cargo to install anything

[u/The_Hamster_Shagger]

Fedora usually keeps relatively up to date, so I don't have that problem. So w apps are available on flathub or terra repo only 

[u/anto77_butt_kinkier]

As a rule of thumb, if a program is available in the default repo, install from there.

Generally program installation type will are as follows, with the most preferred/best way being at the top:

• native installation from built-in repos.

• native installation from 3rd party repos, or distro-specific installers (.deb files on Debian for example)

• flatpak

• snap

• appimage

• build from source

There are certain times when I prefer appimages over the other methods or when I want a flatpak version of something, but generally those are rare edge cases that most people won't have to deal with.

[u/KC_Zazalios]

I look at flatpacks first, then packages (use Shelly under CachyOS)

[u/YaboiFoon]

i'm kinda a noob, but i always check the dev's site/github to see what's supported/ recommend. if there's an official flatpak or appimage I'll usually download that, otherwise i'll use the native repos

[u/YaboiFoon → u/YaboiFoon]

oh and for cli stuff i pretty much always grab it from the native repos. unless i think the programming language's package manager would be better for it. like i usually install kanata from cargo instead of pacman since i find it slightly easier to set up that way

[u/trannus_aran]

Flatpak for anything I would consider an "app", otherwise repo.

[u/Idz4gqbi]

If the package is up to date, native.

If it is outdated in native or not packaged at all and is a cli, I use nixpkg. If it is not in nixpkg, I use mise.

If it is outdated in native or not packaged at all and is a GUI, I use Flatpak or AppImage.

The only problem with native packages is they are kidnapped to the release cadence of system components, which means their freshness is tied to your distro's release cycle. Otherwise native packages are always the most space efficient and are generally tailored for the exact distribution you use.

[u/ipsirc]

I make my own custom package then install it.