CachyOS: Linux optimizado para desarrolladores modernos

Hay una diferencia entre un coche de producción y uno preparado para circuito. Ambos tienen el mismo motor base, las mismas ruedas, el mismo volante. Pero el de circuito tiene la suspensión ajustada para la pista específica donde va a correr, el software de gestión optimizado para extraer cada caballo de fuerza, y las piezas innecesarias para la calle removidas para reducir peso. No es más complicado. Es más preciso.

CachyOS es eso aplicado a Linux. Toma la base de Arch Linux — que ya es una de las distribuciones más limpias y actualizadas disponibles — y le aplica un conjunto de optimizaciones específicas al kernel, al scheduler, al sistema de paquetes y a las librerías del sistema. El resultado no es una distribución diferente. Es la misma distribución corriendo con mayor eficiencia sobre el hardware moderno.

Para un desarrollador que pasa ocho horas al día compilando código, corriendo contenedores, y cambiando de contexto entre veinte herramientas distintas, esa diferencia se acumula y se siente.

Qué hace diferente a CachyOS a nivel técnico

La mayoría de las distribuciones Linux usan el kernel mainline de Linus Torvalds con mínimas modificaciones. CachyOS incluye su propio kernel parchado con varias tecnologías que no han llegado al mainline, o que están desactivadas por defecto por razones de compatibilidad general.

El scheduler BORE

El scheduler del kernel es el componente que decide qué proceso corre en qué CPU y por cuánto tiempo. El scheduler CFS (Completely Fair Scheduler) es el que usa el kernel mainline desde 2007 — funciona bien para cargas de trabajo general, pero no está optimizado para los patrones de uso de un sistema de escritorio moderno, donde una aplicación interactiva (tu editor, tu navegador) necesita respuesta inmediata, mientras un proceso en background (una compilación, un contenedor) puede esperar.

BORE (Burst-Oriented Response Enhancer) es un parche sobre el scheduler que modifica cómo se calcula la prioridad de los procesos. Favorece los procesos interactivos — los que hacen trabajo corto y frecuente, como responder a input del usuario — sobre los procesos que hacen trabajo largo y continuo. El resultado es que tu editor responde más rápido mientras una compilación pesada corre en paralelo.

A partir del kernel 6.6, Linux adoptó EEVDF (Earliest Eligible Virtual Deadline First) como reemplazo de CFS. CachyOS soporta ambos y aplica optimizaciones adicionales sobre EEVDF en su kernel más reciente.

Compilación con optimizaciones específicas por arquitectura

Los paquetes de la mayoría de las distribuciones se compilan para x86-64-v1 — la baseline más antigua de la arquitectura x86-64, para garantizar compatibilidad con el hardware más antiguo posible. CachyOS ofrece paquetes compilados para x86-64-v3 y x86-64-v4, que aprovechan instrucciones SIMD más modernas (AVX2, AVX-512) disponibles en procesadores Intel y AMD de los últimos años.

Para operaciones que procesan grandes volúmenes de datos — compilaciones de código, operaciones con imágenes de contenedor, procesamiento de archivos — la diferencia puede ser medible. No es dramática en cada operación individual, pero en un día de trabajo con cientos de operaciones de ese tipo, el efecto es acumulativo.

Para saber qué nivel soporta tu CPU:

# Verificar nivel de soporte x86-64 de tu CPU
/lib/ld-linux-x86-64.so.2 --help | grep -oP "x86-64-v\d+"

# Alternativa directa con grep sobre /proc/cpuinfo
grep -oP "avx2|avx512f" /proc/cpuinfo | sort -u

Si ves avx2, puedes usar los paquetes x86-64-v3. Si ves avx512f, puedes usar v4.

zRAM activado por defecto

zRAM crea un dispositivo de swap comprimido en RAM. En lugar de hacer swap a disco cuando la memoria está bajo presión, el kernel comprime páginas de memoria y las guarda en una porción de la propia RAM. La descompresión es mucho más rápida que leer de disco, y la compresión reduce la presión efectiva sobre la memoria disponible.

CachyOS configura zRAM automáticamente al instalar. Para un desarrollador que corre Docker, un editor pesado, un navegador con veinte tabs y un servidor de desarrollo simultáneamente, zRAM marca una diferencia real en la estabilidad del sistema bajo carga.

# Verificar que zRAM está activo
zramctl

# Salida esperada:
# NAME       ALGORITHM DISKSIZE DATA COMPR TOTAL STREAMS MOUNTPOINT
# /dev/zram0 lz4           7.8G   0B    0B    0B      16 [SWAP]

Instalación

CachyOS ofrece dos rutas de instalación: el instalador gráfico Calamares para usuarios que prefieren una experiencia guiada, y el instalador CLI para quienes prefieren control total. Ambos están disponibles desde la ISO de instalación.

La ISO se descarga desde el sitio oficial de CachyOS. El proceso de crear un USB booteable es el mismo que cualquier otra distribución Linux:

# Crear USB booteable desde Linux (reemplaza /dev/sdX con tu dispositivo)
# PRECAUCIÓN: esto borra todo lo que hay en el dispositivo destino
dd if=cachyos-desktop-linux-YYYYMM.iso of=/dev/sdX bs=4M status=progress oflag=sync

Durante la instalación, el instalador te pedirá elegir el perfil del kernel. Las opciones principales son:

linux-cachyos: el kernel principal de CachyOS con todos los parches aplicados. Primera opción para uso general.
linux-cachyos-bore: kernel con scheduler BORE. Recomendado si haces trabajo interactivo intensivo.
linux-cachyos-lts: basado en el kernel LTS de Linux, más conservador. Para quienes priorizan estabilidad sobre las últimas optimizaciones.

Para la mayoría de los desarrolladores, linux-cachyos o linux-cachyos-bore son la elección correcta.

Configuración inicial para desarrollo

Una vez instalado, CachyOS incluye pacman (el gestor de paquetes de Arch) y el helper paru o yay para acceder al AUR (Arch User Repository) — el repositorio comunitario de Arch que tiene prácticamente todo el software que existe para Linux.

El primer paso es sincronizar la base de datos de paquetes y actualizar el sistema:

# Sincronizar y actualizar todo el sistema
sudo pacman -Syu

# Instalar paru si no está disponible (helper para AUR)
sudo pacman -S paru

Instalar el stack de desarrollo

A diferencia de Ubuntu o Fedora, en Arch/CachyOS no existen meta-paquetes como build-essential. Instalas exactamente lo que necesitas:

# Herramientas de compilación base
sudo pacman -S base-devel git

# Go
sudo pacman -S go

# Node.js y gestores de paquetes
sudo pacman -S nodejs npm
# bun (desde AUR, más rápido que npm para la mayoría de proyectos)
paru -S bun-bin

# Docker
sudo pacman -S docker docker-compose
sudo systemctl enable --now docker
sudo usermod -aG docker $USER  # para usar docker sin sudo (requiere nuevo login)

# Rust (con rustup para gestionar versiones)
sudo pacman -S rustup
rustup toolchain install stable

# Python con uv (gestor moderno, mucho más rápido que pip)
sudo pacman -S python
paru -S uv

El AUR es uno de los activos más valiosos de CachyOS por ser Arch-based. Herramientas que en Ubuntu requieren agregar PPAs manualmente, compilar desde source, o usar Snap/Flatpak, en Arch están disponibles con un solo comando:

# Herramientas de desarrollo disponibles en AUR
paru -S \
  visual-studio-code-bin \  # VS Code oficial
  google-chrome \           # Chrome
  insomnia-bin \            # cliente REST/GraphQL
  dbeaver \                 # cliente de base de datos
  postman-bin \             # Postman
  teleport-bin \            # acceso a infraestructura remota
  infracost                 # estimación de costos de Terraform

Shell y terminal

CachyOS incluye fish o zsh dependiendo del perfil de instalación. Para desarrollo, una configuración productiva de la terminal es tan importante como el IDE.

fish es una buena elección por su autocompletado inteligente y su configuración mínima. Si prefieres zsh, starship es el prompt que mejor funciona con cualquier shell:

# Instalar starship (prompt minimalista y rápido)
sudo pacman -S starship

# Agregar al final de ~/.config/fish/config.fish
starship init fish | source

# O para ~/.zshrc
eval "$(starship init zsh)"

Una configuración de starship.toml orientada a desarrollo muestra el directorio, la rama de git, el estado del repositorio, la versión del lenguaje activo y el contexto de Kubernetes si estás trabajando con él:

# ~/.config/starship.toml
format = """
$directory$git_branch$git_status$golang$nodejs$rust$python$kubernetes$line_break$character"""

[directory]
truncation_length = 3
truncate_to_repo = true

[git_branch]
symbol = " "
format = "[$symbol$branch]($style) "

[git_status]
format = "[$all_status$ahead_behind]($style) "
conflicted = "⚡"
modified = "M"
staged = "S"
untracked = "?"

[golang]
format = "[go $version]($style) "

[nodejs]
format = "[node $version]($style) "

[kubernetes]
disabled = false
format = "[k8s $context]($style) "

Optimizaciones específicas para flujos de desarrollo

Compilaciones más rápidas

El tiempo de compilación es uno de los costos ocultos más grandes en desarrollo. En Go, Rust o proyectos de TypeScript grandes, cada compilación puede tomar segundos o minutos. CachyOS no puede hacer el compilador más rápido, pero sí puede asegurarse de que el sistema no sea el cuello de botella.

El scheduler BORE ayuda aquí específicamente: cuando corriendo cargo build o go build en background, el sistema sigue respondiendo. Pero también hay configuraciones adicionales que ayudan.

ccache guarda los resultados de compilación de C/C++ para reutilizarlos cuando el código fuente no cambió. Es especialmente útil cuando compilas dependencias nativas o software desde el AUR frecuentemente:

