CI Runnerscirunners.org
Use case · Docker builds

Choosing a runner for Docker image builds

Answer in brief

Docker builds are slow in CI because every job starts with an empty layer cache. The fix is a runner that keeps the build cache between jobs: a persistent disk or a managed layer cache attached to the builder, so unchanged layers are reused instead of rebuilt or downloaded. For multi-platform images, native arm64 runners avoid emulating one architecture on another.

By the CI Runners editors · Updated

What Docker image builds need from a runner

On an ephemeral runner, docker build begins with no local layers. The common workarounds (registry cache, the GitHub Actions cache backend) export and import the cache over the network on every run, which can cost as much time as it saves for large images.

  • Persistent layer cache: the runner mounts a disk that already holds the previous build’s layers, so BuildKit reuses them directly.
  • Cache scope and isolation: who can read and write the cache (per repository, per branch, per organisation) matters for both hit rate and security.
  • Native multi-architecture builds: building arm64 images on arm64 runners instead of under QEMU emulation.
  • Disk size and speed: image builds are I/O heavy, so local NVMe storage helps.
  • Docker-in-runner support: microVM runners give each job its own Docker daemon; container-based self-hosted runners need extra configuration for Docker builds.

See Docker layer caching in CI for how the approaches differ.

Runners that fit, by kind

12 runners document what this workload needs. They are grouped by kind and listed alphabetically; the order is not a ranking. Shortlist two or three, then try them with your own workflows.

Managed runners for GitHub Actions

Third-party runners you switch to by changing the runs-on label in a workflow.

  • Avrea

    Managed GitHub Actions runners for Linux, macOS and Windows on dedicated hardware, with colocated caches and SSH into running jobs.

    • Per-job VM
    • Ephemeral
    • arm64
    • macOS
    • Windows
    • Docker layer cache

    Why it fits: Docker layers are cached through BuildKit’s type=gha backend served by Avrea, with optional persistent-disk Docker state on Linux.

  • Blacksmith

    Managed GitHub Actions runners in Firecracker microVMs on the vendor’s own bare-metal fleet, with caches kept next to the runners.

    • Firecracker microVM
    • Ephemeral
    • arm64
    • macOS
    • Windows
    • Docker layer cache

    Why it fits: Docker layers persist across runs on NVMe-backed sticky disks through Blacksmith’s Docker builder actions.

  • BuildPulse Runners

    Managed Linux runners for GitHub Actions, CircleCI and Semaphore with included cache storage and flaky-test detection on every run.

    • Fresh per-job runner
    • Ephemeral
    • arm64
    • Docker layer cache

    Why it fits: Docker layer caches persist across runs, and NVMe-backed Docker builder runners are offered.

  • Depot GitHub Actions Runners

    Managed GitHub Actions runners on single-tenant AWS EC2 instances, connected to Depot’s cache and container build service.

    • Single-tenant EC2 instance
    • Ephemeral
    • arm64
    • macOS
    • Windows
    • Docker layer cache
    • GPU
    • BYOC

    Why it fits: Depot’s container build service keeps a persistent Docker layer cache on NVMe SSDs and is used from Actions through depot/build-push-action.

  • Namespace

    Managed runners for GitHub Actions and Buildkite on the vendor’s own hardware, configured through profiles with persistent cache volumes.

    • Virtual machine
    • Ephemeral
    • arm64
    • macOS
    • Windows
    • Docker layer cache

    Why it fits: Docker builds on Namespace runners are sent to Remote Builders by default, with layer caching included.

  • WarpBuild

    Managed GitHub Actions runners in ephemeral VMs, also offered as a deployment in your own AWS, Google Cloud or Azure account.

    • Ephemeral VM
    • Ephemeral
    • arm64
    • macOS
    • Windows
    • Docker layer cache
    • BYOC

    Why it fits: Remote Docker Builders build and push images with layer caching, and a type=gha cache endpoint is available on runners.

Runners from your CI platform or cloud

The first-party hosted runners of GitHub, GitLab, Buildkite and Azure, plus cloud-native runner services.

Runners in your own cloud or on your hardware

