NixOS en 2026: por que los developers la estan eligiendo

NixOS te obliga a describir tu sistema en un archivo de texto y a cambio te da upgrades atómicos, rollbacks instantáneos y entornos de desarrollo reproducibles que se pueden clonar entre máquinas con un solo git clone. Te explico qué es, por qué en 2026 se convirtió en la distro favorita de los developers, cómo instalarla sin romper tu laptop y cómo armar tu primer flake.nix con home-manager y direnv sin volverte loco.

—

Qué es NixOS y por qué es distinta a todo lo demás

La mayoría de las distribuciones de Linux te dejan en un dilema: o instalas paquetes uno por uno con apt, dnf o pacman y vas modificando archivos de configuración a mano según tu memoria, o usas Ansible / Chef / Puppet para que un script reproduzca los pasos. NixOS hace algo fundamentalmente distinto: en lugar de ejecutar comandos sobre el sistema, escribís una descripción del sistema que quieres en un archivo de texto (/etc/nixos/configuration.nix o un flake.nix) y Nix la convierte en una generación del sistema que se puede activar, comparar, revertir y compartir como si fuera un commit de Git.

Esto resuelve tres problemas que cualquier developer que trabaja en serio conoce muy bien:

• Reproducibilidad real: si clonas el repositorio de tu flake.nix en una laptop nueva y ejecutas nixos-rebuild switch --flake .#mi-host, obtenés un sistema idéntico al original, hasta la versión exacta de cada librería compartida. No hay “en mi máquina funciona”.
• Upgrades atómicos: cada nixos-rebuild switch construye una nueva generación sin tocar la actual. Si el boot falla, GRUB te ofrece arrancar la generación anterior con un solo click. Si quieres volver a la de hace tres semanas, es un comando: nixos-rebuild switch --rollback.
• Entornos de desarrollo aislados: con nix develop, nix-shell o un flake.nix con devShells puedes tener Python 3.12 con NumPy 1.26 en un proyecto y Python 3.11 con NumPy 2.0 en otro, sin virtualenv, sin Docker, sin pelearte con pyenv.

El precio a pagar es la curva de aprendizaje: el lenguaje Nix no es difícil, pero es raro (no tiene orden de evaluación tradicional, todo es puro, la sintaxis de strings y listas tiene sus trampas) y tienes que cambiar la forma en que pensás sobre tu sistema. Si te suena interesante, seguí leyendo.

—

El estado de NixOS en 2026

A 2026, NixOS ya no es una rareza de early adopters. El proyecto sigue lanzamientos cada seis meses (los nombres de releases son adjetivos en inglés como vicuna, xantusia, wombat), el canal estable tiene aproximadamente 90.000 paquetes en nixpkgs y los flakes, que en 2022 todavía se consideraban experimentales, son la forma recomendada de gestionar configuraciones y shells. La documentación oficial (NixOS Manual) es razonablemente completa y hay una comunidad enorme en el Discourse oficial, en Reddit (r/NixOS) y en el Discord de la comunidad que responde preguntas en minutos.

Lo que realmente cambió en los últimos dos años es el ecosistema alrededor del lenguaje Nix:

• home-manager es estable y ubiquitous. Te permite gestionar tu configuración de usuario (dotfiles, paquetes de usuario, servicios de usuario como tmux o neovim) de la misma forma declarativa que el sistema.
• nix-direnv carga shells de Nix automáticamente cuando entrás a un directorio con un .envrc. Esto cierra la brecha entre “tengo el flake.nix en mi repo” y “tengo todas las herramientas en mi PATH cuando estoy editando código”.
• Determinate Systems comercializó un instalador gráfico y un daemon de Nix para macOS, lo que bajó mucho la barrera para gente que viene de fuera del mundo Linux.
• Flakes ya son el default no oficial: prácticamente cualquier tutorial nuevo arranca con un flake.nix y comandos como nix run, nix build o nix develop en lugar del viejo nix-build + nix-env.

Si venís del mundo apt / dnf / Ansible, te va a llamar la atención que la mayoría de los developers que adoptan NixOS no reemplazan todo de una: empiezan usando nix-shell para tener entornos reproducibles en sus proyectos, después prueban home-manager para los dotfiles y al final terminan adoptando un flake.nix para la configuración del sistema. Esa curva gradual funciona muy bien.

—

Requisitos y cómo elegir entre canales

Antes de instalar, tienes que decidir dos cosas:

