Software management

This page documents various ways to run software compiled with glibc and to manage software using graphical software managers in Alpine Linux. There are pages elsewhere regarding compiling software from source and for creating a custom kernel.

Alpine package keeper

Main article: Alpine Package Keeper

The official package manager in Alpine Linux, Alpine Package Keeper(apk), is a cli tool. Rosetta stone shows how standard package management tasks are done in Alpine Linux compared to other popular distributions.

Graphical software manager

The following graphical tools are available to manage official software packages from Alpine Linux repositories and flatpaks instead of using the cli-based apk tool.

GNOME software

GNOME software can be used as a GUI front end for apk to manage official software packages and flatpaks.

KDE Discover

KDE Discover can be used as a GUI front end for apk to manage official software packages and flatpaks.

Flatpak

Main article: Flatpak

Flatpaks are by far the easiest method for running programs that are not available in the official Alpine Linux repositories. To use flatpaks, ensure that the Flathub repository is enabled.

AppImage

Main article: AppImage

AppImages are another alternative to flatpaks for running programs that are not available in the official Alpine Linux repositories. However, not as many AppImages work on Alpine Linux as compared to Flatpaks, since AppImages are more commonly built for glibc operating systems, as opposed to Alpine Linux's use of musl. Refer to the AppImage page for prerequisites and for detailed instructions to run AppImages in Alpine Linux.

Coldbrew

Coldbrew is a package manager that can install Alpine Linux aports Edge packages without needing root access, somewhat similar to brew. This is particularly useful on immutable operating systems such as with PostmarketOS's duranium image. Coldbrew is available in Alpine Linux Edge testing repository as of January 2026; the testing repository is recommended to be tagged if installing coldbrew on any supported Alpine Linux release.

Coldbrew replaces the iced package on Alpine Linux, which used the mkosi-sandbox; packages run inside a chroot using bubblewrap instead. They have access to the home directory, but have only controlled access to all other files through explicit bind mounts. Packages installed using coldbrew are referred to as tools. See further details upstream.

To install coldbrew:

$ doas apk add coldbrew@testing

To install a tool to be run by coldbrew, say, corepad:

$ coldbrew install corepad

Note that even though the output ends...

Installed binary /usr/bin/corepad

...the path being referred to exists within a new mount namespace using bind mounts in the bubblewrap sandbox.

A wrapper program is installed to ~/.local/bin on Alpine Linux.

To run the tool under coldbrew:

$ coldbrew run corepad

To remove the tool:

$ coldbrew remove corepad

All installed tools can be listed through the $ coldbrew ls command.

Running glibc programs

If you want to run glibc programs in Alpine Linux, there are a few ways of doing so.

For simpler binaries, you can install gcompat, which is a compatibility layer; or you could do it the easy way and use Flatpaks or AppImages. See containers or the chroot section for ways to run glibc programs, including graphical ones such as VSCode, google-chrome, obsidian, etc.

gcompat

gcompat is a library that provides glibc-compatible APIs for use on musl libc systems such as Alpine Linux. To install, issue the command:

$ doas apk add gcompat

After that, you run your binaries as normally.

For an usage example, refer to the Firefox page where gcompat is used to run the glibc-compiled Widevine binary.

Chroot

Main article: Chroot

Glibc applications can be run by installing a glibc-based distribution in a chroot inside the Alpine Linux.

Instructions for setting up chroot for following popular glibc distributions are available:

• Gentoo Linux
• Arch Linux
• Debian

For updating the chroot, or for installing packages and their dependencies using package manager like apt-get, enter the chroot as root.

The following instructions are for a Debian chroot in /var/chroots/debian, on x86_64, but can be adapted to other systems by using the appropriate paths.

$ doas mount --bind /dev /var/chroots/debian/dev $ doas mount --bind /proc /var/chroots/debian/proc $ doas mount --bind /dev/pts /var/chroots/debian/dev/pts $ doas chroot /var/chroots/debian /bin/bash [chroot]# apt update && apt upgrade

After installing the necessary applications and whatever else you might do, exit the chroot:

[chroot]# exit

Then, unmount the binds for /dev/pts, dev and proc to avoid issues:

$ doas umount /var/chroots/debian/dev/pts $ doas umount /var/chroots/debian/dev $ doas umount /var/chroots/debian/proc

Tip: The most reliable way to enter and exit a chroot is to use the start-chroot script, where the script takes care of all mounting and unmounting.

Once a chroot is ready, there are at least a couple of ways to run glibc applications.

• Using the glibc dynamic linker
• Bubblewrap + Chroot

Using the glibc dynamic linker

Todo: Please test and confirm if the below instructions are complete or requires modification.

The glibc dynamic linker can be configured in Alpine as follows. These instructions are for a Debian chroot in /var/chroots/debian, on x86_64, but can be adapted to other systems by using the appropriate paths.

# mkdir -p /lib64 # ln -s /var/chroots/debian/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 /lib64 # printf '/var/chroots/debian/lib/x86_64-linux-gnu\n/var/chroots/debian/usr/lib/x86_64-linux-gnu\n' > /etc/ld.so.conf # /var/chroots/debian/sbin/ldconfig

Gentoo Linux

Select a stage3 from here and the portage latest from here at gentoo/snapshots/portage-latest.tar.xz.

First,

