# Benchmark: Ghostty builds 3-27x faster on Avrea than GitHub Actions

10m 27s on GitHub Actions. 3m 33s on Avrea without cache. 23 seconds with a warm Nix binary cache. That's 2.9x from the hardware, 27x once caching kicks in.

[All posts](https://avrea.com/blog)

[Blog](https://avrea.com/blog)
[CI/CD](https://avrea.com/category/ci-cd)

10m 27s on GitHub Actions. 3m 33s on Avrea without cache. 23 seconds with a warm Nix binary cache. That's 2.9x from the hardware, 27x once caching kicks in.

[Leo Lännenmäki](https://avrea.com/team/leo-lannenmaki)
11 May 2026

On GitHub Actions, a no-cache Ghostty build takes 10 minutes 27 seconds. On Avrea, the same build, same 2 vCPU spec: 3 minutes 33 seconds without cache, 23 seconds with a warm Nix binary cache.

## Why Ghostty

[Ghostty](https://github.com/ghostty-org/ghostty) is an open-source terminal emulator by [Mitchell Hashimoto](https://mitchellh.com/) (of [HashiCorp](https://www.hashicorp.com/) fame), written in [Zig](https://ziglang.org/) and packaged with [Nix](https://nixos.org/). We picked it as a benchmark target because, well, many of us use it as our primary terminal emulator and because we didn’t have any other benchmarks that would be written in Zig or that would use Nix for packaging. Primarily we wanted to exercise and benchmark our Nix caching.

Nix caches whole derivations: built packages keyed by the hash of their inputs. The full Ghostty build graph, including the compiler toolchain and system dependencies, is a graph of derivations. On a cache hit, Nix pulls the derivation’s output. On a miss, it builds from source. The more hits you get, the closer the build gets to doing nothing.

## How we ran the test

We ran `nix build .` against a pinned Ghostty [commit](https://github.com/ghostty-org/ghostty/releases/tag/v1.3.1). Runner sizes matched across both sides.

| | GitHub Actions | Avrea |
| --- | --- | --- |
| Runner label | `ubuntu-24.04` | `avrea-ubuntu-latest-2-vcpu` |
| vCPU | 2 | 2 |
| RAM | 7.8Gi | 7.8Gi |

For the cached run, we used [Avrea’s Nix binary cache](https://docs.avrea.com/cache/build-cache/nix/) as a substitute for the default substituters. On the no-cache run, the binary cache was disabled; every derivation built from source. The GitHub Actions side had no binary cache backing on either run.

The numbers are medians across runs. Avrea’s cached runs were tight (within a few seconds). GitHub Actions was noisier.

Below is a self-contained example workflow of what we are measuring.

```
name: "Ghostty"

on:
  workflow_dispatch:

env:
  PROJECT_REPO: "https://github.com/ghostty-org/ghostty.git"
  PROJECT_TAG: "v1.3.1"

jobs:
  build:
    runs-on: avrea-ubuntu-latest-2-vcpu
    steps:
      - name: Install Nix
        uses: cachix/install-nix-action@v31

      - name: Clone project
        run: git clone --depth 1 --branch ${{ env.PROJECT_TAG }} ${{ env.PROJECT_REPO }} ghostty

      - name: Build
        working-directory: ghostty
        run: nix build .#ghostty --no-link
```

## Results

| | GitHub Actions | Avrea | Speedup |
| --- | --- | --- | --- |
| **No cache** | 10m 27s | 3m 33s | **2.9x** |
| **With cache** | n/a | **23.0s** | **27.2x** |

Hardware alone runs 2.9x faster. Pointing Nix at Avrea’s binary cache brings the warm time to 23 seconds, for 27x total.

The Zig toolchain is the heaviest derivation in this build. On a cache miss it accounts for a big chunk of the cold time. On a cache hit, that same derivation becomes a read off disk.

## Why it’s faster

### The hardware (the 2.9x)

A no-cache Ghostty build compiles Zig, builds system libraries, and links the final binary. CPU-heavy but also dependency-dense: many small builds, lots of filesystem operations for staging and linking.

On a 2 vCPU runner, Avrea clocks roughly 6,500 sysbench events/sec single-core. GitHub does around 3,670. Disk is a wider gap: 4 GB/s vs 220 MB/s on writes. Hardware alone gives the 2.9x speedup.

### The cache (the 27x)

Nix’s binary cache is content-addressed: if the inputs haven’t changed, the derivation’s output already exists somewhere, named by its hash. A cached build becomes: resolve the graph, read or fetch the cached outputs, done.

Avrea’s cache is fast. “Fetch” is a read from this co-located storage. That’s how the Ghostty build goes from 10 minutes to 23 seconds without the compiler running at all.

Nix’s caching model stores whole-derivation outputs rather than single compile units, which is why the warm number drops so hard. If you’re running Nix in CI without a cache like Avrea has you are missing out.

## Other benchmarks in this series

- [Bazel](https://avrea.com/blog/bazel-ci-benchmark) (39.7x)
- [Linux kernel](https://avrea.com/blog/linux-kernel-ci-benchmark) (68x)
- [Kafka](https://avrea.com/blog/kafka-gradle-ci-benchmark) (6.6x)
- [Next.js](https://avrea.com/blog/nextjs-turborepo-ci-benchmark) (142x)
- [RisingWave](https://avrea.com/blog/risingwave-sccache-ci-benchmark) (11.5x)

## About Avrea

Avrea is a [drop-in replacement for GitHub Actions runners](https://avrea.com/ci-runners). Update the `runs-on` label in your workflow and the build moves over.

Runs come with [CPU and memory metrics](https://avrea.com/observability), searchable log history, and a way to SSH into the running VM.

[See pricing](https://avrea.com/pricing) or [start free on Avrea →](https://console.avrea.com/)

## Explore other articles

- 1 Sept 2026
A guide to GitHub Actions caching
Read
<https://avrea.com/blog/github-actions-cache>

- 12 May 2026
Benchmark: Linux kernel builds 3-68x faster on Avrea than GitHub Actions
Read
<https://avrea.com/blog/linux-kernel-ci-benchmark>

- 10 Jul 2026
The Fastest GitHub Actions Runners in 2026: CPU Benchmarks Are Half the Story
Read
<https://avrea.com/blog/fastest-github-actions-runners>

## Start shipping with Avrea

[Start free](https://console.avrea.com/)
[Talk to an engineer](https://avrea.com/demo)