• Stable vs Unstable: el canal nixos-25.11 (o el que esté vigente cuando leas esto) congeló los paquetes en una fecha fija y solo recibe parches de seguridad. Es ideal para servidores y laptops de trabajo donde necesitas estabilidad. El canal nixos-unstable se actualiza a diario con las últimas versiones. Es ideal si quieres bleeding edge (Python 3.13 el día que sale, KDE Plasma 6.4 apenas se libera, etc.). El 90% de los developers nuevos arrancan en nixos-unstable y bajan a stable cuando necesitan estabilidad de servidor.
• Flakes sí o no: la respuesta corta en 2026 es sí. Flakes son la única forma limpia de gestionar múltiples máquinas con la misma configuración, fijar versiones exactas de paquetes y compartir entornos entre colaboradores. El flag experimental ya casi no aparece en tutoriales nuevos.

Requisitos mínimos razonables para una laptop de desarrollo:

• CPU x86_64 (cualquier laptop de los últimos 8 años sirve) o Apple Silicon (sí, aarch64-linux está soportado)
• 8 GB de RAM mínimo, 16 GB recomendado si vas a usar home-manager con muchos paquetes de dev
• 50 GB de disco libre (NixOS llena el /nix/store rápido con cada generación, puedes limpiar con nix-collect-garbage -d cuando quieras)
• UEFI (casi todas las laptops de 2014 en adelante)

—

Paso 1: Bajar la ISO y bootearla

NixOS te da una ISO mínima de instalación que se descarga en segundos. La quemás en una USB con balenaEtcher, dd o la herramienta que prefieras, booteás y llegas a un entorno con un prompt de root.

Descargá la ISO desde nixos.org/download. Vas a ver dos columnas: Graphical ISO (con un instalador de escritorio que sirve más para probar) y Minimal ISO (solo consola, ideal para servidores). Si tu objetivo es aprender, bajá la Graphical ISO, prueba el escritorio GNOME o Plasma que viene por defecto y después reinicias con la Minimal cuando te toque instalar de verdad.

# En Linux o macOS, descargar la ISO estable actual
curl -L -o nixos-minimal.iso https://channels.nixos.org/nixos-25.11/latest-nixos-minimal-x86_64-linux.iso
# Verificar la suma SHA-256 (importante, no te saltees este paso)
curl -L -o nixos-minimal.iso.sha256 https://channels.nixos.org/nixos-25.11/latest-nixos-minimal-x86_64-linux.iso.sha256
sha256sum -c nixos-minimal.iso.sha256
# Grabar en una USB (ojo: /dev/sdX es tu USB, no tu disco principal)
sudo dd if=nixos-minimal.iso of=/dev/sdX bs=4M status=progress conv=fsync
sync

El sha256sum -c es importante porque si la ISO se corrompió durante la descarga, el instalador falla a mitad de camino con errores crípticos tipo cannot find stage-1. Mejor enterarte ahora que después de 30 minutos de instalación.

Si quieres una experiencia más cómoda, quickemu o virt-manager te dejan correr la ISO en una VM y probar antes de tocar tu disco. Si vas a usar NixOS como dual boot con Windows o macOS, asegurate de que tu partición EFI esté compartida (NixOS detecta la existente sin problemas).

—

Paso 2: Particionar y formatear

Una vez que booteaste la ISO, llegas a un prompt de root en una consola con nixos-install disponible. El particionado manual da más control que el automático, especialmente si vas a hacer dual boot. El esquema típico para una laptop moderna:

• EFI System Partition (ESP): 512 MB, FAT32, montada en /boot
• Partición raíz: el resto del disco, ext4 (o btrfs si quieres snapshots a nivel de filesystem)
• Swap: una partición o un archivo (NixOS lo configura automáticamente si la declarás en configuration.nix)

# Listar los discos disponibles (ojo con no equivocarte)
lsblk
# Supongamos que tu disco es /dev/sda
# Crear tabla de particiones GPT
sudo parted /dev/sda -- mklabel gpt
# Crear partición EFI (512 MB)
sudo parted /dev/sda -- mkpart ESP fat32 1MiB 513MiB
sudo parted /dev/sda -- set 1 esp on
# Crear partición raíz (el resto)
sudo parted /dev/sda -- mkpart primary ext4 513MiB 100%
# Formatear
sudo mkfs.fat -F 32 -n BOOT /dev/sda1
sudo mkfs.ext4 -L nixos /dev/sda2
# Montar
sudo mount /dev/sda2 /mnt
sudo mkdir -p /mnt/boot
sudo mount /dev/sda1 /mnt/boot

