GitHub Actions ARM32 Retirement Guide for ARMv7 CI
Identify native ARM32 steps on GitHub-hosted runners and keep Linux ARMv7 builds, artifact checks, and target execution separate.

A CI job can run on a 64-bit host, produce a Linux ARMv7 binary, and upload it without ever starting that binary. Another job can use the same host and fail because one test starts an ARM32 executable. Keeping those jobs distinct is the first step in deciding what to change.
On November 12, 2026, GitHub announced the end of ARM32 job execution support on GitHub-hosted Linux and Windows runners by December 8, 2026. GitHub explicitly includes native AArch32 user-space execution in that scope. The Linux examples here address teams that still ship ARMv7 binaries or containers. GitHub retirement announcement
Trace what runs at each step
Start with the workflow matrix, then follow each job into scripts, container definitions, and custom actions. A label containing arm is a starting point. The commands determine the execution architecture.
| Step | Evidence to capture | Migration decision |
|---|---|---|
| Runner starts the job | Hosted runner label and actual host architecture | Choose a supported host and keep its architecture in the log. |
| Compiler emits an artifact | Compiler target and binary header or OCI platform | Use a compiler or builder that supports the target. |
| A test starts the artifact | Test command and target execution environment | Use explicit emulation or a suitable dedicated target where supported. |
| An action starts a helper | The helper’s target and runtime requirements | Update or replace the helper if it needs native AArch32 execution. |
Inspect any step that installs a native dependency, runs a built binary, or uses a container build stage with a target-platform RUN instruction. Those are places where a pipeline that looks like packaging can also require target execution.
Check the artifact before you test it
This Go example makes a small Linux ARMv7 executable from a program with no C dependency. Run it from a clean directory with Go and file installed.
cat > hello.go <<'GO'
package main
import "fmt"
func main() {
fmt.Println("hello from the smoke test")
}
GO
CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=7 go build -o hello-linux-armv7 hello.go
file hello-linux-armv7
A local run on ARM64 macOS produced an ELF 32-bit LSB executable, ARM, EABI5 file. GOARM=7 selects the target, while file inspects the resulting file family and machine type. Record both. Use a runtime test to check that the binary actually starts, produces the expected output, and does the work that matters to your release. The local run checked the build and file header. If your code uses cgo, native libraries, or architecture-specific instructions, account for the target toolchain and test on hardware when you depend on its behavior. Go command environment reference
For OCI images, verify that the published manifest includes linux/arm/v7 and run a smoke test for that platform. Docker documents QEMU, native builder nodes, and cross-compilation as distinct strategies. Pick one based on which build steps start target binaries, test its actual support on your chosen runner, and record whether the runtime test used emulation or a target device. Docker multi-platform build strategies
When revising the workflow, keep the old ARMv7 release criterion explicit. A passing pipeline should tell a maintainer where the build ran, which platform was published, and where the artifact was executed successfully. LabEx Dockerfile practice is a useful prerequisite for separating the build stage from the final image.
References
- GitHub Actions retirement notice gives the date and scope.
- Go command environment defines the target variables.
- Docker multi-platform build strategies explains emulated, native, and cross-compiled builds.