Commercial products that launch runners inside your cloud account or on servers you own.

  • Actuated

    Managed control plane that runs each CI job in a Firecracker microVM on servers you provide, for GitHub Actions and GitLab CI.

    • Firecracker microVM
    • Ephemeral
    • arm64
    • Docker layer cache
    • GPU
    • BYOC

    Why it fits: Docker runs natively inside each microVM, and a transparent cache and registry mirror keep layers on local NVMe.

  • enomem

    Self-hosted GitHub Actions runners on Azure: an Azure Functions handler in your subscription starts one Spot VM per job.

    • Azure VM
    • Ephemeral
    • arm64
    • Docker layer cache
    • BYOC
    • Self-hostable

    Why it fits: A pre-configured Buildx builder supports Docker layer caching with cache-from and cache-to.

  • RunsOn

    Self-hosted GitHub Actions runner control plane installed in your own AWS account, launching one fresh EC2 instance per job.

    • EC2 instance
    • Ephemeral
    • arm64
    • Windows
    • Docker layer cache
    • GPU
    • BYOC
    • Self-hostable

    Why it fits: Docker layers can be cached through S3-backed Buildx caching, a per-stack ECR registry or sticky EBS disks.

Open-source autoscalers for self-hosted runners

Software you deploy to run and scale self-hosted runners on Kubernetes, cloud VMs or bare metal.

Side by side

RunnerCI systemsRuns onDeploymentIsolationPriceLargest runnerDocker layer cacheGPUOpen sourceCompany HQ
ActuatedGitHub Actions, GitLab CILinux, x64, arm64Your cloud or hardwareFirecracker microVM$150/mo per server + your serversSet by your infrastructureYesYesNoUnited Kingdom
AvreaGitHub ActionsLinux, macOS, Windows, x64, arm64Vendor-hostedPer-job VM$0.004/min32 vCPU / 128 GBYesNot documentedNoFinland
BlacksmithGitHub ActionsLinux, macOS, Windows, x64, arm64Vendor-hostedFirecracker microVM$0.004/min32 vCPU / 128 GBYesNot documentedNoUnited States
Buildkite hosted agentsBuildkiteLinux, macOS, Windows, x64, arm64Platform-hostedEphemeral virtualized environment$0.008/min64 vCPU / 256 GBYesNot documentedNoNot documented
BuildPulse RunnersGitHub Actions, CircleCI, SemaphoreLinux, x64, arm64Vendor-hostedFresh per-job runner$0.004/min64 vCPU / 256 GBYesNot documentedNoNot documented
Depot GitHub Actions RunnersGitHub ActionsLinux, macOS, Windows, x64, arm64Vendor-hostedSingle-tenant EC2 instance$0.006/min64 vCPU / 256 GBYesYesNoNot documented
enomemGitHub ActionsLinux, x64, arm64Your cloud or hardwareAzure VM$25/mo licence + Azure cost96 vCPU / 384 GBYesNot documentedNot documentedNot documented
GitLab-hosted runnersGitLab CILinux, macOS, Windows, x64, arm64Platform-hostedEphemeral VM$10 per 1,000 compute minutes32 vCPU / 128 GBNot documentedYesNoNot documented
NamespaceGitHub Actions, BuildkiteLinux, macOS, Windows, x64, arm64Vendor-hostedVirtual machine$0.002/min prepaid, $0.003/min overage (2 vCPU / 4 GB)64 vCPU / 512 GBYesNot documentedNoNot documented
RunsOnGitHub ActionsLinux, Windows, x64, arm64Your cloud or hardwareEC2 instance€300/yr licence + AWS cost896 vCPUYesYesNoFrance
TestFlows GitHub Hetzner RunnersGitHub ActionsLinux, x64, arm64Self-hostedHetzner Cloud VMFree software + your infrastructureSet by your infrastructureYesNot documentedYesNot documented
WarpBuildGitHub ActionsLinux, macOS, Windows, x64, arm64Vendor-hostedEphemeral VM$0.004/min32 vCPU / 128 GBYesNot documentedNoNot documented

Frequently asked questions

Why are Docker builds slow in GitHub Actions?
Each job runs on a fresh machine with an empty Docker layer cache, so every layer is rebuilt or pulled. Registry-based and Actions-cache-based layer caching help but transfer the cache over the network each time. Runners with a persistent layer cache keep the layers on a disk attached to the builder. See Docker layer caching in CI.

Check before you rely on it. Products change quickly, and this page reflects public documentation as of November 22, 2026. Confirm anything that matters in the provider’s own documentation.

Cite this page

CI Runners. (2026). Choosing a runner for Docker image builds. cirunners.org. Last reviewed November 22, 2026. https://cirunners.org/use-cases/docker-builds/