CachyOS: the ultra-optimized Arch Linux that's preparing a server edition

In the ecosystem of performance-oriented Linux distributions, CachyOS stands out as a bold proposition: take Arch Linux as a base and push optimization to its limits. With measured performance gains ranging from 5% to 20% depending on the workload, this distribution is drawing the attention of system administrators and performance enthusiasts alike. But CachyOS doesn't stop there: the team is currently preparing a hardened server edition that could shake up the market for production-infrastructure distributions.

While most Linux distributions favor universal compatibility at the expense of performance, CachyOS makes the opposite bet: take advantage of modern CPU instructions and advanced optimization techniques to deliver a significantly faster system experience. Could this philosophy redefine performance standards in the server world?

Why Linux 7.0 performance matters in production

The Linux kernel sits at the heart of every system operation: process management, CPU scheduling, disk I/O, networking, memory. Every microsecond saved in the scheduler is multiplied across millions of daily operations. On a web server handling 10,000 requests per second, a 5% reduction in scheduler latency translates to hundreds of milliseconds saved every minute.

Traditional distributions like Ubuntu or Fedora compile their packages for the baseline x86-64 architecture defined back in 2003. This approach guarantees compatibility with older processors, but it leaves modern vector instructions like AVX2, AVX-512 or BMI2 on the table. This is where CachyOS steps in with a radically different approach.

In production, these optimizations translate into:

• Reduced latency: faster responses for web applications and databases
• Improved throughput: more concurrent requests handled on the same hardware
• Optimized power consumption: fewer CPU cycles to accomplish the same tasks
• Better resource utilization: especially for compute-intensive workloads

To dig deeper into web server optimization, check out our guide on Nginx optimizations in production.

CachyOS: origins and philosophy

CachyOS was born in 2021 out of the observation that most Linux distributions fail to fully exploit modern hardware capabilities. Based on Arch Linux, it preserves the rolling-release philosophy and Arch's legendary flexibility, while adding a layer of aggressive optimizations that fundamentally set it apart.

The CachyOS philosophy rests on three pillars:

1. Performance over compatibility

Unlike mainstream distributions that must support processors 20 years old, CachyOS explicitly targets modern CPUs. The project offers three optimization levels:

• x86-64: compatibility baseline (rarely used)
• x86-64-v3: requires AVX, AVX2, BMI1, BMI2, F16C, FMA, LZCNT, MOVBE, OSXSAVE (post-2015 processors)
• x86-64-v4: adds AVX-512 (Intel 10th-gen and AMD Zen 4+ processors)
• znver4: optimizations specific to AMD Zen 4

The installer automatically detects your microarchitecture and configures the corresponding optimized repositories, delivering roughly 10% in immediate gains with no manual configuration.

2. A highly optimized kernel

The linux-cachyos kernel is not a simple recompile. It integrates:

• Alternative schedulers (BORE, EEVDF, BMQ, RT)
• Performance patchsets (Clear Linux, Graysky's GCC)
• Configuration optimizations (CONFIG_CACHY)
• sched-ext support for user-space schedulers

3. A fully optimized ecosystem

Beyond the kernel, CachyOS recompiles all of its critical packages with:

• LTO (Link Time Optimization): cross-module optimizations
• PGO (Profile-Guided Optimization): optimizations based on real execution profiles
• BOLT: binary layout optimization to reduce cache misses
• AutoFDO + Propeller: automatic profiling and function reordering

This holistic approach ensures that the entire system stack benefits from optimization, not just the kernel.

The technical optimizations in detail

BORE Scheduler: at the heart of responsiveness

The BORE (Burst-Oriented Response Enhancer) scheduler is one of CachyOS's major innovations. Developed specifically to improve system smoothness and responsiveness, BORE is an extension of the Linux kernel's EEVDF scheduler.

The problem BORE solves is simple: "bursty" tasks (which alternate between periods of intense activity and idleness) are penalized by traditional schedulers. Typical examples:

• Web servers handling short, numerous requests
• Interactive applications (terminals, editors)
• Databases with fast transactions
• Parallel compilation processes

BORE identifies these burst patterns and dynamically adjusts priorities to reduce perceived latency. In production, this translates into:

• Fewer micro-stutters under mixed CPU/I/O loads
• Better web server response under variable load
• Improved P99 latency for databases

The scheduler is configurable via sysctl, allowing you to fine-tune its behavior to the workload. For an Nginx web server, check out our Nginx optimization tutorials.

PGO and AutoFDO: data-driven optimizations

Profile-Guided Optimization (PGO) is a technique where the compiler uses real execution data to optimize the code. The process unfolds in three phases:

1. Instrumentation: compiling the code with profiling hooks
2. Profiling: running representative workloads to collect statistics
3. Recompilation: using the profiles to optimize branches, function layout and inlining

AutoFDO (Automatic Feedback-Directed Optimization) automates this process by using hardware performance monitoring (Intel PEBS, AMD IBS) to generate profiles without manual instrumentation.

CachyOS uses PGO and AutoFDO on its critical packages:

• The linux-cachyos-lto kernel (with Propeller profile)
• Compilers (GCC, LLVM/Clang)
• System libraries (glibc, libstdc++)
• Runtimes (Python, Node.js)

Typical PGO gains are 5-15% on CPU-bound applications, with peaks at 30% on certain specific workloads.

LTO: cross-module optimizations

Link Time Optimization (LTO) lets the compiler optimize beyond source-file boundaries. Two variants are available:

• Fat LTO: keeps the full intermediate representation, slower but optimal
• Thin LTO: parallelizable, used by CachyOS for the kernel

CachyOS compiles its kernel with Clang and Thin LTO, delivering:

• Better cross-module inlining
• Global dead-code elimination
• Symbol visibility optimization
• Reduced binary size (5-10%)

To understand the impact of these optimizations in a Docker context, read our article on Docker mistakes in production.

x86-64-v3 and v4: exploiting modern instructions

The x86-64-v3 instruction set introduces critical vector capabilities:

• AVX/AVX2: 256-bit SIMD operations (8 floats or 4 doubles at once)
• FMA (Fused Multiply-Add): accelerates scientific and ML computations
• BMI1/BMI2: optimized bit manipulation (important for crypto and compression)
• LZCNT/POPCNT: fast bit counting

x86-64-v4 adds AVX-512, doubling the vector width to 512 bits. These instructions are exploited automatically by:

• Compute libraries (OpenBLAS, Intel MKL)
• Video codecs (x264, x265, AV1)
• Compression (zstd, brotli)
• Encryption (AES-NI, SHA-NI)

A concrete example: brotli compression is significantly faster with AVX2 instructions than on baseline x86-64.

Benchmarks: CachyOS vs Ubuntu vs Fedora

The Phoronix benchmarks from November 2025 provide concrete data. Tests were run on an AMD EPYC server against vanilla Arch Linux, Ubuntu 24.04.3 LTS and Ubuntu 25.10:

Overall results (75 tests)

• CachyOS vs Ubuntu: +11.6% average performance
• CachyOS vs vanilla Arch: +5% average performance
• CachyOS vs Fedora 43: significant gains on CPU-intensive workloads

Details by workload

Compilation: The BORE kernel improves latency during parallel builds (make -j), with measurable gains compiling complex C++ projects (LLVM, Chromium).

Web server: Community tests with Apache Bench and wrk report throughput and latency improvements under mixed GET/POST loads, though the exact gains vary with configuration.

Databases: Community feedback on PostgreSQL (pgbench) and MySQL (sysbench) reports measurable improvements in transactions per second and reduced latency, particularly on read-heavy workloads.

Compression/decompression: Thanks to its use of AVX2 instructions, zstd and brotli performance is significantly improved compared to baseline x86-64 builds.

Desktop tests: On the Framework Desktop AMD Ryzen AI Max+ 395, CachyOS outperforms Ubuntu 25.10 and Fedora 43 on the majority of gaming and interactive-application benchmarks.

These results confirm that CachyOS's optimizations deliver measurable gains under real-world conditions, not just on synthetic micro-benchmarks.

The server edition: hardening and server-specific optimizations

The most anticipated announcement in the CachyOS ecosystem is the preparation of a dedicated server edition, slated for 2026. This version will specifically target production infrastructure with a focus on:

Security hardening

• Hardened kernel: grsecurity/PaX patchset or a modern equivalent
• SELinux or AppArmor: strict policies by default
• Seccomp-bpf: system call filtering
• Stack protection: -fstack-protector-strong across all packages
• Enhanced ASLR: reinforced memory randomization

Server-specific optimizations

The server kernel will be configured differently from the desktop one:

• Timer frequency: 100Hz or 250Hz (vs 1000Hz desktop) to reduce overhead
• Preemption: voluntary or none to favor throughput
• Huge pages: transparent support enabled by default
• I/O schedulers: mq-deadline or kyber optimized for NVMe
• TCP stack: BBR2 tuning, larger network buffers

Packages pre-optimized for common workloads

• Web: Nginx, Apache compiled with PGO on real profiles
• Databases: PostgreSQL, MySQL/MariaDB, Redis optimized
• Containerization: Docker/Podman with optimized runc
• Reverse proxies: HAProxy, Traefik with LTO

For effective monitoring of these systems, refer to our guide on Linux metrics in production.

Long-term support

Unlike the rolling-release desktop edition, the server edition could adopt:

• Semi-annual or annual release cycles
• Security backports for 2-3 years
• An LTS kernel with the CachyOS patchset
• Easier migration between versions

This approach would compete directly with Ubuntu Server LTS and RHEL/AlmaLinux, with the decisive advantage of measurably superior performance in the Phoronix benchmarks.

Target use cases

• High-performance web servers: high-traffic sites requiring minimal latency
• Transactional databases: where every millisecond counts
• API services: microservices requiring fast responses
• Reverse proxies/load balancers: handling millions of connections
• Scientific computing: AVX-512-intensive workloads

Michael Larabel of Phoronix announced his intention to benchmark the server edition on AMD EPYC and Intel Xeon as soon as it ships, which will provide reference data for production adoption.

Installation and configuration

Hardware requirements

To take full advantage of CachyOS, verify your CPU's support:

# Check the supported x86-64 level
/lib/ld-linux-x86-64.so.2 --help | grep supported

# Or use this script
gcc -march=native -Q --help=target | grep march

Processors supporting x86-64-v3:

• Intel: Haswell (2013) and newer
• AMD: Excavator (2015) and newer (Ryzen, EPYC)

Processors supporting x86-64-v4:

• Intel: Ice Lake, Tiger Lake, Alder Lake, Sapphire Rapids
• AMD: Zen 4 (Ryzen 7000, EPYC Genoa)

Installation via ISO

CachyOS offers a modern graphical installer (based on Calamares):

1. Download the ISO from cachyos.org
2. Create a bootable USB drive: dd if=cachyos.iso of=/dev/sdX bs=4M status=progress
3. Boot and follow the installer
4. Select the kernel scheduler (BORE recommended for general use)
5. Choose your desktop environment (or minimal for servers)

The installer will automatically detect your microarchitecture and configure the optimized repositories. A stable Internet connection is required for online installation.

Migrating from an existing Arch Linux

If you already run an Arch system, you can migrate to the CachyOS repos:

# Add the CachyOS GPG key
pacman-key --recv-keys F3B607488DB35A47 --keyserver keyserver.ubuntu.com
pacman-key --lsign-key F3B607488DB35A47

# Download and install the keyring and mirrorlist
wget https://mirror.cachyos.org/repo/x86_64/cachyos/cachyos-keyring-3-1-any.pkg.tar.zst
wget https://mirror.cachyos.org/repo/x86_64/cachyos/cachyos-mirrorlist-18-1-any.pkg.tar.zst
pacman -U cachyos-keyring-3-1-any.pkg.tar.zst cachyos-mirrorlist-18-1-any.pkg.tar.zst

# Add the repositories to /etc/pacman.conf (before [core])
[cachyos-v3]  # or cachyos-v4 if supported
Include = /etc/pacman.d/cachyos-mirrorlist

[cachyos]
Include = /etc/pacman.d/cachyos-mirrorlist

# Update and install the kernel
pacman -Syyu
pacman -S linux-cachyos linux-cachyos-headers

For a server, prefer linux-cachyos-bore or linux-cachyos-lto depending on your needs.

Post-installation configuration

Selecting the scheduler: CachyOS Kernel Manager lets you switch schedulers without recompiling:

sudo pacman -S cachyos-kernel-manager
cachyos-kernel-manager  # TUI interface

Available schedulers:

• BORE: balances performance and responsiveness (recommended for general use)
• EEVDF: upstream Linux scheduler (baseline)
• RT: real-time for critical workloads
• sched-ext: framework for custom user-space schedulers

sysctl tuning for servers:

# /etc/sysctl.d/99-cachyos-server.conf

# Networking
net.core.rmem_max = 268435456
net.core.wmem_max = 268435456
net.ipv4.tcp_rmem = 4096 87380 134217728
net.ipv4.tcp_wmem = 4096 65536 134217728
net.ipv4.tcp_congestion_control = bbr2

# Memory
vm.swappiness = 10
vm.dirty_ratio = 15
vm.dirty_background_ratio = 5

# Scheduler (adjust to the workload)
kernel.sched_migration_cost_ns = 5000000

Apply: sysctl -p /etc/sysctl.d/99-cachyos-server.conf

For advanced systemd configurations, check out our systemd tutorial.

Performance monitoring

Verify that the optimizations are active:

# Repo optimization level in use
pacman -Qi glibc | grep Architecture

# Active scheduler
cat /sys/kernel/debug/sched/features  # requires debugfs mounted

# Timer frequency
cat /boot/config-$(uname -r) | grep CONFIG_HZ

Simple benchmarks:

# Compression test
time zstd -T0 -19 test_file

# Compilation test
time make -j$(nproc)

# Network test (with iperf3 across two machines)
iperf3 -c server_ip -P 10 -t 60

For comprehensive production monitoring, refer to our 5 essential Linux commands for administration.

Production use cases

High-performance web server

CachyOS excels for web servers requiring low latency and high throughput. A typical Nginx configuration:

# Install Nginx from the CachyOS repos (compiled with PGO)
pacman -S nginx-mainline

# Tune worker_processes based on the BORE scheduler
worker_processes auto;
worker_cpu_affinity auto;

# Exploit the kernel network optimizations
events {
    worker_connections 8192;
    use epoll;
    multi_accept on;
}

Expected gains vs Ubuntu Server: higher requests per second, reduced latency and better CPU efficiency according to community feedback.

PostgreSQL database

PostgreSQL benefits particularly from the optimizations:

pacman -S postgresql

# Tuning postgresql.conf
shared_buffers = 8GB  # 25% RAM
effective_cache_size = 24GB  # 75% RAM
work_mem = 64MB
maintenance_work_mem = 2GB
checkpoint_completion_target = 0.9
wal_buffers = 16MB
max_wal_size = 4GB

Users report measurable improvements in TPS (transactions per second), query latency and maintenance-operation performance on EPYC processors.

Docker/Podman containers

The CachyOS kernel optimizations improve container performance:

pacman -S docker docker-compose

# Enable BBR2 for containers
cat <<EOF > /etc/docker/daemon.json
{
  "default-ulimits": {
    "nofile": {
      "Name": "nofile",
      "Hard": 64000,
      "Soft": 64000
    }
  }
}
EOF

Benefits:

• Faster container startup
• Reduced network overhead
• Better CPU isolation with the BORE scheduler

Avoid common mistakes by reading our article on Docker in production.

Load balancer / Reverse proxy

HAProxy or Traefik on CachyOS deliver excellent performance:

pacman -S haproxy

# Optimal configuration for CachyOS
global
    maxconn 100000
    nbthread 16  # auto-detected by the BORE scheduler
    cpu-map auto:1/1-16 0-15

defaults
    mode http
    timeout connect 5s
    timeout client 50s
    timeout server 50s

Community tests with wrk report improvements in connections per second, P99 latency and CPU efficiency.

Limitations and considerations

Hardware compatibility

CachyOS requires relatively recent hardware to take advantage of x86-64-v3. Servers older than 2015 won't benefit from the main optimizations. Always verify CPU support before migrating.

Community vs enterprise support

Unlike Ubuntu or RHEL, CachyOS does not yet offer commercial support. For critical production environments, this can be a deterrent. The server edition could change the picture in 2026 with professional support.

Rolling release vs stability

Arch's rolling-release nature can introduce regressions. For production servers, recommended strategies include:

• Test updates on a staging environment
• Use pacman -Syu --ignore to hold back critical packages
• Keep LVM/Btrfs snapshots before updates
• Wait for the server edition for LTS support

Maintenance overhead

CachyOS requires more expertise than Ubuntu Server. Admins must be comfortable with:

• Arch Linux and pacman
• Kernel tuning and sysctl parameters
• Low-level troubleshooting
• Compilation and optimizations

Package ecosystem

Although based on Arch (AUR included), some proprietary or enterprise packages may be missing. Verify the availability of your critical tools before migrating.

Alternatives and comparisons

Clear Linux (Intel)

Intel's Clear Linux shares a similar philosophy of aggressive optimization. Key differences:

• CachyOS: Arch-based, AMD/Intel focus, multiple schedulers
• Clear Linux: custom base, optimized for Intel, less flexible

Clear Linux can be slightly faster on recent Intel CPUs, but CachyOS offers more flexibility and better AMD support.

Gentoo with optimizations

Gentoo lets you compile the entire system with optimized flags. Comparison:

• CachyOS: optimizations pre-applied, fast installation
• Gentoo: total control, massive compilation time

CachyOS delivers much of Gentoo's performance gains with considerably less installation and maintenance effort.

Ubuntu with a liquorix/xanmod kernel

You can install an optimized kernel on Ubuntu. Drawbacks:

• Only the kernel is optimized, not all the packages
• No x86-64-v3/v4 on the system libraries
• Limited gains compared to CachyOS's holistic approach

Fedora with tuned

Fedora offers tuned profiles to optimize for the workload. But:

• Runtime optimizations only, no recompilation
• Marginal gains compared to CachyOS
• No alternative schedulers

The future of CachyOS

Server edition 2026

The server edition will be the major turning point for production adoption. Development directions:

• Hardened LTS kernel with the CachyOS patchset
• Commercial support and SLAs
• Certifications (PCI-DSS, HIPAA)
• Automated deployment tools (Ansible, Terraform)
• Cloud images (AWS, GCP, Azure)

Sched-ext and custom schedulers

The sched-ext framework makes it possible to write schedulers in user space (Rust, C). CachyOS could offer specialized schedulers:

• Database scheduler: optimized for PostgreSQL/MySQL
• Web scheduler: minimal latency for Nginx/Apache
• HPC scheduler: maximum throughput for scientific computing

ARM and RISC-V support

With the rise of ARM servers (Graviton, Ampere), CachyOS could extend its optimizations to other architectures. The same principle (modern instructions + PGO/LTO) applies to ARMv8.2+ and RISC-V.

Cloud-native integration

Development of optimized container images:

• Ultra-lightweight Docker/Podman images with x86-64-v3
• Kubernetes support with scheduler awareness
• Native Prometheus/Grafana integration

Benchmarking and automatic tuning tools

The community is working on tools for:

• Automatic workload detection and scheduler recommendations
• Continuous profiling and automated PGO recompilation
• A/B testing of kernel configurations in production

Conclusion

CachyOS represents a refreshing approach in a Linux ecosystem that is often conservative when it comes to performance. By pushing the limits of what a distribution can offer through aggressive optimization of the kernel and the entire system stack, CachyOS demonstrates that substantial performance headroom remains to be exploited on modern hardware.

The benchmarks speak for themselves: 11.6% average gains over Ubuntu, 5% over vanilla Arch, with far higher peaks on certain workloads. For infrastructure handling millions of daily requests, these percentages translate into tangible savings in hardware, energy and user-facing latency.

The server edition planned for 2026 could mark a turning point. If CachyOS manages to combine its exceptional performance with the security hardening and enterprise support needed in production, the distribution could become a credible alternative to the giants Ubuntu Server and RHEL for organizations that prioritize performance.

That said, CachyOS is not a one-size-fits-all solution. The rolling-release nature, the need for deep technical expertise and the current lack of commercial support reserve it for experienced technical teams and environments where performance takes precedence over ease of maintenance.

For system administrators looking to extract the maximum from their servers, CachyOS deserves serious evaluation. Start with non-critical environments, measure the real gains on your specific workloads, and get ready for the server edition that could redefine performance standards in the Linux world.

The CachyOS philosophy is clear: modern hardware is underexploited by traditional distributions. It's time to change that.

Sources:

• CachyOS Linux Kernel Repository
• CachyOS Official Documentation
• Phoronix: CachyOS Performance Benchmarks vs Ubuntu & Fedora
• Dataconomy: CachyOS Server Benchmarks
• CachyOS Optimized Repositories Documentation