Nix : comprendre l'écosystème et savoir quand l'utiliser

Vous avez déjà cassé un environnement en mettant à jour un paquet, ou passé des heures à reproduire la configuration d’un collègue ? Nix est un gestionnaire de paquets qui élimine ces problèmes à la racine. Chaque paquet est isolé, versionné et reproductible — deux machines configurées de la même façon obtiennent exactement le même résultat.

Ce guide pose les bases : vous comprendrez ce que Nix apporte par rapport aux gestionnaires classiques, comment les différentes briques de l’écosystème s’articulent, et dans quels cas concrets l’adopter.

Ce que vous allez apprendre

Positionner Nix dans le paysage des gestionnaires de paquets Linux
Identifier les trois facettes de Nix : gestionnaire, langage et philosophie
Comprendre les concepts clés : store, hash, profils, générations
Comparer Nix à apt, dnf, Homebrew, asdf, mise et Docker
Décider quand adopter Nix — et quand ce n’est pas le bon choix

Dans quel contexte ?

Nix répond à des problèmes que tout administrateur ou développeur rencontre tôt ou tard :

Vous administrez des serveurs et une mise à jour de bibliothèque casse un service en production — impossible de revenir en arrière avec apt.
Votre équipe partage un projet, mais chacun a des versions différentes de Python, Node.js ou Terraform — le fameux « ça marche sur ma machine ».
Vous testez un outil pour 5 minutes et vous ne voulez pas l’installer définitivement sur votre système.
Vous préparez un pipeline CI/CD et vous avez besoin d’un environnement identique entre votre poste, le serveur de build et la production.
Vous gérez plusieurs projets qui dépendent de versions incompatibles d’une même bibliothèque (le dependency hell).

Si l’un de ces scénarios vous parle, Nix a probablement quelque chose à vous apporter.

Ce que Nix résout concrètement

Le problème : des systèmes fragiles et non reproductibles

Les gestionnaires de paquets traditionnels — apt, dnf, pacman — partagent un même modèle : les paquets s’installent dans des répertoires communs (/usr/bin, /usr/lib). Ce modèle présente trois faiblesses structurelles.

Les conflits de dépendances. Quand deux logiciels ont besoin de versions différentes d’une même bibliothèque, le système ne peut en garder qu’une seule. L’installation de l’un casse l’autre.

L’absence de retour arrière fiable. apt upgrade modifie des fichiers en place. Si la mise à jour casse quelque chose, il n’y a pas de bouton “annuler” qui restaure l’état précédent.

La non-reproductibilité. Deux machines installées “à peu près pareil” divergent au fil du temps : mises à jour faites à des dates différentes, paquets ajoutés manuellement, PPA ou dépôts tiers… L’état final est imprévisible.

La réponse de Nix : isolation, immutabilité, reproductibilité

Nix adopte une architecture radicalement différente. Chaque paquet est stocké dans son propre répertoire, identifié par un hash unique :

/nix/store/aaaa1111...-python-3.12.0/
/nix/store/bbbb2222...-python-3.10.0/
/nix/store/cccc3333...-openssl-3.0.0/
/nix/store/dddd4444...-openssl-1.1.1/

Deux versions de Python coexistent sans conflit. Chaque paquet embarque ses propres dépendances. Rien n’est partagé, rien ne peut être écrasé par une mise à jour.

Nix comme gestionnaire de paquets

C’est la première facette de Nix et la plus immédiatement utile. Nix peut s’installer sur n’importe quelle distribution Linux et sur macOS, en coexistant avec le gestionnaire de paquets natif.

Ce que Nix fait différemment

Fonctionnalité	apt / dnf	Nix
Coexistence de versions	Non — une seule version par paquet	Oui — autant de versions que nécessaire
Retour arrière	Pas de mécanisme natif	Rollback instantané par génération
Installation temporaire	Non	Oui — `nix shell` charge un outil sans l’installer
Reproductibilité	Dépend de la date et des dépôts	Identique à l’octet près grâce au hash
Impact sur le système	Modifie `/usr/lib`, `/usr/bin`	Ne touche que `/nix/store`

Plus de 100 000 paquets

Le dépôt nixpkgs (prononcé “nix-packages”) est l’un des plus grands dépôts de logiciels au monde. Il contient plus de 100 000 paquets, régulièrement mis à jour par une communauté active.

Nix comme langage de programmation

