# No space left on device in GitHub Actions: causes and fixes

A private repository's runner starts with about 14 GB free, and Docker on Ubuntu 26.04 needs more than before. Here is what fills the disk, and how to get room.

November 8, 2026, by Supercorp.

A job that fails with `No space left on device` has filled the runner's disk. The message comes in many shapes, from Docker (`failed to register layer`, `write /var/lib/docker/...`), from Java (`java.io.IOException: No space left on device`), from .NET (`System.IO.IOException`) or from Rust (`os error 28`), but the cause is the same: the job wrote more than the machine had room for. Here is how much room GitHub's runners really have, what usually fills it, and the ways to get more.

## How much disk a runner has

GitHub's [runner reference](https://docs.github.com/en/actions/reference/runners/github-hosted-runners) lists 14 GB of SSD storage for its standard runners. The machines' disks are larger than that, but most of each is taken by the tools GitHub preinstalls. In August 2026 a maintainer of GitHub's runner images gave the real figures, [in an issue about disk sizes](https://github.com/actions/runner-images/issues/14492):

> Public repos use 4-core VM, which has a 150 GB disk and ~90 GB of free space.
>
> Private repos use 2-core VM, which has a 75 GB disk and ~14 GB of free space.

He added that only 14 GB of free space is promised on either. So:

| Runner | Disk | Free when the job starts |
|---|---|---|
| Standard, private repository (2 cores) | 75 GB | about 14 GB |
| Standard, public repository (4 cores) | 150 GB | about 90 GB, not promised |
| Larger runner, 4 cores | 150 GB | |
| Larger runner, 8 cores | 300 GB | |
| Larger runner, 16 cores | 600 GB | |
| Larger runner, 32 cores | 1,200 GB | |

The larger runners' sizes are from GitHub's [larger runners reference](https://docs.github.com/en/actions/reference/runners/larger-runners).

So the same workflow can pass in a public repository and fail in a private one: 90 GB free in one, 14 GB in the other.

## What fills it

**Docker, most of all.** Every image pulled, every layer built and the build cache stay on the disk until the job ends. A few large images, or one image with a model or a dataset in it, is enough.

**Docker on Ubuntu 26.04 needs more.** GitHub is moving `ubuntu-latest` to Ubuntu 26.04 between [19 October and 19 November 2026](https://github.com/actions/runner-images/issues/14748). Its Docker 29 uses the [containerd image store](https://docs.docker.com/engine/storage/containerd/) by default, and a maintainer of the images explained in [an issue about a build that failed after the switch](https://github.com/actions/runner-images/issues/15233) that it "keeps both a compressed and an unpacked copy of each image layer, increasing the needed disk space". A Docker build that fit on Ubuntu 24.04 can run out of room on 26.04.

**Build outputs and dependencies.** A Rust `target` folder, a large `node_modules`, Gradle and Maven caches, compiled test binaries: each can be several GB.

**Test data.** Database dumps, fixtures, browsers, recorded videos and screenshots of failed tests.

## Find out what is using it

Add a step that runs when the job fails, and read its output:

```yaml
- name: What is using the disk
  if: failure()
  run: |
    df -h /
    docker system df || true
    sudo du -xh / --max-depth=3 2>/dev/null | sort -h | tail -25
```

`df` says how full the disk is, `docker system df` how much of it is Docker's, and `du` which folders are largest.

## Five ways to get room

### 1. Remove the tools you do not use

The runner comes with Android's SDK, .NET, Haskell, browsers, databases and more. A job that needs none of them can delete them first. The [free-disk-space](https://github.com/lumbroso-commons/free-disk-space) action does it, and its README says that with every option on it "can clear up to 31 GB of disk space in about 3 minutes":

```yaml
- uses: lumbroso-commons/free-disk-space@main
  with:
    android: true
    dotnet: true
    haskell: true
    large-packages: true
    docker-images: true
```

The minutes count. On a short job, deleting tools can take longer than the work it makes room for.

### 2. Keep Docker smaller

- **Push instead of loading.** A build that is pushed straight to a registry does not keep the whole image on the runner. The maintainer suggests `docker buildx build --push`, or `push: true` in `docker/build-push-action`, instead of loading the image locally.
- **On Ubuntu 26.04, go back to the classic store** if the job only needs what Ubuntu 24.04's Docker did. This step is from the same answer:

```yaml
- name: Use the classic Docker storage driver
  run: |
    echo '{"features":{"containerd-snapshotter":false}}' | sudo tee /etc/docker/daemon.json
    sudo systemctl restart docker
    docker info -f '{{ .Driver }}'   # should print overlay2
```

- **Prune between steps** that pull different images: `docker system prune -af`.

### 3. Pin the image

If a job started failing when `ubuntu-latest` moved, `runs-on: ubuntu-24.04` puts it back on the image it passed on, while you find out why. It is a stopgap: that image will be retired in its turn.

### 4. Split the job

A job that builds three large images, or runs three heavy suites, can be three jobs, each on a runner of its own with its own disk. A [matrix](https://docs.github.com/en/actions/how-tos/write-workflows/choose-what-workflows-do/run-job-variations) does it in a few lines.

### 5. Use a runner with a larger disk

- **GitHub's larger runners** start at 150 GB. The 4-core one is $0.012 a minute, twice the $0.006 of the standard runner, and needs a Team or Enterprise Cloud plan.
- **Your own runners** have whatever disk you give them.

## With SuperCI

SuperCI, which we make, runs GitHub Actions jobs on fresh machines in your own AWS, Cloudflare or Modal account. The label says how much disk a job gets:

```yaml
jobs:
  build:
    runs-on: superci/cpu=8/disk=200
```

On AWS the disk is the machine's whole root filesystem. The image uses about 18 GB of it, so the standard machine's 60 GB leaves about 40 GB free, and `disk=200` about 180. A larger disk costs little: gp3 storage is $0.08 a GB-month, so 200 GB adds about $0.02 an hour to the machine, billed only while the job runs. Jobs that write a lot can also keep their work on an NVMe disk of the machine's own, or in memory: see [Labels and machines](/docs/labels).

The machine is fresh for every job and ends with it, so nothing a job leaves behind fills the next one's disk.

Related: [GitHub Actions out of memory](/blog/github-actions-out-of-memory), and [every GitHub Actions limit in one place](/blog/github-actions-limits).
