I am currently using Linux Mint (after a long stint of using MX Linux) after learning it handles Nvidia graphics cards flawlessly, which I am grateful for. Whatever grief I have given Ubuntu in the past, I take it back because when they make something work, it is solid.

Anyways, like most distros these days, Flatpaks show up alongside native packages in the package manager / app store. I used to have a bias towards getting the natively packed version, but these days, I am choosing Flatpaks, precisely because I know they will be the latest version.

This includes Blender, Cura, Prusaslicer, and just now QBittorrent. I know this is probably dumb, but I choose the version based on which has the nicer icon.

  • @ebits21
    link
    English
    42
    edit-2
    10 months ago

    I have a ton of flatpaks which means packages are shared between them, so no it’s not lazy or a copy of the whole system. It makes a ton of sense for stability.

    Updates are diff’s so downloading and updating is fast. Not entire packages.

    Making every package work with only a certain version of a dependency and hoping it is stable doesn’t make a lot of sense.

    • stevecrox
      link
      fedilink
      1610 months ago

      You’ve just moved the packaging problem from distributions to app developers.

      The reason you have issues is historically app developers weren’t interested in packaging their application so distributions would figure it out.

      If app developers want to package deb, rpm, etc… packages it would also solve the problem.

      • @ebits21
        link
        English
        3610 months ago

        Sure. Except you gain universal compatibility for all distros that have flatpak and aren’t building all the different package formats. Makes it much more attractive for actual developers to package since it’s only done once.

        There’s no right answer here, but there are definite benefits.

        I’ve had many little issues since I moved to Linux years ago, most of which would never have been an issue if flatpaks were there at the time. My experience has been better with them.

        • @[email protected]
          link
          fedilink
          English
          610 months ago

          Makes it much more attractive for actual developers to package since it’s only done once.

          I maintain a few apps that are included into some distributions with no participation from my side apart from tagging what I consider releases in my git repo. How is doing something only once is more attractive as not doing it at all?

          • True Blue
            link
            fedilink
            English
            3
            edit-2
            10 months ago

            Because you can make sure it was done right. You don’t have to worry about bugs or other issues being the result of faulty packaging if you’re the one doing the packaging. Plus It makes reproducing bugs easier when everyone’s using the same package, and declaring the flatpak as the official package makes it much more likely that people will use the flatpak.

    • db2
      link
      fedilink
      English
      310 months ago

      You know you can have many versions of a library on your system at once, right?

      • @ebits21
        link
        English
        12
        edit-2
        10 months ago

        As long as they don’t cause conflicts. You know dependency hell is a thing right? The reason flatpaks were thought up in the first place? Right?

        • stevecrox
          link
          fedilink
          10
          edit-2
          10 months ago

          Nice out of date dependencies with those lovely security vulnerabilities!

          • @ebits21
            link
            English
            210 months ago

            Touché

            Developers shouldn’t be out of date, but yes.

      • @[email protected]
        link
        fedilink
        English
        410 months ago

        Besides that it’s only partially true (unless we speak Nix systems) That’s also not the point of it. It’s more about having runtime environment that an app was built against and tested with.