Arch Linux Vs. Cachyos Vs. Omarchy 4.5 Performance Benchmarks

Welcome back to Self-Hosted Tech! If you’ve been hanging around the homelab and local AI communities lately, you’ve probably noticed a massive shift toward Arch-based distributions. Why? Because when you’re running Docker containers, spinning up virtual machines, and trying to squeeze every last token per second out of a local Large Language Model (LLM), bleeding-edge packages and kernel optimizations actually matter.

But Arch Linux itself can be a chore to set up. Enter the specialized spins: CachyOS and Omarchy. Today, we’re putting vanilla Arch Linux up against CachyOS and the newly updated Omarchy 4.5 to see how they stack up in raw performance, local AI inference, and self-hosted workloads.

Let’s dive into the benchmarks, break down the technical differences, and see which one deserves a spot on your bare-metal homelab server.

The Contenders

Before we look at the numbers, let’s define what we’re actually testing here. All three of these options are Arch Linux at their core, but their philosophies and out-of-the-box configurations are wildly different.

1. Arch Linux (The Baseline)

Vanilla Arch is the DIY blank canvas. You boot the ISO, drop to a command line, and build your system piece by piece. For our benchmarks, we installed Arch using the standard archinstall script, selecting the linux kernel, systemd-boot, and a minimal KDE Plasma environment just to have a standard GUI baseline. Arch uses the default upstream Linux kernel with the standard Completely Fair Scheduler (CFS) — or rather, its modern replacement, EEVDF (Earliest Eligible Virtual Deadline First), which was merged in kernel 6.6.

2. CachyOS (The Performance Beast)

CachyOS is an Arch-based distribution with one singular goal: absolute performance. It achieves this by using heavily optimized kernels (linux-cachyos), utilizing the BORE (BPF-OR-Enhanced) scheduler, and compiling its repositories with x86-64-v3 and x86-64-v4 optimizations. This means if you have a modern CPU (Haswell or newer for v3, Zen 4 or Ice Lake for v4), the binaries running on your system are compiled specifically to take advantage of advanced instruction sets like AVX2 and AVX-512.

3. Omarchy 4.5 (The Curated Wayland Spin)

Omarchy is a bit different. It’s an Arch-based distribution focused on delivering a flawless, out-of-the-box Wayland experience using Hyprland. Version 4.5 brings updated dotfiles, refined tiling window manager scripts, and a highly stripped-down environment. Because it relies on Wayland and Hyprland rather than a full Desktop Environment like GNOME or KDE, its baseline RAM usage is incredibly low. It uses the standard Arch Linux repositories but ships with a tuned kernel setup designed for maximum desktop responsiveness.

The Test System

To make this a fair fight, we ran all three distributions on the exact same hardware. This represents a solid, modern homelab/local AI hybrid machine:

CPU: AMD Ryzen 7 7800X3D (8 Cores / 16 Threads)
RAM: 64GB DDR5-6000 CL30
GPU: NVIDIA RTX 4070 Ti (12GB VRAM)
Storage: 2TB Samsung 990 Pro NVMe SSD
Kernel: Linux 6.8.x across all distros

Note: For CachyOS, we selected the x86-64-v4 repository during installation since the 7800X3D supports the required instruction sets.

Benchmark Results

We ran three main categories of tests to see how these systems handle everyday homelab and local AI tasks. All tests were run five times, and we took the average.

1. System Boot and Idle Overhead

When you’re running a headless server in your closet, you want minimal resource waste.

Idle RAM Usage (with GUI loaded):
- Arch Linux (KDE Plasma): ~1.1 GB
- CachyOS (KDE Plasma): ~1.2 GB
- Omarchy 4.5 (Hyprland): ~450 MB
Cold Boot Time (From GRUB to Desktop/Terminal):
- Arch Linux: 14.2 seconds
- CachyOS: 11.8 seconds
- Omarchy 4.5: 9.5 seconds

Winner: Omarchy 4.5. By utilizing Hyprland instead of a full Desktop Environment, Omarchy leaves an incredible amount of RAM free for your Docker containers and VMs. CachyOS boots slightly faster than Arch due to its optimized mkinitcpio configurations.

2. CPU Compilation (The Phoronix Test Suite)

To test raw CPU scheduling and binary optimization, we compiled a Linux kernel from source using make -j16.

Arch Linux: 4 minutes, 12 seconds
CachyOS: 3 minutes, 48 seconds
Omarchy 4.5: 4 minutes, 11 seconds

Winner: CachyOS. This is where CachyOS flexes its muscles. The BORE scheduler handles multi-threaded workloads brilliantly, and the x86-64-v4 compiled binaries give it a distinct edge in CPU-heavy tasks. Omarchy performs almost identically to vanilla Arch here because it relies on standard Arch repos.

3. Local AI / LLM Inference

This is the big one for the Self-Hosted Tech community. We ran Ollama locally to pull the llama3:8b model and measured the token generation rate (tokens per second). The model was entirely offloaded to the GPU’s 12GB VRAM to test the system’s ability to handle high-throughput PCIe and memory operations.

