Linux Packaging

Package formats and managers

• Metadata: package name, version number (SemVer), author, dependencies, description, more.
• Files to install: usually a libSOMETHING.so (shared library) file or a binary executable file (e.g. /usr/bin/firefox), but there could be multiple binaries, plus config files, maybe source files, man page, etc.
• Scripts that do anything: usually tweak configuration files, but really could be large and do just about anything including interacting with the user.

• VMs and emulators. See "VMs and Containers" page.
• Bundles/containers (Snap, Flatpak, appimage, Docker). See "VMs and Containers" page.
• Language-specific module managers (node.js's npm, Ruby's gem, Python's pip, Go's get, Rust's cargo, Perl's cpan).
• App store managers (GNOME Software, Ubuntu Software, Snap Store, POP!_Shop, Discover, Muon).
• Web site "hubs": Flathub, Dockerhub, AppImageHub.

Package Manager Commands

apt search PATTERN
dnf search PATTERN
pacman --query --search PATTERN
pamac search -a PATTERN
nix-env -qaP PATTERN
eopkg search PATTERN
xbps-query -Rs PATTERN

apt show PKG
dnf info PKG
pacman --query --info PKG
pamac info -a PKG
eopkg info PKG
xbps-query --show PKG

apt install PKG
dnf install PKG
pacman --sync PKG
pamac install PKG
nix-env -iA
xbps-install PKG
rpm-ostree install PKG

apt list --installed
dpkg --get-selections
dnf list --installed
rpm -qa --qf "%{NAME}\n"
pamac list -i
pacman -Q
yay -Q
nix-env -q
eopkg list-installed
[xbps-query   no way to do it]

zypper se -si | grep i+

dnf repoquery --installed --whatrequires PKGX
xbps-query --revdeps PKGX

With deb/apt/dpkg packages:

ls -lt /var/lib/dpkg/info/*.list | less

zcat -f /var/log/dpkg.log* | grep -i PKGNAME | grep -E "\ install\ |\ upgrade\ "
# grab part of datetime from that, and do:
zcat -f /var/log/dpkg.log* | grep -i DATETIME | grep -E "\ install\ |\ upgrade\ "

cat /var/log/apt/history.log

sudo apt remove PKGNAME --simulate

apt-cache rdepends --installed --recurse PKGNAME

aptitude why PKGNAME --show-summary

On openSUSE: "zypper info PKGNAME" tells if manually or automatically installed.

Repositories

Edit /etc/dnf/dnf.conf to set:

max_parallel_downloads=20
fastest_mirror=true    # but some say this is a bad idea
install_weak_deps=true
deltarpm=true

Install RPMFusion free and non-free repositories (instructions), reboot, then

sudo dnf groupupdate sound-and-video
sudo dnf install -y libdvdcss	# FAILED
sudo dnf install -y gstreamer1-plugins-{bad-\*,good-\*,ugly-\*,base} gstreamer1-libav --exclude=gstreamer1-plugins-bad-free-devel ffmpeg gstreamer-ffmpeg
sudo dnf install -y lame\* --exclude=lame-devel
sudo dnf group upgrade --with-optional Multimedia
sudo dnf config-manager --set-enabled fedora-cisco-openh264
sudo dnf install -y gstreamer1-plugin-openh264 mozilla-openh264
# Then in Firefox, enable OpenH264 plugin from Cisco.

As needed for specific apps or projects, enable the copr repository for each.
"sudo dnf copr enable OWNER/REPO" and then "sudo dnf install APPNAME"
So a copr repository is like an Ubuntu PPA.

There also is RPM Sphere but I haven't tried anything from it.

export ZYPP_MEDIANETWORK=1
export ZYPP_SINGLE_RPMTRANS=1

# Debian family:
apt-add-repository --list
grep -v '#' /etc/apt/sources.list /etc/apt/sources.list.d/*

# Arch family:
less /etc/pacman.conf   # ???

# Red Hat family:
dnf repolist --enabled

# SUSE family:
zypper repos

# Flatpak:
flatpak remotes

# Snap:
# there is only one public store
# I don't know how to detect what store is being used

# Docker:
docker info | grep Registry     # ???

Declarative Managers

Nix is the language.
Nix is the package manager.
Nixpkgs is the specification (and repo) of the NixOS distro.
NixOS is the distro that results from Nixpkgs.
There is a command "nix-store".
There is a command "nix", with sub-commands build, run, develop, log, flake.
There are commands of form "nix-something".
There are "flakes", which are building blocks of some kind.
There are "channels".
Haskell for all's "Stop calling everything 'Nix'"

Nix can be used as the package manager on other distros ? You don't have to run NixOS to use Nix.
Ariya Hidayat's "Nix Package Manager on Ubuntu or Debian"
Chris Titus Tech's "Nix Package Manager"

From Jesse Smith's "NixOS 23.11":

... This idea that NixOS is immutable is false. The NixOS distribution has no immutable properties and we can write to any part of the root filesystem. ...

...

NixOS, using its snapshots and atomic updates, can offer some of the same benefits as some distributions which are immutable. However, NixOS does not use an immutable filesystem. It achieves its atomic update magic using other means.

Guix is or includes a modification of Nix ?

NixOS
NixOS Wiki

Zero to Nix
Fernando Ayats' "Into the Nix"
Henrik Lissner's "Frequently asked questions"
Fernando Borretti's "NixOS for the Impatient"
nixos.asia's "First steps with Nix"
Michael Lynch's "My First Impressions of Nix"
Cat Girl's "Eight Months of NixOS"
Karl Voit's "I Started With Nix, NixOS, Home Manager and Flakes"
Matt Rickard's "Why Is NixOS Popular Again?"
Mike Kelly's "Why do people love NixOS so much?"
Ramin Honary's "Nix OS, Guix OS, and declarative package management"
MyNixOS
Remy Grunblatt's "Nix and NixOS, my pain points"
Tinkering's "Nix journey part 0: Learning and reference materials"
Julia Evans' "Some notes on using nix"
Ryan Yin's "NixOS & Flakes Book"


Looks like installing NixOS is pretty standard, and then you can install Flatpak applications. But system configuration changes are done by editing /etc/nixos/configuration.nix and then doing "nixos-rebuild switch". Package installation: "nix-env -iA PKGNAME", where PKGNAME might be of form "nixos.SOMENAME". Search for package: "nix-env -qaP PATTERN" or look at search.nixos.org.



From Cat Girl's "Eight Months of NixOS":

Nix does not follow the standard Linux filesystem hierarchy; it stores almost all of its libraries and binaries under /nix/store. This means that you can have multiple copies of something installed without them interfering with each other, but it also means that you need to know how Nix packaging works to compile anything. Even libc isn't in its usual place, so downloading prebuilt binaries usually won't work.

From someone on reddit 10/2022:

I've been driving it a few months now, been gradually rolling it out to my other devices. It's very interesting, and I've been absolutely loving the declarative configuration, but the learning curve is very high, since all the configuration is done using its own bespoke syntax. The installer will get you up and running with a basic configuration that has Xorg, a desktop environment of your choice, and some preinstalled system packages, but everything else, you're going to have to configure in some way - bluetooth, wireless, and probably a million little packages that are normally installed by default on Ubuntu and Mint.

Once it's configured, though, you can back up the /etc/nixos folder somewhere, and never worry about getting it working again, at least in my short experience, where I've re-installed the base OS a few times, or on different computers. The NixOS manual or wiki often has the snippets of configuration you need right there. You can use Nix as a more 'normal' package manager with nix-env, but I like having it all down in a single place in a comprehensible way. It's also nice to be able to split that config into individual component files - I have my 'base system' configuration file, my general GUI configuration is in another, a bluetooth configuration in another, etc.

What I'm talking about is just my experience using the basic, stable featureset of configuration - I haven't even begun to touch flakes at all, which many people tout as being one of the more powerful features of NixOS, or home-manager. There's a lot there you can sink your teeth into, if you want or need it, but I've been pretty content with the basics.

From someone on reddit:

Imho, it isn't exactly an immutable distro. Yes, the system is read-only, but you can tweak your config file and update your system in a matter of seconds. That sets it apart from something such as Fedora Silverblue, where updating your system can take quite some time.

In general, this means NixOS is great for tinkering. You can tweak an option, try it out, and change back if you don't like the results, all in a minute. There's essentially no risk. And small tweaks can lead to big results. You could switch to a new desktop environment / wm with the same degree of ease.

Compiling From Source

# Get the source code:
git clone https://a-repo/foo.git
# Or download a TAR or ZIP file and then do one of:
tar -xzvf foo.tar.gz
tar -xjvf foo.tar.bz
tar -xjvf foo.tar.bz2
unzip foo.zip

# You may need to install tools and dependencies:
sudo apt install build-essential
sudo pacman -S base-devel
sudo pamac install base-devel
sudo zypper install -t pattern devel_C_C++
sudo yum groupinstall "Development Tools"
sudo dnf groupinstall "Development Tools"   # or:
sudo dnf install @development clang

# Configure:
cd foo/
# If there is an Autogen file:
./autogen.sh
# Check for dependencies and configure the makefile:
./configure --prefix=/opt/foo
# Or if there is a CMakeList.txt file, maybe:
cmake . -DCMAKE_BUILD_TYPE=Release {some options ...}

# Build and install:
make
make test    # maybe
sudo make install

# Launch the app from CLI:
/opt/foo/foo

# Maybe create a foo.desktop file, in
# /usr/share/applications or $HOME/.local/share/applications,
# that points to executable file /opt/foo/foo
# Then you'll be able to launch foo from the desktop GUI.

# Later, remove it:
sudo make uninstall
make clean

Distribution (Distro)

• A Linux kernel.

• A bootloader.
• An init system.
• Core utilities.

• A graphic stack (X or Wayland).
• A display manager (for logging in).
• A window manager.

• A desktop shell (e.g. plasma).
• Default applications.
• System utilities (settings, network manager, etc).

Miscellaneous