# Building Custom Linux with Yocto on Hetzner:  With 9 Steps

## Introduction

Building a custom Linux distribution gives you complete control over your system's components, dependencies, and footprint. The Yocto Project is the industry-standard framework for creating tailored Linux distributions, and Hetzner provides powerful, affordable dedicated servers perfect for compilation workloads. This guide walks you through the entire process of building a custom Linux system using Yocto on a Hetzner server.

## Why Yocto on Hetzner?

**Yocto Benefits:**

* Complete control over every system component
    
* Optimized for embedded and production systems
    
* Reproducible builds
    
* Extensive hardware support
    
* Active community and commercial backing
    

**Hetzner Advantages:**

* Powerful dedicated servers at competitive prices
    
* High-speed network connectivity
    
* Located in European data centers
    
* Excellent build server specifications
    
* No bandwidth limitations for compilation tasks
    

## Prerequisites

Before starting, you'll need:

* A Hetzner dedicated server (minimum 16GB RAM, 4+ cores recommended)
    
* Ubuntu 22.04 LTS or Debian 11+ installed
    
* Root or sudo access
    
* At least 100GB free disk space
    
* Basic Linux command line knowledge
    

## Step 1: Provision Your Hetzner Server

Log into the Hetzner Robot panel and provision a dedicated server. For Yocto builds, I recommend:

* **CPU:** Intel Xeon or AMD Ryzen with 6+ cores
    
* **RAM:** 32GB or more (builds are memory-intensive)
    
* **Storage:** NVMe SSD preferred for faster compilation
    

Once provisioned, SSH into your server and update the system:

```bash
ssh root@your-server-ip
apt update && apt upgrade -y
```

## Step 2: Install Required Dependencies

Yocto requires several build tools and libraries. Install them with:

```bash
apt install -y gawk wget git diffstat unzip texinfo gcc build-essential \
chrpath socat cpio python3 python3-pip python3-pexpect xz-utils \
debianutils iputils-ping python3-git python3-jinja2 libegl1-mesa \
libsdl1.2-dev pylint xterm python3-subunit mesa-common-dev zstd liblz4-tool
```

## Step 3: Create a Build User

Never run Yocto builds as root. Create a dedicated build user:

```bash
useradd -m -s /bin/bash yocto
usermod -aG sudo yocto
su - yocto
```

## Step 4: Download Yocto (Poky)

Clone the Yocto Project reference distribution (Poky). We'll use the latest LTS release:

```bash
cd ~
git clone git://git.yoctoproject.org/poky
cd poky
git checkout -b my-build scarthgap  # LTS release
```

## Step 5: Initialize the Build Environment

Source the build environment setup script:

```bash
source oe-init-build-env
```

This creates a `build` directory and sets up your shell environment. You'll need to source this script every time you open a new terminal session.

## Step 6: Configure Your Build

Navigate to the build configuration directory and edit `local.conf`:

```bash
cd ~/poky/build/conf
nano local.conf
```

```bash
# Set machine architecture (e.g., x86-64, ARM, etc.)
MACHINE ?= "qemux86-64"  # For testing in QEMU
# MACHINE ?= "genericx86-64"  # For physical x86-64 hardware

# Increase parallel build tasks based on your CPU
BB_NUMBER_THREADS ?= "8"  # Number of CPU cores
PARALLEL_MAKE ?= "-j 8"   # Parallel make jobs

# Add systemd support (optional)
DISTRO_FEATURES:append = " systemd"
VIRTUAL-RUNTIME_init_manager = "systemd"
DISTRO_FEATURES_BACKFILL_CONSIDERED = "sysvinit"

# Add additional packages to your image
IMAGE_INSTALL:append = " openssh vim htop curl wget"

# Set download directory to save bandwidth on rebuilds
DL_DIR ?= "${TOPDIR}/../downloads"

# Shared state cache for faster rebuilds
SSTATE_DIR ?= "${TOPDIR}/../sstate-cache"
```

## Step 7: Select Your Image Type

Yocto provides several base images. Choose based on your needs:

* **core-image-minimal:** Bare minimum system
    
* **core-image-base:** Small image with some utilities
    
* **core-image-full-cmdline:** Full command-line system
    
* **core-image-sato:** Image with graphical interface
    

For a server, `core-image-base` or `core-image-full-cmdline` are good starting points.

## Step 8: Start the Build

Launch your first build:

```bash
bitbake core-image-minimal
```

> The first build takes 2-8 hours depending on your server specs and will download several gigabytes of source code. Subsequent builds are much faster thanks to caching.

## Step 9: Deploy Your Custom Image

After the build completes, your images are located in:

```bash
~/poky/build/tmp/deploy/images/qemux86-64/
```

Congratulations! For new set of issues in your life