Si tu laptop tiene disco NVMe, los nombres van a ser /dev/nvme0n1p1 y /dev/nvme0n1p2 en lugar de /dev/sda1 y /dev/sda2. Si usas LUKS para cifrado, el particionado es similar pero montás el volumen cifrado en lugar de la partición directa.

Si te equivocaste de disco: lsblk antes de cada parted o mkfs. La línea más cara de tu vida es sudo mkfs.ext4 /dev/sda en lugar de sudo mkfs.ext4 /dev/sda2. Si te pasó, no entres en pánico — la herramienta testdisk recupera tablas de particiones borradas en muchos casos.

—

Paso 3: Generar la primera configuración

Con las particiones montadas en /mnt, generas la configuración inicial con nixos-generate-config. Este comando lee el hardware, detecta que arrancaste en UEFI, configura GRUB automáticamente y deja un /mnt/etc/nixos/configuration.nix que puedes editar antes de instalar.

# Generar configuración inicial basada en tu hardware
sudo nixos-generate-config --root /mnt
# Editar la configuración antes de instalar
sudo nano /mnt/etc/nixos/configuration.nix

El archivo generado tiene cientos de líneas comentadas. Las que vas a tocar son tres:

• boot.loader.systemd-boot.enable = true; si quieres usar systemd-boot en lugar de GRUB. En UEFI, systemd-boot es más simple y rápido.
• networking.hostName = "nixos"; para ponerle un nombre a tu máquina.
• environment.systemPackages para los paquetes de sistema. puedes agregar acá tus herramientas de dev (git, vim, tmux, ripgrep, fd, etc.).

Una configuración mínima decente para empezar:

{ config, pkgs, ... }:
{
  imports = [
    ./hardware-configuration.nix
  ];
  boot.loader.systemd-boot.enable = true;
  boot.loader.efi.canTouchEfiVariables = true;
  networking.hostName = "nixos";
  networking.networkmanager.enable = true;
  time.timeZone = "America/Montreal";
  environment.systemPackages = with pkgs; [
    git
    vim
    tmux
    ripgrep
    fd
    htop
    curl
    wget
  ];
  system.stateVersion = "25.11";
}

El system.stateVersion NO es la versión de NixOS que instalas — es una versión interna que Nix usa para detectar migraciones necesarias. Una vez que lo seteás, no lo cambies salvo que sepas exactamente lo que estás haciendo.

Cuando termines de editar, instalas con nixos-install. Te va a pedir una contraseña para el usuario root. Creá el usuario normal en la misma línea si quieres:

# Instalar usando el configuration.nix que acabás de editar
sudo nixos-install
# Te pide contraseña de root. Ponela.
# Cuando termina, desmonta y reiniciá
sudo umount -R /mnt
sudo reboot

Si tu laptop no bootea después del reboot (pantalla negra o queda colgada en el logo de la BIOS), el problema casi siempre es la combinación UEFI/GRUB. Volvé a la USB, montá las particiones, y verifica que /mnt/boot/EFI/systemd-boot/systemd-bootx64.efi exista. Si no existe, tu boot.loader.systemd-boot.enable = true; no se aplicó — reescribilo y volvé a correr nixos-install.

—

Paso 4: Habilitar flakes

Una vez en tu sistema nuevo, lo primero que quieres hacer es habilitar flakes. Es un flag experimental en 2026, pero es estable en la práctica: lo usa todo el mundo. Sin flakes, tienes que usar los viejos canales de NixOS y comandos como nix-env -i que son más crípticos.

# Habilitar flakes en la configuración del sistema
sudo nano /etc/nixos/configuration.nix
# Agregar estas líneas:
#   nix.settings.experimental-features = [ "nix-command" "flakes" ];
# Guardar, salir y reconstruir
sudo nixos-rebuild switch
# Verificar que flakes funciona
nix --version
# Debería decir 2.18 o superior

El nixos-rebuild switch aplica la nueva configuración y deja la generación anterior como fallback en GRUB. Si algo sale mal, en el próximo boot eliges la generación vieja desde el menú de systemd-boot y vuelves.

—

Paso 5: Tu primer flake.nix

Ahora viene la parte interesante. Un flake.nix es un archivo que describe qué cosas puedes construir desde tu proyecto (un paquete, un sistema completo, un entorno de desarrollo) y de dónde vienen los inputs. El formato más simple tiene tres secciones: description, inputs y outputs.

Ejemplo de un flake.nix básico para tu home:

{
  description = "Mi configuración de NixOS y home-manager";
  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
    home-manager = {
      url = "github:nix-community/home-manager";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };
  outputs = { self, nixpkgs, home-manager, ... }:
    let
      system = "x86_64-linux";
      pkgs = import nixpkgs {
        inherit system;
        config.allowUnfree = true;
      };
    in {
      homeConfigurations."usuario" = home-manager.lib.homeManagerConfiguration {
        inherit pkgs;
        modules = [ ./home.nix ];
      };
    };
}

El archivo home.nix es donde declarás tus dotfiles, paquetes de usuario y servicios. Ejemplo:

{ pkgs, ... }:
{
  home.packages = with pkgs; [
    python312
    nodejs_20
    docker
    kubectl
    terraform
    neovim
  ];
  programs.git = {
    enable = true;
    userName = "Tu Nombre";
    userEmail = "[email protected]";
  };
  programs.zsh = {
    enable = true;
    shellAliases = {
      ll = "ls -l";
      la = "ls -la";
      g = "git";
    };
  };
  home.file.".config/nvim/init.lua".source = ./nvim/init.lua;
}

Para activarlo:

# Asumiendo que flake.nix y home.nix están en ~/.config/nix/
cd ~/.config/nix
# Construir y activar la configuración de home-manager
home-manager switch --flake .#usuario
# Si algo falla, vuelves al estado anterior con:
home-manager generations
# Te lista las generaciones, después:
home-manager rollback

Si te tira error de “experimental-features”: significa que los flakes no están habilitados globalmente. Volvé al paso 4 y verifica que el nix.settings.experimental-features esté bien escrito.

Si te tira “attribute missing”: usualmente es un typo en el nombre del input o en el path de un módulo. Releé el error completo — Nix te dice exactamente qué atributo falta y en qué archivo.

—

Paso 6: Entornos de desarrollo reproducibles con nix develop

Acá es donde los developers realmente ven el valor de Nix. En lugar de documentar en el README “instala Python 3.11, después pip install -r requirements.txt, después node 18, después yarn”, ponés un flake.nix en el repo y cada colaborador obtiene el mismo entorno con un solo comando.

Ejemplo de un flake.nix para un proyecto Python:

{
  description = "Entorno reproducible para mi proyecto Python";
  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
  outputs = { self, nixpkgs }:
    let
      system = "x86_64-linux";
      pkgs = import nixpkgs { inherit system; };
    in {
      devShells."${system}".default = pkgs.mkShell {
        packages = with pkgs; [
          python312
          python312Packages.pip
          python312Packages.virtualenv
          ruff
          mypy
          pytest
          postgresql
        ];
        shellHook = ''
          echo "🐍 Python $(python3 --version) listo"
          export PYTHONDONTWRITEBYTECODE=1
          export PYTHONPATH="$PWD:$PYTHONPATH"
        '';
      };
    };
}

Para usarlo:

# Entrar al shell del proyecto
nix develop
# Verificar que las herramientas están en el PATH
python --version
# Python 3.12.x
which ruff
# /nix/store/...-ruff/bin/ruff
# Salir del shell
exit

Si quieres que se active automáticamente al hacer cd al directorio del proyecto, usas nix-direnv:

# Instalar direnv en NixOS (agregar a configuration.nix)
# environment.systemPackages = [ pkgs.direnv ];
# sudo nixos-rebuild switch
# Instalar nix-direnv como paquete de usuario
nix profile install nixpkgs#nix-direnv
# Agregar direnv al shell de tu usuario (bash)
echo 'eval "$(direnv hook bash)"' >> ~/.bashrc
# En zsh: echo 'eval "$(direnv hook zsh)"' >> ~/.zshrc
# Reiniciar shell o sourcear el rc
source ~/.bashrc
# Crear .envrc en el proyecto
echo "use flake" > .envrc
direnv allow
# A partir de acá, cada vez que hagas cd al directorio, el shell se carga solo

El direnv allow es necesario la primera vez porque direnv no carga archivos .envrc automáticamente por seguridad (te protege de un repo malicioso que te inyecta variables de entorno). Después del primer allow, el directorio queda en la whitelist.

—

Paso 7: Upgrades atómicos y rollback

Una de las features más queridas de NixOS es que cada nixos-rebuild deja el sistema anterior completamente funcional. Si un upgrade te rompe algo, vuelves a la versión vieja con un comando (o con un click en el menú de boot).

