TL;DR: the container image every overpressure build runs
in: the userspace, the system image, Valve's kernel (overpressure/linux)
and packages. Published as ghcr.io/overpressure/builder for amd64 and arm64. Consumers pin it by digest, and
that pin is what makes a build's tools the same on every computer and in a year.
Ubuntu 24.04 (the base pinned by digest) with every tool of the builds:
- the kernel's toolchain:
gcc-aarch64-linux-gnu(on amd64; on arm64 the nativegcc), binutils,pahole(dwarves),device-tree-compiler,flex,bison,bc,libssl-dev,libelf-dev, andccache, which keeps compiled objects between a kernel's check builds (a release builds without it); - LLVM 20's
clang-20andlld-20, which compile natively inside the userspace build's aarch64 root; qemu-user-static, whoseqemu-aarch64-staticruns that root's programs on an x86-64 host;python3,git,make,e2fsprogs,util-linux,zstd,xz-utils,cpio,curl,shellcheck.
The packages come from Ubuntu's archive as it was when the image was built. Every installed package and
version is in /usr/share/overpressure-packages.txt and attached to the image's release.
Pin the image with its tag and digest, as each release names it:
ghcr.io/overpressure/builder:2026.11.12@sha256:<digest>
The digest names a multi-arch index; the engine takes the variant of its host. Reproducible kernel releases are built with the amd64 variant only: on arm64 the compiler is the native one, which gives other bytes.
What the consumers rely on: overpressure's tooling (IMAGE in
overpressure/linux.py) and the
packages' CI (BUILDER in overpressure/packages'
packages.yml). A change to it
is a new image that the consumers pin on purpose.
- How it runs. Privileged (
--privileged): the builds mount/proc,/sysand overlayfs and chroot. The checkout is bound at/work, the working directory; build roots live in a volume at/var/tmp. - The entrypoint,
/usr/local/bin/overpressure-entrypoint, then runs the command:- it mounts the host kernel's
binfmt_miscat/proc/sys/fs/binfmt_miscwhen it is not there; - with
OVERPRESSURE_BINFMT=1(a build) it runsoverpressure-binfmt; - with
OVERPRESSURE_UIDandOVERPRESSURE_GID(a Linux host's user, not 0) on a rootful engine, what root created or changed under/workduring the command goes back to that user (overpressure-hand-back), whatever the command's exit status, which stays the container's.
- it mounts the host kernel's
overpressure-binfmt [--report]registers this image'sqemu-aarch64-staticas the host kernel's aarch64 handleroverpressure-aarch64with the flagsPOF, unless an enabled handler withFis there, or the host is arm64.--reportsays which.BINFMT_MISCandBINFMT_QEMUname other places, for tests.overpressure-hand-back DIR MARKER UID GIDgives UID:GID what root owns under DIR and created or changed after MARKER was made, on DIR's own file system, links themselves; nothing else.- git trusts every directory (
safe.directory *): the checkout is the host user's, git here runs as root.
Every pull request, push to main and tag checks both variants' tools and runs the scripts' tests in them
(image.yml). Each variant is built once per content of image/ and kept as
ghcr.io/overpressure/builder:ci-<tree>-<arch>; later runs pull it instead of building it again. A tag
YYYY.MM.DD (or YYYY.MM.DD.N) publishes the tested variants as one multi-arch image under that tag, with a
release that names its digest and lists each variant's packages; its notes list the commits to image/ and
each variant's packages added, removed or at another version since the previous release. main changes only
by pull request; the run's last job, ci, passes only when the lint and both variants passed, and is the
check main requires. Published images are kept: an old pin keeps working.
The ci-* tags in ghcr.io/overpressure/builder are CI's cache of tested variants: never pin them. A release is
an exact pin by digest, so there are no channels.
python3 -m unittest -v # the recipe test; the binfmt tests need bash on x86-64 Linux, the hand-back tests root
uvx [email protected] format --check . && uvx [email protected] check . # the Python code (pyproject.toml)
docker run --rm -i hadolint/hadolint:v2.15.1 hadolint --ignore DL3008 - < image/Dockerfile # the Dockerfile
docker build -t builder:local imageThe Unlicense: the Dockerfile and the scripts. The image itself contains Ubuntu 24.04's packages,
unmodified, each under its own licenses (many GPL or LGPL), stated in the image's
/usr/share/doc/PACKAGE/copyright. Their sources are Ubuntu's: each release's packages-ARCH.txt (in the
image /usr/share/overpressure-packages.txt) lists every package with its version and architecture, and from
the release after 2026.11.12 on also its source package and source version (2026.11.12's lists carry name,
version and architecture only). Every published version of a source package, with its .dsc, upstream and
Debian archives, is kept at https://launchpad.net/ubuntu/+source/SOURCE/VERSION (also by date on
snapshot.ubuntu.com). The image is a build tool for developers and CI; nothing of it goes onto a headset.