I didn't understand Linux package managers until everything broke — now I have one rule

For the longest time, I treated Linux package managers like a vending machine. Need an app? Install it. Need another one? Install that too. APT, Flatpak, Snap were mixed and match, and then sprinkled in a PPA or two. What could possibly go wrong? For a while, nothing did. And that was the problem. Because it gave me just enough confidence to keep going. Linux didn’t push back. It didn’t warn me. It didn’t pop up a helpful little message saying, “Hey, maybe don’t install three different versions of the same app from three different ecosystems.” It just … let me.

And the more it let me, the more I assumed I knew what I was doing. Until one day, everything broke. Not dramatically, and definitely not in a satisfying, explosion-and-error-messages kind of way. Just … subtly wrong. Apps stopped launching, updates failed, and dependencies started arguing with each other like a dysfunctional family that had been politely avoiding conflict for years and suddenly decided tonight was the night. That was the evening I realized I didn’t actually understand how Linux installs software.

Why everything worked until it didn’t Linux lets you stack complexity without warning Roine Bertelson/MakeUseOf

Modern Linux distributions are incredibly forgiving. You can install software from multiple sources without thinking too hard about it, and most of the time, things will just work. APT pulls from system repositories and keeps everything tightly integrated. Flatpak installs sandboxed apps with their own dependencies. Snaps bundle their own environments and update independently. PPAs quietly inject newer or alternative versions straight into your system.

At first, this feels like freedom. Real freedom. The kind that makes you feel like you’ve escaped the walled gardens of other operating systems. You’re not waiting for updates. You’re not locked into a single store. You’re not being told “no.” But freedom without friction is a dangerous thing. Because all of these systems solve slightly different problems. They don’t share a single view of your system, and they don’t coordinate with each other in any meaningful way. They coexist, sometimes peacefully. Other times, not so much.

So you can install the same app three different ways, each with its own dependencies, update logic, and expectations about the surrounding system. Linux doesn’t stop you. It doesn’t even slow you down. It just quietly lets you stack complexity until something eventually gives.

Related When the cracks started to show Nothing failed completely, but everything felt off Screenshot: Roine Bertelson

My system didn’t crash. That would have been clean, obvious, and fixable. Instead, things started getting weird in that slow, creeping way that makes you question your sanity and grip on reality. GIMP installed through APT refused to launch after I installed a Flatpak version of the same thing. A PPA replaced a system library just enough to make updates complain without fully explaining why. Snap apps behaved slightly differently, just enough to feel inconsistent in ways that were hard to describe but impossible to ignore.

Nothing screamed “this is broken.” But everything felt off. Animations had a slight hesitation. Apps took a beat longer to open. Updates started throwing vague, passive-aggressive errors that felt less like diagnostics and more like hints. Removing one app would quietly break another. Reinstalling didn’t always fix anything because the problem wasn’t the app itself. It was the ecosystem it came from. Or more accurately, the ecosystems I had stacked on top of each other without thinking. And the worst part was how invisible it all felt. There was no single error message pointing to the root cause. No obvious “you did this” moment. Just a growing sense that the system was becoming harder to trust. That’s when it clicked. This wasn’t random. It was an accumulation. Small, reasonable decisions piled up until they stopped being reasonable together.

The realization that changed everything Package managers aren’t interchangeable

This is the part I wish I had understood from day one, or at least before I started casually adding PPAs like they were browser extensions. APT, Flatpak, and Snap aren’t just different ways to install the same software. They are different philosophies pretending to coexist peacefully.

APT assumes a shared system. Libraries are reused. Dependencies are managed centrally. Everything is expected to play nicely together, because it all lives in the same world.

Flatpak assumes isolation. Apps bring what they need and largely ignore the system. That’s why they’re more portable, often more up to date, and sometimes slightly heavier.

Snap takes a similar approach, but with its own packaging format, update behavior, and runtime model layered on top. It solves some problems while introducing its own quirks, as anyone who has waited for a Snap app to start can confirm.

And PPAs? They bend the rules entirely by replacing parts of your APT ecosystem with custom versions. Powerful, useful, and slightly chaotic if you forget they’re there, which I absolutely did.

None of these are wrong. But they’re not interchangeable either. And they’re definitely not designed to be layered on top of each other without any kind of plan. Mixing them casually is like combining parts from different operating systems and hoping they’ll behave like one coherent system. Sometimes they do. Until they don’t.

The one rule that fixed my system Every app gets one home Screenshot by Sharqa Hameed -- No attribution required

Cleaning this up wasn’t fun. It involved uninstalling duplicates, purging leftover packages, removing PPAs I had completely forgotten about, and trying to figure out which version of what was actually being used. At one point, I had three versions of the same app installed on three different systems, and none of them behaved exactly the same. That felt less like flexibility and more like I had accidentally created my own fragmented software multiverse.

Somewhere in that cleanup process, slightly annoyed and slightly impressed with how thoroughly I had complicated things, I landed on a rule that felt almost embarrassingly simple: Every app gets one home. If I install something through APT, I stick with APT for that app. If I choose Flatpak, I commit to that version. If I absolutely need a PPA, I treat it like a deliberate choice, not a casual addition I’ll forget about later.

No duplicates, no overlap, and absolutely no parallel installs quietly drifting out of sync in the background. The effect was immediate and, honestly, a little surprising. Updates stopped complaining. Dependencies stopped conflicting. Removing software actually removed it instead of leaving behind little ghosts. My system started behaving like a system again instead of a collection of loosely connected decisions. And maybe more importantly, I stopped second-guessing every weird little issue. Because now I knew where things lived.

Linux didn’t break. I just finally understood it

That’s the uncomfortable truth. Linux didn’t betray me, it didn’t randomly fall apart, and it didn’t decide to have a bad day.

It followed my instructions perfectly. I just didn’t realize those instructions were conflicting. Once I understood how package managers actually work, the chaos stopped feeling mysterious. It became logical. Predictable. Even a little obvious in hindsight, which is always how these things go. And once something is predictable, it’s fixable. Linux didn’t need to change, but I did.

View Original Article