Arch Linux: 42.1 tokens/sec
CachyOS: 43.8 tokens/sec
Omarchy 4.5: 42.0 tokens/sec

Winner: CachyOS (barely). When running purely on the GPU, the OS overhead matters less. However, CachyOS still pulled ahead slightly. If we had offloaded some of the model layers to system RAM (which happens with larger models), CachyOS would likely widen the gap due to its optimized memory management and CPU scheduling.

Practical Walkthrough: Running Local AI in Docker

To give you a real-world example of how these systems perform under self-hosted workloads, let’s walk through setting up an Ollama container alongside Open-WebUI. This is a standard local AI homelab stack.

We’ll use Docker Compose. The process is identical across all three distros, but the performance you get at the end varies.

Step 1: Install Docker

First, install Docker and Docker Compose. On Arch, CachyOS, and Omarchy, the packages are identical.

1
2
3
sudo pacman -S docker docker-compose
sudo systemctl enable --now docker
sudo usermod -aG docker $USER

Log out and log back in for the Docker group change to take effect.

Step 2: Create the Compose File

Create a directory for your AI stack and make a docker-compose.yml file.

1
2
3
mkdir ~/ai-stack
cd ~/ai-stack
nano docker-compose.yml

Paste the following configuration into the file:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
version: '3.8'

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    # If you have an NVIDIA GPU, uncomment the deploy section below
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - open-webui_data:/app/backend/data
    depends_on:
      - ollama

volumes:
  ollama_data:
  open-webui_data:

Step 3: Spin Up the Stack

Bring your containers online:

1
docker-compose up -d

Step 4: Pull a Model and Test

Once the containers are running, pull a model through the Ollama API and test the generation speed.

1
2
3
4
5
# Pull the model
docker exec -it ollama ollama run llama3:8b

# Once inside the prompt, ask it a question:
# "Explain how Docker containers work in three sentences."

The Real-World Difference: When you run this exact setup on Omarchy 4.5, you’ll notice that spinning up the containers takes almost no system RAM overhead. You have 63.5GB of RAM left over for other homelab services like Proxmox LXC containers or Nextcloud.

When you run this on CachyOS, while the RAM overhead is slightly higher, the actual generation speed of the LLM is noticeably snappier, especially if you are running a model like mixtral:8x7b which requires offloading layers to your system’s DDR5 RAM. The BORE scheduler ensures the CPU doesn’t bottleneck the memory transfer between the system RAM and the GPU VRAM.

Which One Should You Choose?

After running these benchmarks and living with all three distros on my homelab server for a few weeks, here is my verdict:

Choose Arch Linux if: You are a purist. You want to build everything from scratch, understand every package on your system, and don’t want any third-party repositories holding custom optimizations. It’s reliable, but it takes work.
Choose CachyOS if: You are building a dedicated Local AI rig or a heavy compute server. The x86-64-v4 optimizations and BORE scheduler are not just marketing fluff—they yield measurable improvements in compilation, memory throughput, and multi-threaded tasks. If your hardware supports it, it is the fastest Arch experience available.
Choose Omarchy 4.5 if: You are running a multi-purpose homelab server that also doubles as your daily driver workstation. The Hyprland setup is gorgeous, insanely fast, and sips resources. The fact that it idles at under 500MB of RAM means you have more resources to dedicate to Docker Swarm, Kubernetes nodes, or ZFS ARC caching.

Summary

Arch Linux remains the gold standard for DIY Linux users, but the specialized spins are proving their worth in the homelab space. CachyOS takes the crown for raw compute and local AI inference, making it the go-to for heavy workloads. Omarchy 4.5 steals the show for resource efficiency and out-of-the-box usability, especially if you want a beautiful, low-overhead Wayland environment to manage your self-hosted infrastructure from.

Ultimately, the beauty of the Arch ecosystem is that you can start with one and switch to another without losing your home directory or learning a completely new package manager.

What do you think? Are you running a specialized Arch spin in your homelab, or are you sticking to the vanilla experience? Drop a comment below and let us know what your local AI stack looks like! If you found this comparison helpful, make sure to subscribe to the Self-Hosted Tech YouTube channel and bookmark the blog for more deep dives into homelab hardware, software, and local AI. Happy hosting!

Arch Linux Vs. Cachyos Vs. Omarchy 4.5 Performance Benchmarks#

The Contenders#

1. Arch Linux (The Baseline)#

2. CachyOS (The Performance Beast)#

3. Omarchy 4.5 (The Curated Wayland Spin)#

The Test System#

Benchmark Results#

1. System Boot and Idle Overhead#

2. CPU Compilation (The Phoronix Test Suite)#

3. Local AI / LLM Inference#

Practical Walkthrough: Running Local AI in Docker#

Step 1: Install Docker#

Step 2: Create the Compose File#

Step 3: Spin Up the Stack#

Step 4: Pull a Model and Test#

Which One Should You Choose?#

Summary#