# What hardware does a build server need?

> A build server needs many cores, 64 GB+ RAM for Android-size trees and NVMe. Rent one from $109.37 per 30 days, paid in crypto, no KYC.

- URL: https://lumenfer.com/build-server-hardware/
- Last updated: 2026-11-01
- Publisher: Lumenfer (https://lumenfer.com)

Cores, memory and disk for compiling large codebases, taken from the build documentation of Android, Chromium, LLVM and Rust, and matched to rented current-generation bare metal.

**Quick answer — What hardware does a build server need?**

A build server needs as many fast cores as your build can keep busy. It also needs enough RAM that parallel compiles and links never swap, and NVMe for sources, outputs and caches. Android's official floor is 64 GB of RAM and 400 GB of free disk. **Lumenfer**'s Lumen 8 (8 cores / 16 threads, 64 GB DDR5) costs $109.37 per 30 days, paid in crypto, no KYC.

## Official build requirements at a glance

| Attribute | Value |
| --- | --- |
| Android (AOSP) | 64-bit x86, 64 GB RAM minimum, 400 GB free disk (250 GB to check out, 150 GB to build) |
| Chromium on Linux | x86-64, 8 GB RAM minimum, more than 16 GB highly recommended, 100 GB free disk |
| Rust compiler | 2+ cores, 8 GB+ RAM, 30 GB+ free disk; the guide adds that 10 or 20 cores is not too many |
| LLVM and Clang | 15 to 20 GB of disk for a full debug build; Release needs much less |
| Jenkins | Run builds on agents, not on the controller |
| ccache | Default cache size 5 GiB, with optional remote storage |
| Lumenfer CPUs | AMD EPYC 4244P, AMD Ryzen 7 9700X, AMD Ryzen 9 9950X, AMD EPYC 9254, AMD EPYC 9354: all launched in 2022 or later |
| Lumenfer storage | NVMe only. Two-drive plans ship with the operating system on a software RAID 1 mirror; ask support before delivery if you prefer RAID 0 or two separate drives |
| Price | Lumen 6 $91.65, Lumen 8 $109.37, Lumen 16 $205.27, Lumen 24 $356.25, Lumen 32 $749.67 per 30 days |

## How many CPU cores does a build server need?

**As many as your build graph can run at once: compile steps spread across cores, while final links and code generators often run on one.** Ninja runs jobs in parallel by default. With Make, LLVM's guide tells you to pass `-j` with roughly your CPU count.

Google's Android documentation gives the clearest public numbers. Google builds Android on 72-core machines with 64 GB of RAM: a full build takes about 40 minutes. On a 6-core machine with 64 GB, the same full build takes about 6 hours.

**Twelve times the cores cut Google's full Android build about nine times, from 6 hours to 40 minutes.** That is Google's figure, not ours: Lumenfer publishes no benchmarks. The Rust compiler guide makes the same point in plainer words. It asks for 2 cores and says 10, 20 or more is not too many.

Single-threaded steps still set a floor. A long final link runs at the speed of one core, so per-core speed matters too. Our [guide to the best CPU for a rented server](https://lumenfer.com/best-cpu-for-dedicated-server/ "Best CPU for a rented dedicated server in 2026") weighs clock speed against core count. [How many cores you need](https://lumenfer.com/how-many-cores-dedicated-server/ "How many CPU cores a rented dedicated server needs") maps cores to workloads.

## How much RAM does a build server need?

**Enough for every parallel job at its peak plus the linker: Android sets a 64 GB minimum, and Chromium recommends more than 16 GB.** Running out of memory does not just slow a build. It pushes the machine into swap or kills the job.

- **Linking is the memory spike.** LLVM's guide warns that linking can use lots of memory. Its `LLVM_PARALLEL_LINK_JOBS` option caps simultaneous links with Ninja; set it to 1 when memory is short.
- **Debug symbols cost RAM and disk.** Chromium suggests `is_debug = false` or `symbol_level = 0` when links fail for lack of memory.
- **Swap is a safety net, not capacity.** Chromium asks for at least 32 GB of SSD swap on an 8 GB machine, and 16 GB on a 16 GB one.
- **RAM can replace disk writes.** Chromium allows a tmpfs for build output, as long as RAM plus swap can hold it.

To size your own build, measure one job's peak memory with `/usr/bin/time -v` and multiply by the parallel jobs you plan. Add the largest link on top.

## What storage does a build server need?

**Fast local NVMe with room for sources, outputs and caches: Android asks for 400 GB free, Chromium for 100 GB.** Builds read thousands of small files and write object files in bursts. Local NVMe keeps that close to the CPU. Our comparison of [NVMe and SATA SSD on rented servers](https://lumenfer.com/nvme-vs-sata-ssd-dedicated-server/ "How much faster NVMe is than SATA SSD") explains the difference.

- **Debug builds take far more space.** LLVM's guide puts a full LLVM and Clang debug build at 15 to 20 GB, against much less for Release.
- **Caches need their own budget.** ccache speeds up recompiles by storing earlier results, with a default limit of 5 GiB. Large trees need a bigger limit.
- **Shared caches beat bigger disks.** ccache can query remote storage after its local cache. Chromium's default build tool, Siso, supports remote execution and caching instead.

Two-drive plans ship with the operating system on a software RAID 1 mirror; ask support before delivery if you prefer RAID 0 or two separate drives. On a build box, RAID 0 doubles scratch space, and a dead drive only loses caches you can rebuild. Keep sources in git and artefacts off the machine either way.

## Should builds run on the CI controller itself?

**No: Jenkins calls executors on the controller a bad practice and tells you to delegate jobs to agents.** Its hardware guide describes agents as generic x86 machines with enough memory for the builds they run. The controller stays small. Jenkins counts about 2 MB or more of memory per connected build node.

With GitHub Actions, GitHub is the controller and your server is the agent. The [self-hosted GitHub Actions runner setup on a rented server](https://lumenfer.com/github-actions-runner-dedicated-server/ "Set up a self-hosted GitHub Actions runner on a rented server") walks through registration, services and security. Whether it pays off against hosted minutes is worked out in [self-hosted runner vs GitHub-hosted cost](https://lumenfer.com/self-hosted-runner-vs-github-hosted-cost/ "Is a rented server cheaper than GitHub-hosted runners?").

## Does a build server need ECC memory?

**Not for everyday CI, but prefer it for release builds you sign and ship.** ECC memory detects and corrects single-bit errors before they reach a file. Without it, a rare flipped bit can end up inside an artefact that passes every test.

The Lumenfer plans with ECC are Lumen 6 (32 GB DDR5 ECC), Lumen 24 (256 GB DDR5 ECC) and Lumen 32 (384 GB DDR5 ECC). The Ryzen plans list standard DDR5. Our page on [whether you need ECC RAM](https://lumenfer.com/ecc-ram-dedicated-server/ "Do I need ECC RAM on a rented dedicated server?") covers the trade-off.

## Which Lumenfer plan fits which build?

**Match the plan to your largest build, then add one parallel job per spare 4 to 8 threads.** Every plan is a whole machine: no hypervisor, no neighbours. Linux images only: Debian, Ubuntu, AlmaLinux and Rocky Linux, plus Proxmox VE for running virtual machines on the hardware. Windows is not offered.

**In Lumenfer's check of 30 October 2026, 12 of 18 no-KYC crypto hosts sold their cheapest dedicated server on a CPU launched before 2022.** Every Lumenfer plan runs a 2022-or-newer CPU with DDR5 memory. Full prices and terms are on the [Lumenfer pricing page](https://lumenfer.com/pricing/ "Lumenfer bare-metal plans and prices per 30 days").

### Lumenfer plans as build servers

| Plan | CPU | Cores | Memory | Disks | Per 30 days | Fits |
| --- | --- | --- | --- | --- | --- | --- |
| Lumen 6 | AMD EPYC 4244P | 6 cores / 12 threads | 32 GB DDR5 ECC | 2 × 960 GB NVMe | $91.65 | Small services, test runners, a Jenkins controller |
| Lumen 8 | AMD Ryzen 7 9700X | 8 cores / 16 threads | 64 GB DDR5 | 2 × 1 TB NVMe | $109.37 | Mid-size C++, Rust and Java builds |
| Lumen 16 | AMD Ryzen 9 9950X | 16 cores / 32 threads | 128 GB DDR5 | 2 × 1.92 TB NVMe | $205.27 | Chromium-size trees, 4 to 8 parallel jobs |
| Lumen 24 | AMD EPYC 9254 | 24 cores / 48 threads | 256 GB DDR5 ECC | 2 × 1.92 TB NVMe | $356.25 | Android on ECC memory, runner VMs under Proxmox |
| Lumen 32 | AMD EPYC 9354 | 32 cores / 64 threads | 384 GB DDR5 ECC | 2 × 3.84 TB NVMe | $749.67 | Full Android builds, a shared build farm |

### What comparable 8-core and 16-core servers cost elsewhere

| Server | Specs | Price per month |
| --- | --- | --- |
| Lumenfer Lumen 8 | AMD Ryzen 7 9700X (2024, 8 cores / 16 threads), 64 GB DDR5, 2 × 1 TB NVMe in RAID 1, 40 TB a month at 1 Gbit/s, 1 IPv4 and an IPv6 /64 | $109.37 |
| Privex: RYZ78-ZEN4-FIN (Finland Dedicated (AMD Ryzen / EPYC)) | AMD Ryzen 7 PRO 8700GE, 8 cores / 64 GB / 2x512GB NVMe (Gen4) | $140.00/month + $70.00 setup ($145.83 a month over a year) |
| Median of 13 hosts | Comparable 8-core servers | $356.07 |
| Lumenfer Lumen 16 | AMD Ryzen 9 9950X (2024, 16 cores / 32 threads), 128 GB DDR5, 2 × 1.92 TB NVMe in RAID 1, 60 TB a month at 1 Gbit/s, 1 IPv4 and an IPv6 /64 | $205.27 |
| AbeloHost: AMD Ryzen 9 7950X (PL) | AMD Ryzen 9 7950X, 16 cores / 192 GB / 2 x 2 TB NVMe | €244.99 ($273.70) |
| Median of 8 hosts | Comparable 16-core servers | $430.21 |

*Prices checked on October 30, 2026.*

Crypto-paying hosts with no ID check at signup; 2022+ CPU, NVMe only, monthly billing. 1 EUR = 1.1172 USD (ECB, 30 October 2026).

## Rent a build server

Billed per 30 days, 3 months, 6 months or 12 months from a crypto balance. Amsterdam (Netherlands), Reykjavik (Iceland), Zurich (Switzerland) and Bucharest (Romania): all five plans in all four cities, one price everywhere.

| Plan | Quantity | 30 days | 3 months | 6 months | 1 year |
| --- | --- | --- | --- | --- | --- |
| Lumen 8 | 8 cores · 64 GB DDR5 | $109.37 | $295.29 (−10%) | $524.97 (−20%) | $918.70 (−30%) |
| Lumen 16 | 16 cores · 128 GB DDR5 | $205.27 | $554.22 (−10%) | $985.29 (−20%) | $1,724.26 (−30%) |
| Lumen 32 | 32 cores · 384 GB DDR5 | $749.67 | $2,024.10 (−10%) | $3,598.41 (−20%) | $6,297.22 (−30%) |

In every plan: 2022+ CPU · DDR5 · NVMe only · RAID 1 · Dedicated IPv4 · No KYC

**Before you pay**

- Minimum top-up $1. Top up once in crypto, then buy any plan from your balance.
- Credit on your balance does not expire and renews any of your servers. When a top-up is only made to reach the minimum, the unspent part comes back on request within 30 days of payment, in USDT or USDC. The rest of a balance is not paid out unless the law requires it.
- Credited once your payment is checked on the blockchain. Typical network confirmation time: BTC ≈ 20 min · USDT TRC-20 ≈ 1 min · USDT ERC-20 ≈ 5 min · USDC ERC-20 ≈ 5 min · ETH ≈ 5 min · SOL ≈ 1 min · LTC ≈ 15 min · XMR ≈ 20 min

## Build server hardware: FAQ

### Is 32 GB of RAM enough for a build server?

For many projects, yes: Chromium's Linux guide asks for 8 GB and highly recommends more than 16 GB. For Android, no: Google's minimum is 64 GB. Count your parallel jobs and peak link memory before you decide.

### Can I compile in RAM with tmpfs?

Yes. Chromium's documentation suggests a tmpfs for build output to cut disk writes. It warns that RAM plus swap must be large enough to hold that output. Plans with more memory leave room for both the build and the tmpfs.

### Should I use ccache or remote execution?

Use ccache for classic Make, CMake or Ninja builds; raise its 5 GiB default for large trees. Chromium's documentation says ccache and icecc are not useful with its Siso build tool, which supports remote execution instead.

### Can this server build Windows or macOS software?

Linux images only: Debian, Ubuntu, AlmaLinux and Rocky Linux, plus Proxmox VE for running virtual machines on the hardware. Windows is not offered. Cross-compiling toolchains for other targets run fine on Linux. Native macOS and Windows builds need machines running those systems, elsewhere.

### How quickly can I get a build server?

Your server goes live a few minutes after the payment confirms, and the wait never runs past one hour; the dashboard follows the build, then shows the IP address once the machine is up. You pay from a crypto balance in BTC, USDT, USDC, ETH, SOL, LTC, XMR, with no KYC. Terms of 6 or 12 months cost less per month than 30-day renewals.

## Sources

1. [Hardware and software requirements (Android Open Source Project)](https://source.android.com/docs/setup/start/requirements) — Android Open Source Project (read 2026-11-01)
2. [Checking out and building Chromium on Linux](https://chromium.googlesource.com/chromium/src/+/main/docs/linux/build_instructions.md) — The Chromium Projects (read 2026-11-01)
3. [Prerequisites (building the Rust compiler)](https://rustc-dev-guide.rust-lang.org/building/prerequisites.html) — Rust Compiler Development Guide (read 2026-11-01)
4. [Getting Started with the LLVM System](https://llvm.org/docs/GettingStarted.html) — LLVM Project (read 2026-11-01)
5. [Hardware Recommendations](https://www.jenkins.io/doc/book/scaling/hardware-recommendations/) — Jenkins (read 2026-11-01)
6. [Ccache manual](https://ccache.dev/manual/latest.html) — ccache (read 2026-11-01)
7. [RYZ78-ZEN4-FIN (Finland Dedicated)](https://pay.privex.io/order/package/ryz78-zen4-fin) — Privex (read 2026-10-30)
8. [AMD Ryzen 9 7950X (PL)](https://bill.abelohost.com/index.php?rp=/store/pl-dedicated-servers/amd-ryzen-9-7950x) — AbeloHost (read 2026-10-30)

---

Lumenfer: Lumenfer rents current-generation bare-metal servers in Amsterdam, Reykjavik, Zurich and Bucharest, paid in crypto with no KYC: no ID, no selfie, no documents. Every machine has a CPU launched in 2022 or later, DDR5 memory and NVMe drives, and is rented whole by one customer with root access. It is run by DomaineGoat LLC, a Panama company that ignores DMCA notices, answers only to Panamanian law, allows Tor exit relays and keeps no logs. On the 30-day term, every plan is priced at least 25% under a named comparable current-generation server from 13 no-KYC crypto hosts, read on 30 October 2026.