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.

AppImage

Main article: AppImage

AppImages are by far the easiest method for running programs that are not available in the official Alpine Linux repositories. Refer to the AppImage page for prerequisites and for detailed instructions to run them in Alpine Linux.

Flatpak

Main article: Flatpak

Flatpak is an alternative to AppImages for running programs that are not available in the official Alpine Linux repositories. To use flatpaks, ensure that the Flathub repository is enabled.

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

An option that is easier to generalize to other glibc applications is to install a glibc-based distribution into a chroot. You can then either chroot into it, or use a symlink and some configuration to make its glibc (and associated libraries) usable from Alpine.

Tip: The most reliable way to enter a chroot is to use the start-chroot script.

After setting up a chroot using any of the methods described below, the loader can be set up 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):

$ doas mkdir -p /lib64 $ doas ln -s /var/chroots/debian/lib/x86_64-linux-gnu/ld-2.33.so /lib64 $ doas printf '/var/chroots/debian/lib/x86_64-linux-gnu\n/var/chroots/debian/usr/lib/x86_64-linux-gnu\n' > /etc/ld.so.conf $ doas /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:

$ doas mkdir ~/chroot $ doas 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 enviroment, 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 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.

For updating the chroot, or for installing packages and their dependencies using apt-get, mount it, and then login as root:

$ 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

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

glibc and glibcX11 shell aliases are defined interactively using bwrap to create a container with Bubblewrap, using a Debian chroot as its content. It's not just a chroot anymore: it's a bubblewrap-powered isolated environment. This allows for easily running graphical programs and does not require root privileges once installed.

Install the bubblewrap package.

Set up Debian chroot at /var/chroots/debian and install necessary glibc applications using apt-get.

Create a glibc alias using bwrap in the Alpine Linux host in order to start applications from the Debian chroot:

$ 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"

To run programs that use X11/Xorg, you can use:

$ 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"

In this case, you might need to use xhost on the Alpine Linux host in order to allow local connections. For example:

# xhost + local:

Now we can invoke glibc-built binaries using the alias from the Alpine Linux host, as follows:

$ glibc ./binary

or

$ glibcX11 ./binary

When a Wayland desktop such as Sway runs without XWayland on the Alpine Linux host, Electron apps need to be started with Ozone Wayland support:

• For VS Code (note the use of the code command):

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

• For Google Chrome, etc:

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

The flags enforce Wayland rendering, thus avoiding XWayland and improving display, particularly if fractional scaling is also used.

See also

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