Hi, I’m looking to open-source a small CLI application I wrote and I’m struggling with how to provide the built app since just providing the binary will not work. I had a friend test it and he had to compile from source due to glibc version differences.
My first thought was providing it as a flatpak but that isn’t really suitable for CLI software.
I’ve googled around a bit and most guides I find just mention packaging separately for multiple package managers/formats (rpm, apt etc.). This seems really inefficient/hard to maintain. What is the industry standard for packaging a Linux software for multi-distro use?
Just build the app on very old distros like Ubuntu 16.04 if possible. But in general, packaging should be handled by the maintainer. If you want to be both a developer and maintainer, packaging problems will take up 75% of your time.
It’s not really hard for us users to follow your README and just copy the built binary to
~/.local/bin.Hi thanks for the reply. Could you elaborate on why building for an old distro may be benefitial/a good solution? Thanks for mentioning this developer/maintainer dynamic. It’s not a concept I was aware of.
Do you have any projects with good READMEs you could point me to, so I can get an idea of what’s important to address?
If you build your app with glibc 2.32 and then run it with glibc 2.39, it will run fine. But it won’t work the other way around.
There is no best README template, but for my personal projects I use this:
- Title
- Brief description of the project
- Features
- Build
- List of supported OS
- List of dependencies (what packages do I need to build your application)
- Commands to build the application (what do I need to do to build your application)
- Binary Locations (where can I find the built binary)
- Usage
- Program arguments (what do I need to provide to use your CLI application)
You can find an example here. I’m not saying this is the best README, but I think it’s simple and informative.
You don’t have to!
If a downstream distribution wants your software they will build and package it themselves and maintain that infrastructure.
You could provide an example rpm spec (etc) to make their lives easier but it’s not on you to provide a binary package that works everywhere; you released the source code so any given user / distro can compile it for themselves.
Just make sure that your build infrastructure and docs are up to speed, and ideally implement some CI/CD and testing to catch any breaking changes.
I see, thanks for the info. I wasn’t even aware that this developer/maintainer dynamic exists. It makes a lot of sense though. I’ll start by creating some documentation about building the software and then maybe create an example package for rpm.
This dynamic does exist, but you have to build something useful to the likes of Debian and Redhat and that’s a tall order. You should look into Linux brew, it’s a community maintained package management system that might be more suitable for your scale https://docs.brew.sh/Homebrew-on-Linux
This only applies if your program becomes popular or you go to a huge amount of effort packaging it yourself. And even then updates are going to be a huge pain. Do you want your users to be able to use the latest version easily?
There’s quite a big gap between “no users” and “included in all distros” where this advice doesn’t apply.
the best possible “industry standard” in my opinion is nix, but people need to install it on their machine, other than that don’t package lol, put a curl link in your github/gitlab to how install it and problem solved lol
deleted by creator
I have seen some CLI tools distributed via docker. You build a docker image and push to dockerhub, then supply a commandline like:
docker run -it -v workdir:workdir myapp:latest myapp [my app args]I cant think of an IRL example for this, but I have seen it a few times.My own example: https://github.com/cameroncros/idevicerestore/tree/docker-container?tab=readme-ov-file#docker
Statically link it with Musl instead. Then you don’t have do deal with bullshit glibc issues.
For distribution I package my Rust programs as Pip packages using Maturin. Theoretically you can do the same with any language but I’ve only tried Rust.
Why on earth would I publish pure Rust programs on PyPI you ask? I stole the idea from CMake, which is distributed there too despite being completely C++. The main advantage is that your users probably already have Pip installed no matter what distro they are using. Maybe even on Mac too. And installation is a single command. No fannying around adding custom repos and keys, making 5 different kinds of packages, etc.
Flatpak seems to be the way most people are doing it now.
Prior to that, it was mostly just packaging an npm and/or deb file and telling anyone not on a redhat/debian system to build it themselves.
Flatpak is for GUI applications. For CLI tooling the distro package managers are still the way to go.
