Valve, alongside Collabora, has released Holo Core, a proof-of-concept aarch64 port of Arch Linux designed to power its upcoming Steam Frame handheld. Since Arch Linux lacks official aarch64 support, the team built custom CI tooling that replays the distribution's build history to resolve complex dependency chains and rolling-release hurdles from scratch. This engineering effort enables a native operating system foundation for the Frame's ARM64 silicon while tackling critical challenges like SONAME transitions and source availability decay over time. Collabora has made sources, binary packages, and build containers available for preview, with plans to collaborate on bringing official aarch64 support to upstream Arch Linux.

Valve and Collabora Release Holo Core, an aarch64 Port of Arch Linux for Steam Frame

Valve needs Arch Linux to run on ARM64. It's a simple requirement for its upcoming Steam Frame handheld, but it's a problem because Arch Linux doesn't officially support aarch64 as a primary architecture yet. Collabora stepped in and built a custom proof-of-concept called Holo Core to bridge that gap, enabling a native OS foundation for the new device.

Valve's SteamOS is already an adaptation of Arch Linux for x86_64, leveraging the rolling-release model and simplicity that Arch is known for. The Steam Frame flips the script on the Steam Deck's silicon, sporting an aarch64 CPU instead. You can't just grab the existing SteamOS ISO and install it on ARM. The company needed a viable path to port Arch's tooling and package infrastructure to the new architecture, and that's where Holo Core comes in.

The Build Replay Trick

Collabora didn't just cross-compile a few packages and call it a day. Holo Core introduces a "build replay" system designed to construct a reproducible aarch64 environment from scratch. Instead of relying on a static bootstrap, the tooling calculates the complete dependency tree and replays Arch Linux's build history up to a target snapshot.

Keep in mind that Arch is a rolling-release distribution. Rebuilding a package like rust 1.91 requires rust 1.90, which needs 1.89, cascading all the way back to the initial bootstrap version. You can't skip steps. The CI infrastructure resolves these chains, fixes build ordering issues that Arch's state repo sometimes gets wrong, and manages the chaos of package evolution.

However, at the same time, the project tackles the "time decay" problem. Replaying builds from months ago means dealing with upstream URLs that have moved, projects that migrated hosting services, and checksums that broke when Git short hashes expanded to longer forms. Infrastructure changes and rate-limiting pop up out of nowhere. Replaying a build from months ago often means wrestling with a broken internet. It's a game of whack-a-mole.

On top of that, there's the SONAME transition headache. The build-time dependency might require an old library version, while the output needs the new one. Both versions have to exist simultaneously during the build. The custom tooling resolves these chicken-and-egg problems dynamically, a feat that's significantly more complex than porting a static distribution.

The initial goal is a subset of packages required for development and image creation on the Steam Frame, though the custom tooling aims to support the full rolling release eventually. Reproducible from scratch? Sure. Fast? No.

Artifacts and Reality

Collabora and Valve have released artifacts for the preview. You'll find the PKGBUILDs and patches on GitLab, along with pre-built binary packages from the mash-20251118 snapshot. There's also a Docker container for the build environment. Head here to the GitLab repo to check out the sources and dive into the tooling.

For what it's worth, Holo Core is a proof-of-concept. If you're expecting to run your daily driver on it today, you'll be disappointed. The repository contains the tooling necessary to build the packages, but the scope is focused on enabling development for the Steam Frame.

If you need to experiment, you can build on a native aarch64 host or use QEMU emulation on x86_64 via Distrobox. The emulation path requires some manual tweaks to fix a sudo SUID issue via binfmt.d, and it's not a simple copy-paste job. If you need to build on x86_64, the QEMU setup demands care. Every aarch64 binary runs through user-space emulation, so builds will be painfully slow. You can't escape the penalty.

The research behind Holo Core suggests this port is feasible, even if it requires heavy lifting. Collabora is already working with upstream Arch Linux to bring aarch64 support officially. The company plans to open-source the tooling, which could benefit anyone else trying to port rolling-release distributions or tackle reproducible builds.

Ultimately, Holo Core paves the way for native aarch64 support on Steam Frame and potentially future SteamOS versions. It also proves that a custom Arch Linux port isn't science fiction. It's just a lot of CI configuration and dependency management. You can grab the preview artifacts and see what it takes to make Arch Linux run on ARM64.

Head here for the announcment.