La deuxième facette de Nix est moins visible mais fondamentale : Nix possède son propre langage de programmation fonctionnel qui sert à décrire comment construire et configurer les paquets.

Vous n’avez pas besoin de maîtriser le langage pour utiliser Nix au quotidien. Mais dès que vous voudrez créer vos propres environnements de développement ou comprendre comment un paquet est construit, le langage devient indispensable.

Ce que le langage Nix permet

Décrire un environnement de développement dans un fichier shell.nix : Python 3.12 + requests + Flask + un linter, le tout reproductible.
Définir un paquet : ses sources, ses dépendances, ses options de compilation, dans une expression Nix.
Factoriser et modulariser : importer des fichiers, créer des fonctions réutilisables, composer des configurations.

Un paradigme déclaratif

Avec les gestionnaires classiques, vous donnez des instructions (paradigme impératif) :

# Impératif : "fais ceci, puis ceci"
apt install python3
pip install requests flask

L’état final dépend de l’ordre des commandes, de ce qui était déjà installé, et de la date de la dernière mise à jour du système.

Avec Nix, vous décrivez l’état souhaité (paradigme déclaratif) :

# Déclaratif : "voici ce que je veux"
{ pkgs ? import <nixpkgs> {} }:

pkgs.mkShell {
  packages = [
    pkgs.python312
    pkgs.python312Packages.requests
    pkgs.python312Packages.flask
  ];
}

Nix calcule comment atteindre cet état. Deux machines évaluant cette expression obtiennent exactement le même environnement.

Nix comme philosophie : les trois piliers

Au-delà du gestionnaire et du langage, Nix incarne une philosophie de gestion du logiciel fondée sur trois piliers.

Pilier 1 — Reproductibilité

Tout dans Nix est déterministe. Le hash de chaque paquet est calculé à partir de l’ensemble de ses entrées : code source, dépendances, options de compilation, compilateur.

Hash = f(sources + dépendances + options + compilateur)

Si les entrées sont identiques, le résultat est identique — octet pour octet. C’est ce qui permet à deux machines indépendantes de produire le même environnement sans aucune coordination.

Pilier 2 — Isolation

Chaque paquet vit dans son propre répertoire sous /nix/store/. Il ne partage rien avec les autres paquets. Il ne modifie aucun répertoire système comme /usr/lib. Cette isolation élimine les conflits de dépendances par conception.

Pilier 3 — Atomicité et rollback

Chaque opération crée une nouvelle génération (un instantané de votre profil). L’ancien état reste intact. Si quelque chose ne va pas, un rollback restaure l’état précédent en une commande. Il n’y a pas d’état intermédiaire corrompu.

L’écosystème autour de Nix

Nix est le socle sur lequel s’appuient plusieurs projets complémentaires.

Projet	Rôle	Rapport avec Nix
Nix	Gestionnaire de paquets + langage	Le noyau de l’écosystème
nixpkgs	Dépôt de 100 000+ paquets	La bibliothèque de référence
NixOS	Distribution Linux déclarative	Système complet piloté par Nix
Home Manager	Gestion déclarative des dotfiles	Configure le home avec Nix
Flakes	Système de dépendances + lock file	Reproductibilité renforcée
Cachix	Cache binaire partagé	Accélère les builds en CI/CD

Nix vs NixOS : ne pas confondre

Nix (le gestionnaire de paquets) s’installe sur n’importe quelle distribution Linux ou macOS. Vous gardez votre système actuel — Debian, Ubuntu, Fedora — et vous ajoutez Nix par-dessus.

NixOS est une distribution Linux complète où tout le système est configuré par des expressions Nix : noyau, services, réseau, utilisateurs. C’est un engagement beaucoup plus fort.

Les flakes en un mot

Les flakes sont une évolution majeure de l’écosystème Nix. Ils ajoutent un fichier flake.lock qui fige les versions exactes de toutes les dépendances (comme package-lock.json en JavaScript ou Cargo.lock en Rust).

Concrètement, les flakes résolvent le problème des channels classiques : au lieu de dépendre d’une branche nixpkgs qui évolue dans le temps, vous référencez un commit précis, verrouillé dans le lock file.

Nous les couvrons en détail dans le guide Comprendre et utiliser les flakes.

Comparer Nix avec les outils existants

Nix vs apt / dnf

