trevor (he/they)

I posted this in another thread, but reposting here because a lot of people, including myself up until very recently, were under that impression:

I’ve packaged a CLI that I made as a flatpak. It works just fine. Nothing weird was required to make it work.

The only thing is that if you want to use a CLI flatpak, you probably want to set an alias in your shell to make running it easier.

I’m not sure why more CLIs aren’t offered as flatpaks. Maybe because static linking them is so easy? I know people focus on flatpak sandboxing as a primary benefit, but I can’t help but think that if static linking was easier for bigger applications, it wouldn’t be needed as much.

I’ve packaged a CLI that I made as a flatpak. It works just fine. Nothing weird was required to make it work.

The only thing is that if you want to use a CLI flatpak, you probably want to set an alias in your shell to make running it easier.

I’m not sure why more CLIs aren’t offered as flatpaks. Maybe because static linking them is so easy? I know people focus on flatpak sandboxing as a primary benefit, but I can’t help but think of static linking was easier for bigger applications, it wouldn’t be needed as much.

I’m not quite sure why you think pointing out someone’s confidently incorrect claim that containers do give you reproducible environments means that I fetishsize anything?

But if you genuinely want to know why reproducibility is valuable, take a look at https://reproducible-builds.org/.

I was quite happy to see that Debian and Arch have both made great strides into making tooling that enables reproducible packages in recent times. It’s probable that, because of efforts like this, creating reproducible builds will become easier/possible on most Linux environments, including traditional container workflows.

For now though, Nix Flakes are much better at enabling reproducible builds of your software than traditional containers, if you can suffer through Nix not being documented very well. This article covers some more details on different build systems and compares them with Nix Flakes if you want more concrete examples.

FWIW, I think that containers are awesome, and using them for dev environments and CI tooling solves a lot of very real problems (“it works on my machine”, cheap and easy cross-compilation for Linux systems, basic sandboxing, etc.) for people. I use containers for a lot of those reasons. But if I need to make something reproducible, there are better tools for the job.

🤡

For dev environments, repeatable is okay. If you want actually reproducible binaries that you can ship, Nix is better fit for that purpose.

Care to elaborate? Containers give you repeatable environments, which are not the same thing as reproducible environments.

Okay, so this definitely feels like bad practice to not change the version number or URL, even in something trivial like example texts here. But what real-world significance does this have?

It almost seems equivalent to just changing a variable name based on how it’s being used, which – to be clear – should come with a version bump, but I can’t imagine this having any meaningful impact anywhere.

The biggest downside to containers vs. Nix for me is that Nix can produce binaries for Linux and macOS, whereas docker only helps with Linux unless you can perform literal magic to cross-compile your project on Linux for macOS.

Containers also don’t give you reproducible environments, and Nix does.

That said, Nix documentation is ass, so I usually end up going with containers because they require far less suffering to get working because writing a containerfile is much easier than guessing how to hobble together a Nix flake with a mostly undocumented language.

All those packages, but terrible/lacking documentation and LSP support 😭 And, yes, I’ve tried nixd and nil, and they’re not even close.

I’ve tried to learn Nix multiple times, and even got by okay running NixOS for a year or so, but doing almost anything that isn’t just adding a package to a list in a nix file or flake was like pulling teeth because everything is documented so poorly (or not at all). It would take me hours to do what I could have done in seconds with any other package management tool or configuration management because I’d have to scour hundreds of search results to find someone that did the thing I’m trying to do because there was little-to-no documentation for it.

Nix is a tool with amazing promise that could solve so many problems if they could get their documentation and LSP support up to the standard of something like Rust.

I would say that development is the one thing that can get very annoying on immutable distros.

Flatpaks can only get you so far (as seen by the VS Code Flatpak’s limitations that have to be worked around). I don’t even use VS Code, so I can get around that pretty comfortably, but I have to use Distrobox for a lot of miscellaneous developer tools, and even then, I still run into problems and I can’t install container tools inside of the containers that I’m already working in.

Not to discourage you from trying. I can still get by with some dev work on Bazzite, but it’s waaay easier to do the same dev work on CachyOS (Arch-derivative) because I can just install shit normally and it will work.

Same. If most of my games stopped working, I would be very annoyed, especially because it was entirely preventable.

Thankfully, the Fedora project and community agree.

No. Valve (the biggest offender) will have to make native 64-bit Steam before then, as will the remaining holdouts, so Linux distros will be able to remove 32-bit packages in a timely manner.

Removing then now will break too much to be worth doing.

I highly doubt that those “couple dozen” patches are trivial though. Even Pixel devices can’t run the vanilla mainline kernel without a bunch of added code to make it work with the hardware (see: the Greg KH interview I linked).

And abstracting the hardware is what you do when you make drivers, so this is a distinction without a difference.

I mean, Linux is the driver layer, and you mentioned GNU (userspace) / Linux (hardware layer), and the Linux part of that solid base can’t just be the vanilla Linux kernel that you’d run on a computer.

Sort of. Whatever hardware these are intended to run on require something like 3X the driver code (at least in the case of the Android Linux kernel, according to Greg Kroah-Hartman). Phones tend to have more specialized and proprietary hardware, so you can’t just take the standard Linux kernel, use it there, and call it a day.

But I’d be surprised if the people working on this weren’t aware of that fact, and I hope they are working on abstracting the hardware layers more so that every mobile Linux project doesn’t have to start from scratch every time.

Edit: source (YouTube, sorry) for the claim about how much driver code is required for mobile devices.

This is why I hope to see rule zero get shit-canned. It’s a naive vestige from a time long before we hit late-stage capitalism. Corporate interests have slithered their way into every facet of our lives and we should be working to make software that we write hostile to their practices as much as we can.

If that means that the organizations that have a stranglehold on Open Source™️ don’t like it, so be it. We can follow in the spirit of open source without the naivety or captured interests of organizations that define the arbitrary terms by which we categorize software licenses.

Yeah. A lot of the extra nice things about Ghostty come from native macOS features. It’s a very different story on Linux, but still a solid terminal emulator there as well.

Ghostty is amazing on macOS. On Linux, it’s basically another GTK terminal emulation with a lot of nice configuration options, but nothing that special.

You can already sort of hack distrobox-like functionality, but the biggest problem with doing so is that there’s no Wayland or X11 server running on macOS, so GUI applications don’t work unless you install something like XQuartz, and even then, it’s a pretty janky experience.

I beg of you: try something that isn’t going to shove a broken packaging format like Snaps down your throat.

Try Pop!_OS or Linux Mint if you want something like Ubuntu, only not broken.

If my first experience with Linux involved wasting time trying to figure out why the applications I installed appeared to freeze because they take 30-60 seconds to open after installation or updates, randomly didn’t work because of dogshit sandboxing, etc., I probably would have turned away.