Add ARM-compatible image handling

Author: lemon07r

.github/workflows/docker.yml

@@ -5,6 +5,7 @@ on:
     branches: [main]
     paths:
       - 'containers/**'
+      - '.github/workflows/docker.yml'
   workflow_dispatch:
 
 env:
@@ -30,11 +31,26 @@ jobs:
           - dockerfile: containers/Dockerfile-ts
             image: sanity-ts
             tag: latest
+          - dockerfile: containers/Dockerfile-kotlin
+            image: sanity-kotlin
+            tag: latest
+          - dockerfile: containers/Dockerfile-dart
+            image: sanity-dart
+            tag: latest
+          - dockerfile: containers/Dockerfile-zig
+            image: sanity-zig
+            tag: latest
 
     steps:
       - name: Checkout repository
         uses: actions/checkout@v6
 
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
       - name: Log in to Container Registry
         uses: docker/login-action@v3
         with:
@@ -53,6 +69,7 @@ jobs:
         with:
           context: .
           file: ${{ matrix.dockerfile }}
+          platforms: linux/amd64,linux/arm64
           push: true
           tags: |
             ${{ env.REGISTRY }}/${{ github.repository_owner }}/${{ matrix.image }}:${{ matrix.tag }}

containers/Dockerfile-zig

@@ -1,11 +1,18 @@
 FROM alpine:3.19
 
+ARG TARGETARCH
+
 # Install Zig 0.13.0
 RUN apk add --no-cache wget xz && \
-    wget -q https://ziglang.org/download/0.13.0/zig-linux-x86_64-0.13.0.tar.xz -O /tmp/zig.tar.xz && \
+    case "${TARGETARCH}" in \
+      amd64) ZIG_ARCH="x86_64" ;; \
+      arm64) ZIG_ARCH="aarch64" ;; \
+      *) echo "unsupported TARGETARCH: ${TARGETARCH}" >&2; exit 1 ;; \
+    esac && \
+    wget -q "https://ziglang.org/download/0.13.0/zig-linux-${ZIG_ARCH}-0.13.0.tar.xz" -O /tmp/zig.tar.xz && \
     tar -xf /tmp/zig.tar.xz -C /opt && \
     rm /tmp/zig.tar.xz && \
-    ln -s /opt/zig-linux-x86_64-0.13.0/zig /usr/local/bin/zig
+    ln -s "/opt/zig-linux-${ZIG_ARCH}-0.13.0/zig" /usr/local/bin/zig
 
 # Configure Zig cache location
 ENV ZIG_GLOBAL_CACHE_DIR=/tmp/.zig-cache

docs/ROAD-TO-V2-Overhaul.md

@@ -88,6 +88,18 @@ Multi-run directories use a `multi-run.json` config and `multi-run-state.json` f
 
 Phase 5 (parallel runs with `--parallel-runs`) is deferred to a future release.
 
+## What changed in v1.8.0-alpha.3 — ARM readiness
+
+This pre-release focuses on making the harness reliable on `arm64` hosts while keeping behavior explicit when image architecture is mismatched.
+
+- **Early image platform validation in the runner.** `EnsureImage` now inspects the local/pulled image platform and fails fast with a clear error if the image does not match the host architecture, instead of failing later at container create/run time.
+- **Zig container is now architecture-aware.** The Zig Dockerfile now selects the correct upstream tarball for `amd64` (`x86_64`) and `arm64` (`aarch64`) builds.
+- **Docker image publishing now includes both Linux architectures.** The Docker workflow now builds and pushes `linux/amd64` and `linux/arm64` images for all six runtime images (`go`, `rust`, `typescript`, `kotlin`, `dart`, `zig`) using Buildx + QEMU.
+
+Operationally, this means ARM users get deterministic behavior:
+- either a matching image runs normally,
+- or the harness exits with an actionable platform mismatch message telling you to publish/build the needed architecture or override image config.
+
 ## Compatibility and comparing old runs
 
 `1.7.x` is intentionally not identical to `v1.6.1` behavior. If you are comparing against historical leaderboard-era runs, use legacy mode:

internal/runner/docker.go

@@ -110,14 +110,67 @@ func (d *DockerClient) EnsureImage(ctx context.Context, imageName string, autoPu
 	}
 
 	if exists {
-		return nil
+		compatible, localPlatform, err := d.imageMatchesHostPlatform(ctx, imageName)
+		if err != nil {
+			return err
+		}
+		if compatible {
+			return nil
+		}
+
+		if !autoPull {
+			return fmt.Errorf(
+				"image %s is %s but host platform is %s and auto-pull is disabled",
+				imageName,
+				localPlatform,
+				hostPlatformString(),
+			)
+		}
+
+		if err := d.PullImage(ctx, imageName); err != nil {
+			return err
+		}
+
+		compatible, localPlatform, err = d.imageMatchesHostPlatform(ctx, imageName)
+		if err != nil {
+			return err
+		}
+		if compatible {
+			return nil
+		}
+
+		return fmt.Errorf(
+			"image %s is %s but host platform is %s; build or publish a %s image, or override this image in config",
+			imageName,
+			localPlatform,
+			hostPlatformString(),
+			hostPlatformString(),
+		)
 	}
 
 	if !autoPull {
 		return fmt.Errorf("image %s not found locally and auto-pull is disabled", imageName)
 	}
 
-	return d.PullImage(ctx, imageName)
+	if err := d.PullImage(ctx, imageName); err != nil {
+		return err
+	}
+
+	compatible, localPlatform, err := d.imageMatchesHostPlatform(ctx, imageName)
+	if err != nil {
+		return err
+	}
+	if compatible {
+		return nil
+	}
+
+	return fmt.Errorf(
+		"image %s resolved to %s but host platform is %s; build or publish a %s image, or override this image in config",
+		imageName,
+		localPlatform,
+		hostPlatformString(),
+		hostPlatformString(),
+	)
 }
 
 // ContainerConfig holds configuration for creating a container.
@@ -314,3 +367,23 @@ func hostPlatform() *ocispec.Platform {
 func hostPlatformString() string {
 	return "linux/" + runtime.GOARCH
 }
+
+func (d *DockerClient) imageMatchesHostPlatform(ctx context.Context, imageName string) (bool, string, error) {
+	inspect, err := d.client.ImageInspect(ctx, imageName)
+	if err != nil {
+		return false, "", fmt.Errorf("inspecting image %s: %w", imageName, err)
+	}
+
+	localPlatform := platformString(inspect.Os, inspect.Architecture)
+	return localPlatform == hostPlatformString(), localPlatform, nil
+}
+
+func platformString(osName, arch string) string {
+	if osName == "" {
+		osName = "unknown"
+	}
+	if arch == "" {
+		arch = "unknown"
+	}
+	return osName + "/" + arch
+}

internal/runner/docker_test.go

@@ -0,0 +1,64 @@
+package runner
+
+import (
+	"runtime"
+	"testing"
+)
+
+func TestPlatformString(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		os   string
+		arch string
+		want string
+	}{
+		{
+			name: "full platform",
+			os:   "linux",
+			arch: "arm64",
+			want: "linux/arm64",
+		},
+		{
+			name: "missing os",
+			os:   "",
+			arch: "amd64",
+			want: "unknown/amd64",
+		},
+		{
+			name: "missing arch",
+			os:   "linux",
+			arch: "",
+			want: "linux/unknown",
+		},
+		{
+			name: "missing os and arch",
+			os:   "",
+			arch: "",
+			want: "unknown/unknown",
+		},
+	}
+
+	for _, tc := range tests {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			got := platformString(tc.os, tc.arch)
+			if got != tc.want {
+				t.Fatalf("platformString(%q, %q) = %q, want %q", tc.os, tc.arch, got, tc.want)
+			}
+		})
+	}
+}
+
+func TestHostPlatformString(t *testing.T) {
+	t.Parallel()
+
+	want := "linux/" + runtime.GOARCH
+	got := hostPlatformString()
+	if got != want {
+		t.Fatalf("hostPlatformString() = %q, want %q", got, want)
+	}
+}