sudo pacman -S ccache

# Configurar en ~/.bashrc o ~/.config/fish/config.fish
export CC="ccache gcc"
export CXX="ccache g++"
export CCACHE_DIR="$HOME/.cache/ccache"
export CCACHE_MAXSIZE="10G"

Para proyectos Go, el cache del módulo y del compilador ya están bien manejados por la toolchain, pero puedes asegurarte de que estén en un filesystem rápido:

# Verificar que GOPATH y GOCACHE están en el SSD principal
go env GOPATH GOCACHE

# Si quieres moverlos a un directorio específico
export GOPATH="$HOME/go"
export GOCACHE="$HOME/.cache/go-build"

Docker sin overhead innecesario

CachyOS incluye el kernel preparado para Docker y containerd. Hay dos ajustes que mejoran la experiencia con contenedores en desarrollo:

El primero es usar el driver overlay2 para almacenamiento de layers — ya es el default en sistemas modernos, pero vale verificar:

docker info | grep "Storage Driver"
# Debe mostrar: Storage Driver: overlay2

El segundo es configurar buildkit por defecto para que todos los builds de Docker aprovechen el cache paralelo y los --mount=type=cache:

# En ~/.config/fish/config.fish o ~/.bashrc
export DOCKER_BUILDKIT=1
export COMPOSE_DOCKER_CLI_BUILD=1

Para proyectos que hacen builds frecuentes, mover el directorio de datos de Docker a un SSD NVMe dedicado (si tienes más de uno) puede reducir el tiempo de build significativamente, ya que Docker es intensivo en I/O de disco.

Gestión de memoria bajo carga

CachyOS configura vm.swappiness en un valor más bajo que el default de Linux (60). Esto le dice al kernel que prefiera mantener datos en RAM antes de usar swap, lo que reduce la latencia en operaciones de escritorio. El valor recomendado con zRAM configurado es 100 (paradójicamente alto, pero con zRAM esto favorece el uso del swap comprimido en RAM antes que liberar cache del filesystem):

# Ver configuración actual
cat /proc/sys/vm/swappiness

# El valor recomendado con zRAM
sudo sysctl vm.swappiness=100

# Para hacerlo permanente
echo "vm.swappiness=100" | sudo tee /etc/sysctl.d/99-cachyos.conf

vm.vfs_cache_pressure controla cuánto agresivamente el kernel libera inodes y dentry del cache. Reducirlo hace que el sistema mantenga más metadata de filesystem en memoria, lo que acelera operaciones como find, ls en directorios grandes, y la resolución de paths en compilaciones:

echo "vm.vfs_cache_pressure=50" | sudo tee -a /etc/sysctl.d/99-cachyos.conf
sudo sysctl --system

CachyOS Helper: gestión del sistema integrada

CachyOS incluye cachyos-hello, una herramienta gráfica que centraliza tareas comunes de mantenimiento. Desde ahí puedes actualizar el sistema completo, cambiar el perfil del kernel, gestionar los repositorios de CachyOS y acceder a documentación.

Para mantenimiento desde terminal, el flujo habitual es:

# Actualización completa del sistema (pacman + AUR)
paru -Syu

# Limpiar cache de paquetes (mantener las 2 versiones más recientes)
sudo paccache -rk2

# Limpiar cache de paru
paru -Sc

# Ver paquetes huérfanos (dependencias que ya no son necesarias)
pacman -Qtdq

# Eliminar huérfanos
sudo pacman -Rns $(pacman -Qtdq)

La actualización frecuente es más importante en Arch-based que en distribuciones de release estable. Arch es rolling release — los paquetes se actualizan continuamente y no hay versiones puntuales. Actualizar cada semana es una práctica razonable. Esperar meses puede crear conflictos de dependencias difíciles de resolver.

Por qué esto importa para el trabajo diario

El argumento de rendimiento de CachyOS no es “tu código compilará el doble de rápido”. Es más sutil: el sistema interfiere menos con tu trabajo.

Cuando un build pesado no congela el editor. Cuando cambiar de rama en un repositorio grande responde de inmediato. Cuando Docker levanta los contenedores sin que el escritorio se vuelva inusable durante 30 segundos. Cuando puedes tener el servidor de desarrollo, el debugger, el cliente de base de datos y el navegador abiertos sin que el sistema empiece a hacer swap agresivo.

Esas fricciones pequeñas, multiplicadas por ocho horas al día y doscientos días al año, son horas de concentración perdida y contexto interrumpido. No son dramáticas individualmente. Son cortes de papel.

CachyOS no soluciona problemas de arquitectura ni hace que tu código sea mejor. Pero sí hace que el entorno en el que escribes ese código sea más rápido, más predecible y menos interferente. Para alguien que ya eligió Linux como plataforma de desarrollo, es el siguiente paso natural.

El mejor entorno de desarrollo no es el más poderoso. Es el que desaparece — el que se quita del camino y te deja pensar en el problema que importa.