$ doas apk add xz

Enter the chroot:

$ mkdir ~/chroot $ cd ~/chroot $ doas tar -xvf stage3-*.tar.xz $ doas tar -xvf portage-latest.tar.xz $ doas mv portage usr $ doas mount --bind /dev dev $ doas mount --bind /sys sys $ doas mount -t proc proc proc $ doas cp /etc/resolv.conf etc $ doas chroot . /bin/bash

And voilà, you have your working Gentoo chroot!

You can now take a look at Gentoo's Handbook to find out how you can configure and install your system, or simply extract/copy the program that you need to run in your chroot environment, and then execute it.

Here is a wrapper script that is similar to arch-chroot when you frequently reuse this chroot. Also, create an account with the same username as host current user to the chroot, or make changes to the userspec option to chroot line:

Contents of gentoo-chroot.sh

#!/bin/bash CHROOT_PATH="/home/$USER/chroot" cd $CHROOT_PATH mount | grep $CHROOT_PATH/dev || doas mount --bind /dev dev mount | grep $CHROOT_PATH/sys || doas mount --bind /sys sys mount | grep $CHROOT_PATH/proc || doas mount -t proc proc proc doas cp /etc/resolv.conf etc doas chroot --userspec=$USER:users . /bin/bash echo "You must manually unmount $CHROOT_PATH/dev, $CHROOT_PATH/sys, $CHROOT_PATH/proc."

Do $ chmod +x gentoo-chroot.sh to make it executable.

Arch Linux

See also: Installing ArchLinux inside an Alpine chroot

Either use pacstrap (included with the arch-install-scripts package) or an Arch bootstrap image:

$ doas apk add arch-install-scripts $ mkdir ~/chroot && cd ~/chroot $ curl -O https://mirrors.edge.kernel.org/archlinux/iso/latest/archlinux-bootstrap-x86_64.tar.zst $ doas tar -x --zstd -f archlinux-bootstrap-x86_64.tar.zst && rm archlinux-bootstrap-x86_64.tar.zst $ doas sed -i '/evowise/s/^#//' root.x86_64/etc/pacman.d/mirrorlist $ doas sed -i '/CheckSpace/s/^/#/' root.x86_64/etc/pacman.conf $ doas arch-chroot root.x86_64 [chroot]# pacman-key --init [chroot]# pacman-key --populate archlinux

Once that is done, update the system and install the desired package(s) (denoted by "foo" in this example):

[chroot]# pacman -Syu foo

Debian

Alpine Linux provides the debootstrap package to create the Debian chroot. Here are the steps:

$ doas apk add debootstrap $ doas mkdir -p /var/chroots/debian $ doas debootstrap --arch amd64 stable /var/chroots/debian/ https://deb.debian.org/debian

The --arch is optional, depending on your needs. Instructions for entering and exiting the Debian chroot are given in the Chroot section above.

Containers

Distrobox + Podman

Distrobox, combined with podman container running in rootless mode, allows to easily run glibc-compiled graphical programs. This will not require root privileges once set up.

Bubblewrap + Chroot

Shell aliases are used to create a container with Bubblewrap with Chroot as its content. Once the graphical glibc packages are installed inside the chroot, this allows for running them without requiring root privileges using bwrap.

• Install the bubblewrap package.
• Follow the instructions to set up a Chroot. For eg. Debian chroot.
• Install necessary glibc applications inside the chroot as root either using package manager like apt-get or otherwise.
• Create alias glibc and/or glibcX11 using bwrap in the Alpine Linux host as regular user.

$ alias glibc="LANG=en_US.UTF-8 bwrap --bind /var/chroots/debian / --dev-bind /dev /dev --proc /proc --bind /sys /sys --bind /run /run --bind /home /home --ro-bind /etc/resolv.conf /etc/resolv.conf --ro-bind /etc/passwd /etc/passwd --ro-bind /etc/group /etc/group"

$ alias glibcX11="LANG=en_US.UTF-8 bwrap --bind /var/chroots/debian / --dev-bind /dev /dev --proc /proc --bind /sys /sys --bind /run /run --bind /home /home --ro-bind /etc/resolv.conf /etc/resolv.conf --ro-bind /etc/passwd /etc/passwd --ro-bind /etc/group /etc/group --bind /tmp/.X11-unix/X0 /tmp/.X11-unix/X0 --setenv DISPLAY :0"

To run programs that use X11/Xorg, you might need to use xhost on the Alpine Linux host in order to allow local connections. For example:

$ doas xhost + local:

Now we can invoke any glibc_binary from the chroot using the above alias from the Alpine Linux host, as follows:

$ glibc glibc_binary

or

$ glibcX11 glibc_binary

When a Wayland desktop such as Sway runs without XWayland on the Alpine Linux host, Electron apps need to be started with certain flags. These flags enforce Wayland rendering.

• For VS Code:

glibc code --enable-features=UseOzonePlatform --ozone-platform=wayland

• For Google Chrome:

glibc google-chrome --enable-features=UseOzonePlatform --ozone-platform=wayland

Tip: The Bubblewrap aliases are sufficient only for running applications. To install, remove, or update software within the chroot, follow the steps described in the Chroot section.

See also

• Alpine Package Keeper
• Installing ArchLinux inside an Alpine chroot
• Compile software from source
• Kernels