Critère	apt / dnf	Nix
Portée	Paquets système uniquement	Système + langages + outils
Versions	Une seule version installable	Multiples versions côte à côte
Rollback	Non	Oui, par génération
Déclaratif	Non (sauf Ansible/Puppet au-dessus)	Nativement
Courbe d’apprentissage	Faible	Moyenne à élevée

Nix vs Homebrew

Homebrew est simple et populaire sur macOS. Nix est plus puissant mais plus complexe. Homebrew installe dans /opt/homebrew/ (ou /home/linuxbrew/) avec un modèle classique — pas d’isolation ni de rollback.

Nix vs asdf / mise

asdf et mise gèrent des versions d’outils de développement (Node.js, Python, Terraform…). Nix va plus loin : il gère aussi les bibliothèques système, les dépendances C, et permet de décrire des environnements complets.

Si vous avez juste besoin de basculer entre Node 18 et Node 20, asdf ou mise suffisent. Si vous avez besoin d’un environnement reproductible avec des dépendances système, Nix est le bon choix.

Nix vs Docker

Docker isole au niveau du conteneur (processus, filesystem, réseau). Nix isole au niveau du paquet (dans le store). Les deux sont complémentaires :

Docker : isolation runtime, déploiement, orchestration
Nix : isolation de build, reproductibilité des dépendances, environnements de développement

Nix peut d’ailleurs construire des images Docker minimalistes sans avoir besoin de Docker pendant le build.

Quand adopter Nix — et quand ne pas le faire

Nix est un bon choix si

Vous gérez des environnements de développement partagés entre plusieurs personnes et vous voulez garantir qu’ils sont identiques.
Vous avez besoin de plusieurs versions d’un même outil côte à côte.
Vous voulez pouvoir revenir à un état précédent après une mise à jour qui casse quelque chose.
Vous construisez des pipelines CI/CD et vous avez besoin de reproductibilité.
Vous êtes curieux et prêt à investir du temps pour un outil durable.

Nix n’est probablement pas nécessaire si

Vous administrez un serveur simple avec apt et vous n’avez jamais eu de problème de reproductibilité.
Vous cherchez un outil “plug-and-play” sans courbe d’apprentissage.
Votre équipe n’a pas le temps d’apprendre un nouveau paradigme.
Vous n’utilisez que des conteneurs Docker pour isoler vos environnements et cela vous suffit.

Glossaire des termes Nix

Terme	Définition
Store	Le répertoire `/nix/store/` où Nix stocke tous les paquets, chacun dans un dossier identifié par un hash unique
Hash	Empreinte calculée à partir des sources et dépendances — garantit l’unicité et la reproductibilité
Profil	Ensemble de liens symboliques pointant vers les paquets que vous utilisez — c’est votre “vue” sur le store
Génération	Instantané numéroté de votre profil après chaque modification — permet le rollback
Channel	Branche du dépôt nixpkgs (méthode classique de gestion des sources de paquets)
Nixpkgs	Le dépôt communautaire principal, contenant plus de 100 000 définitions de paquets
Flake	Unité de projet Nix avec un `flake.lock` qui fige les dépendances (remplace progressivement les channels)
Dérivation	La recette de construction d’un paquet dans le langage Nix
NixOS	Distribution Linux complète où le système entier est configuré par des expressions Nix
Home Manager	Outil qui gère la configuration utilisateur (dotfiles, shell, applications) de façon déclarative via Nix

À retenir

Nix est trois choses : un gestionnaire de paquets, un langage fonctionnel, et une philosophie basée sur la reproductibilité.
Chaque paquet est isolé dans /nix/store/ avec un hash unique — pas de conflit de dépendances possible.
Le rollback est natif : chaque modification crée une génération, et on peut revenir en arrière instantanément.
Nix coexiste avec votre distribution : il s’installe sur Debian, Ubuntu, Fedora ou macOS sans rien casser.
nixpkgs contient plus de 100 000 paquets et constitue l’un des plus grands dépôts logiciels au monde.
La courbe d’apprentissage est réelle : comptez quelques jours pour être à l’aise, quelques semaines pour le langage et les flakes.

Prochaines étapes

Installer Nix sur Linux Installez Nix en mode single-user ou multi-user sur votre distribution.

Comprendre le store, les profils et les générations Explorez le fonctionnement interne de Nix : store, hash, profils et rollback.

Utiliser les commandes modernes de Nix Recherchez, installez et gérez vos paquets avec nix shell, nix profile et nix run.

Section NixOS Découvrez NixOS, la distribution Linux entièrement déclarative basée sur Nix.