# Actualizar el canal y reconstruir el sistema
sudo nix-channel --update
sudo nixos-rebuild switch --upgrade
# Listar todas las generaciones disponibles
sudo nix-env --list-generations --profile /nix/var/nix/profiles/system
# O, más legible:
sudo nixos-rebuild list-generations
# Si el último upgrade rompió algo, rollback instantáneo
sudo nixos-rebuild switch --rollback
# Si quieres volver a una generación específica (ejemplo: la número 42)
sudo nix-env --switch-generation 42 --profile /nix/var/nix/profiles/system
sudo /nix/var/nix/profiles/system/bin/switch-to-configuration switch

El --rollback no borra la generación rota, simplemente le dice a GRUB “booteá la generación N-1”. Si el problema era un servicio que crasheaba, puedes investigar el log con journalctl -b -1 (el -1 significa “boot anterior”) sin perder nada.

Limpieza periódica para no quedarte sin disco:

# Borrar generaciones con más de 14 días y garbage collection
sudo nix-collect-garbage --delete-older-than 14d
# Optimizar el store deduplicando archivos
sudo nix-store --optimise

Si quieres borrar TODO y arrancar de cero con una ISO nueva, nix-collect-garbage -d borra todas las generaciones y deja el /nix/store en su estado mínimo. Útil después de probar mucho y querer liberar espacio.

—

Cuándo NO usar NixOS

NixOS no es para todos los casos. Antes de saltar:

• Si necesitas drivers propietarios específicos: NixOS los soporta (con hardware.enableRedistributableFirmware = true; y similares), pero la configuración es más verbosa que en Ubuntu. Si tu laptop depende de drivers raros para funcionar, prueba primero en una VM.
• Si tu equipo no tolera una curva de aprendizaje: NixOS te obliga a entender cómo funciona tu sistema. Si prefieres “instalar y olvidar”, Ubuntu LTS o Debian siguen siendo opciones más cómodas.
• Si dependés de paquetes fuera de nixpkgs: si tu herramienta crítica no está empaquetada (o solo está en AUR), el costo de mantener un overlay propio es alto.
• Si tu laptop tiene un hardware muy nuevo: a veces el kernel de NixOS stable va un par de versiones atrás del último release de upstream, y periféricos nuevos (webcams, lectores de huellas, GPUs recientes) pueden no funcionar hasta el próximo release. verifica en el Discourse oficial antes de comprar una laptop pensando en NixOS.

Para un developer que ya está cómodo con la terminal, que mantiene varios proyectos en paralelo y que odia el clásico “funciona en mi máquina”, NixOS es probablemente la mejor distribución disponible en 2026. Para un usuario que quiere una laptop que simplemente funcione, hay opciones más simples.

—

Resumen y siguientes pasos

NixOS te da tres superpoderes que ninguna otra distribución tiene juntos:

1. Reproducibilidad real: nixos-rebuild switch --flake .#mi-host en cualquier máquina produce un sistema idéntico.
2. Upgrades atómicos: si rompe, vuelves a la generación anterior con un comando o un click en GRUB.
3. Entornos aislados: nix develop te da Python 3.12 + Node 20 + Postgres 16 en un proyecto y versiones distintas en otro sin pelearte con Docker.

Tu primer paso hoy: arrancar la ISO en una VM con quickemu o virt-manager, instalar siguiendo los pasos 2 y 3 de esta guía, y después armar un flake.nix mínimo en ~/.config/nix/. Cuando te sientas cómodo, movés tu configuración a un repo de Git privado y empezás a versionarla como cualquier otro código.

Si quieres profundizar en algún tema específico, hay recursos excelentes en español y en inglés:

• NixOS Manual oficial: la referencia completa, actualizada con cada release.
• NixOS & Flakes Book: guía opinionada y moderna, ideal para developers.
• NixOS Discourse: el foro oficial, donde la mayoría de preguntas obtienen respuesta en horas.
• r/NixOS en Reddit: comunidad grande y activa, especialmente buena para troubleshooting.

Lee también: Distribuciones Linux inmutables en 2026: el estado actual del ecosistema para ver cómo se compara NixOS con Fedora Silverblue, Bazzite y Universal Blue, y ¿Qué es Linux y por qué sigue siendo relevante en 2026? si necesitas un repaso del ecosistema.

---

Preguntas frecuentes

Lee también

• Guía Fedora 44: Novedades, Instalación y Upgrade para Sysadmins Linux
• Configura VLANs en Linux con nmcli: Guía paso a paso para sysadmins
• Protege tu SSH: Guía esencial para configurar Fail2ban en Linux
• Guía Definitiva: Configura Kubernetes con kubeadm en Ubuntu para Sysadmins Linux
• Configura Prometheus y Grafana: Guía DevOps para SysAdmins Linux