CI/CD Migration to arm64

Cut CI costs by moving to arm64 runners. Your blueprint works on both architectures: no changes needed.

The Pain

x86_64 CI runners cost more than arm64 equivalents for the same workload
Migrating CI to arm64 means untangling x86-only scripts, Docker images, and toolchain installs
No guarantee the existing blueprint or environment works on a different host architecture
Running parallel x86 and arm64 pipelines during migration doubles CI costs temporarily

What alloy-it Changes

alloy-provisioner is a native arm64 binary: same install command, no changes needed
The same blueprint provisions identically on x86_64 and arm64 CI runners
Architecture-aware tool layers in blueprints handle platform-specific binaries automatically
Idempotent provisioning makes it safe to run parallel x86/arm64 jobs during validation

The Outcome

20 to 40% lower CI compute costs on arm64 cloud runners (AWS Graviton, GitHub arm64)
One blueprint for local dev, x86 CI, and arm64 CI; no divergence
Same cross-compilation target: host architecture change is invisible to your firmware
Full migration in hours, not weeks

How it works

arm64 cloud runners (AWS Graviton, GitHub-hosted arm64, self-hosted Ampere or Apple Silicon machines) deliver 20 to 40% better price/performance than equivalent x86_64 instances. For embedded teams running continuous firmware builds, that margin compounds fast.

The catch is that most CI environments were built for x86 and rely on ad-hoc install scripts, x86-only Docker base images, or toolchain steps that silently break on a different host architecture.

With Alloy, there is nothing to untangle. alloy-provisioner is a native arm64 binary. Its install script detects the host architecture and selects the correct binary automatically. Your blueprint does not change: architecture-aware layers in the catalog handle platform-specific tool variants. The same alloy-provisioner install command works on your x86 runner today and your arm64 runner tomorrow.

Cross-compilation targets are unaffected. The host switching from x86 to arm64 does not change what the compiler produces; your firmware still targets the same embedded architecture it always did.

GitHub Actions example

Switch the runner label. Everything else stays the same.

jobs:
  build:
    runs-on: ubuntu-24.04-arm   # ← only change from ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install alloy-provisioner
        run: |
          curl -fsSL https://raw.githubusercontent.com/alloy-it/\
            alloy-provisioner-releases/main/scripts/install.sh | bash

      - name: Provision environment
        run: sudo alloy-provisioner install myorg/my-blueprint:1.4.0

      - name: Build
        run: source /etc/alloy/env && make build

Ready to Cut Your CI Costs?

See how alloy-it makes arm64 migration a one-afternoon task instead of a multi-week project.

Read the Guide