migrate to flake-parts

flake.lock

···
         "type": "github"
       }
     },
+    "flake-parts": {
+      "inputs": {
+        "nixpkgs-lib": "nixpkgs-lib"
+      },
+      "locked": {
+        "lastModified": 1765835352,
+        "narHash": "sha256-XswHlK/Qtjasvhd1nOa1e8MgZ8GS//jBoTqWtrS1Giw=",
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "rev": "a34fae9c08a15ad73f295041fec82323541400a9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "type": "github"
+      }
+    },
     "flake-utils": {
       "inputs": {
         "systems": "systems"
···
     },
     "flake-utils_3": {
       "inputs": {
-        "systems": "systems_4"
+        "systems": "systems_3"
       },
       "locked": {
         "lastModified": 1731533236,
···
         "type": "github"
       }
     },
+    "nixpkgs-lib": {
+      "locked": {
+        "lastModified": 1765674936,
+        "narHash": "sha256-k00uTP4JNfmejrCLJOwdObYC9jHRrr/5M/a/8L2EIdo=",
+        "owner": "nix-community",
+        "repo": "nixpkgs.lib",
+        "rev": "2075416fcb47225d9b68ac469a5c4801a9c4dd85",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "nixpkgs.lib",
+        "type": "github"
+      }
+    },
     "nixpkgs-stable": {
       "locked": {
         "lastModified": 1766736597,
···
     },
     "nixpkgs_3": {
       "locked": {
-        "lastModified": 1759381078,
-        "narHash": "sha256-gTrEEp5gEspIcCOx9PD8kMaF1iEmfBcTbO0Jag2QhQs=",
+        "lastModified": 1766902085,
+        "narHash": "sha256-coBu0ONtFzlwwVBzmjacUQwj3G+lybcZ1oeNSQkgC0M=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "7df7ff7d8e00218376575f0acdcc5d66741351ee",
+        "rev": "c0b0e0fddf73fd517c3471e546c0df87a42d53f4",
         "type": "github"
       },
       "original": {
···
         "type": "github"
       }
     },
-    "nixpkgs_8": {
-      "locked": {
-        "lastModified": 1765934234,
-        "narHash": "sha256-pJjWUzNnjbIAMIc5gRFUuKCDQ9S1cuh3b2hKgA7Mc4A=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "af84f9d270d404c17699522fab95bbf928a2d92f",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixpkgs-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
     "pre-commit": {
       "inputs": {
         "flake-compat": "flake-compat_2",
···
     "root": {
       "inputs": {
         "catppuccin": "catppuccin",
+        "flake-parts": "flake-parts",
         "ghostty": "ghostty",
         "helix": "helix",
         "home-manager": "home-manager_2",
···
         "sops-nix": "sops-nix",
         "ssh-keys": "ssh-keys",
         "starship-jj": "starship-jj",
-        "systems": "systems_3",
         "topiary-nushell": "topiary-nushell",
         "tree-sitter-nu": "tree-sitter-nu",
         "zjstatus": "zjstatus"
···
         "type": "github"
       }
     },
-    "systems_4": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
-    },
     "topiary-nushell": {
       "flake": false,
       "locked": {
···
       "inputs": {
         "crane": "crane_2",
         "flake-utils": "flake-utils_3",
-        "nixpkgs": "nixpkgs_8",
+        "nixpkgs": [
+          "nixpkgs"
+        ],
         "rust-overlay": "rust-overlay_3"
       },
       "locked": {

flake.nix

···
       inputs.nixpkgs.follows = "nixpkgs";
     };
     nixos-wsl.url = "github:nix-community/NixOS-WSL/main";
-    systems.url = "github:nix-systems/default";
     catppuccin = {
       url = "github:catppuccin/nix";
     };
···
       url = "https://github.com/karitham.keys";
       flake = false;
     };
-
     zjstatus = {
       url = "github:dj95/zjstatus";
+      inputs.nixpkgs.follows = "nixpkgs";
     };
     knixpkgs = {
       url = "github:karitham/knixpkgs";
-      inputs.nixpkgs.follows = "nixpkgs"; # use the same mesa as local system
+      inputs.nixpkgs.follows = "nixpkgs";
     };
-
     tree-sitter-nu = {
       url = "github:nushell/tree-sitter-nu";
       flake = false;
     };
-
     topiary-nushell = {
       url = "github:blindFS/topiary-nushell";
       flake = false;
     };
-
     sops-nix = {
       url = "github:Mic92/sops-nix";
       inputs.nixpkgs.follows = "nixpkgs";
     };
+    flake-parts.url = "github:hercules-ci/flake-parts";
   };
-  outputs = inputs @ {
+  outputs = {
     self,
     nixpkgs,
+    flake-parts,
     ...
-  }: let
-    hasHome = cfg: (cfg ? home) && cfg.home;
+  } @ inputs:
+    flake-parts.lib.mkFlake {inherit inputs;} (
+      {withSystem, ...}: {
+        systems = [
+          "x86_64-linux"
+          "aarch64-linux"
+        ];
 
-    # Unified system configuration
-    systems = {
-      belaf = {
-        user = "kar";
-        home = true;
-        arch = "x86_64-linux";
-      };
-      kiwi = {
-        user = "kar";
-        home = true;
-        arch = "x86_64-linux";
-      };
-      reg = {
-        user = "root";
-        arch = "x86_64-linux";
-      };
-      ozen = {
-        user = "nixos";
-        home = true;
-        arch = "x86_64-linux";
-      };
-      wakuna = {
-        user = "root";
-        arch = "aarch64-linux";
-      };
-    };
+        perSystem = {pkgs, ...}: {
+          packages = {
+            pokego = pkgs.callPackage ./pkgs/pokego.nix {};
+            http-nu = pkgs.callPackage ./pkgs/http-nu.nix {};
+            topiary-nu = pkgs.callPackage ./pkgs/topiary-nu.nix {
+              inherit (inputs) tree-sitter-nu topiary-nushell;
+            };
 
-    # Helper function to create NixOS configurations
-    mkSystem = hostname: cfg:
-      nixpkgs.lib.nixosSystem {
-        specialArgs = let
-          inherit (nixpkgs) lib;
-        in {
-          inherit inputs;
-          username = cfg.user;
-          inputs' = lib.mapAttrs (_: lib.mapAttrs (_: v: v.${cfg.arch} or v)) inputs;
+            wakuna-image = self.lib.sdImageFromSystem self.nixosConfigurations.wakuna;
+          };
+          formatter = pkgs.alejandra;
         };
-        modules =
-          [
-            (_: {
-              networking.hostName = hostname;
-              nix.registry = {
-                self.flake = self;
-              };
-            })
-            ./modules/nixos
-            ./hosts/${hostname}
-          ]
-          ++ nixpkgs.lib.optionals (hasHome cfg) [
-            inputs.home-manager.nixosModules.home-manager
-            inputs.niri.nixosModules.niri
-            ./modules/home
-          ];
-      };
 
-    forAllSystems = function:
-      nixpkgs.lib.genAttrs (import inputs.systems) (system: function nixpkgs.legacyPackages.${system});
-  in {
-    nixosConfigurations = nixpkgs.lib.mapAttrs mkSystem systems;
+        flake = let
+          inherit (nixpkgs) lib;
+        in {
+          lib = {
+            sdImageFromSystem = system: system.config.system.build.sdImage;
 
-    homeConfigurations = nixpkgs.lib.mapAttrs' (hostname: cfg: {
-      name = "${cfg.user}@${hostname}";
-      value = {
-        config = self.nixosConfigurations.${hostname}.config.home-manager.users.${cfg.user};
-      };
-    }) (nixpkgs.lib.filterAttrs (_: hasHome) systems);
+            mkSystem' = system: hostname:
+              withSystem system ({
+                inputs',
+                self',
+                ...
+              }:
+                lib.nixosSystem {
+                  specialArgs = {inherit inputs inputs' self self';};
+                  modules = [
+                    {networking.hostName = hostname;}
+                    ./modules/core.nix
+                    ./modules/nixos
+                    ./hosts/${hostname}
+                  ];
+                });
 
-    images = {
-      wakuna = self.nixosConfigurations.wakuna.config.system.build.sdImage;
-    };
+            mkSystem = system: hostname: {${hostname} = self.lib.mkSystem' system hostname;};
+            mkSystems = system: hosts: lib.mergeAttrsList (map (self.lib.mkSystem system) hosts);
+          };
 
-    packages = forAllSystems (pkgs: {
-      pokego = pkgs.callPackage ./pkgs/pokego.nix {};
-      http-nu = pkgs.callPackage ./pkgs/http-nu.nix {};
-      topiary-nu = pkgs.callPackage ./pkgs/topiary-nu.nix {
-        inherit (inputs) tree-sitter-nu topiary-nushell;
-      };
-    });
+          nixosConfigurations = inputs.nixpkgs.lib.concatMapAttrs self.lib.mkSystems {
+            "x86_64-linux" = ["ozen" "kiwi" "reg" "belaf"];
+            "aarch64-linux" = ["wakuna"];
+          };
 
-    overlays.default = import ./overlays;
-  };
+          overlays.default = import ./overlays;
+        };
+      }
+    );
   nixConfig = {
     warn-dirty = false;
     extra-experimental-features = [

hosts/belaf/default.nix

···
   inputs,
   ...
 }: {
-  catppuccin.enable = true;
-  catppuccin.flavor = "macchiato";
-  desktop.niri = true;
+  imports = [
+    inputs.lanzaboote.nixosModules.lanzaboote
+    inputs.catppuccin.nixosModules.catppuccin
+    ../../modules/home
+    ./hardware.nix
+  ];
+  catppuccin = {
+    enable = true;
+    flavor = "macchiato";
+  };
   time.timeZone = "Europe/Paris";
-
-  system = {
-    stateVersion = "25.11";
-  };
+  desktop.enable = true;
+  system.stateVersion = "25.11";
 
   boot = {
     loader.systemd-boot = {
···
       data-root = "/docker";
     };
   };
-
-  imports = [
-    inputs.lanzaboote.nixosModules.lanzaboote
-    inputs.catppuccin.nixosModules.catppuccin
-    ./hardware.nix
-  ];
 }

hosts/kiwi/default.nix

···
 {
   inputs,
-  inputs',
   pkgs,
   ...
 }: {
+  imports = [
+    inputs.catppuccin.nixosModules.catppuccin
+    ../../modules/home
+    ./hardware.nix
+  ];
+
+  yubikey.enable = true;
   catppuccin = {
     enable = true;
     flavor = "macchiato";
   };
-  desktop.niri = true;
-  ipcam.enable = false;
-  yubikey.enable = true;
   time.timeZone = "Europe/Paris";
-
-  system = {
-    stateVersion = "25.05";
-  };
-
-  imports = [
-    inputs.catppuccin.nixosModules.catppuccin
-    ./hardware.nix
-  ];
+  desktop.enable = true;
+  system.stateVersion = "25.11";
 
   home-manager.users.kar.imports = [
     ./home-upf.nix

hosts/ozen/default.nix

···
   inputs,
   pkgs,
   lib,
-  username,
+  config,
   ...
 }: let
   inherit (lib) mkForce;
 in {
+  my.username = "nixos";
+
   imports = [
     inputs.catppuccin.nixosModules.catppuccin
     inputs.nixos-wsl.nixosModules.default
-    {
-      system.stateVersion = "24.11";
-      wsl.enable = true;
-      wsl.defaultUser = "nixos";
-    }
+    ../../modules/home
   ];
 
   catppuccin = {
     enable = true;
     flavor = "macchiato";
   };
+  wsl.enable = true;
+  wsl.defaultUser = config.my.username;
+  system.stateVersion = "25.11";
 
   virtualisation.docker.enable = true;
 
-  programs = {
-    ssh.startAgent = true;
-  };
+  programs.ssh.startAgent = true;
 
   services = {
     smartd.enable = mkForce false;

hosts/reg/default.nix

···
 {
+  config,
   pkgs,
   inputs,
-  username,
   ...
 }: {
+  my.username = "root";
+
   imports = [
     inputs.sops-nix.nixosModules.sops
     ./hardware.nix
···
   };
 
   users.users = {
-    ${username}.openssh.authorizedKeys.keyFiles = [inputs.ssh-keys];
+    ${config.my.username}.openssh.authorizedKeys.keyFiles = [inputs.ssh-keys];
   };
 
   environment.systemPackages = with pkgs; [helix];

hosts/wakuna/default.nix

···
   ];
 
   sdImage.compressImage = false;
+  
   nixpkgs.hostPlatform = "aarch64-linux";
   system.stateVersion = "24.11";
 

modules/core.nix

···
+{lib, ...}: {
+  options.my.username = lib.mkOption {
+    type = lib.types.str;
+    description = "The username for the current user.";
+    default = "kar";
+  };
+}

modules/home/default.nix

···
   config,
   inputs,
   inputs',
-  username,
+  self,
+  self',
   ...
 }: {
-  users.users.${username} =
-    if username != "root"
+  imports = [inputs.home-manager.nixosModules.default];
+  users.users.${config.my.username} =
+    if config.my.username != "root"
     then {
-      home = "/home/${username}";
+      home = "/home/${config.my.username}";
       isNormalUser = true;
       extraGroups = [
         "networkmanager"
···
     else {};
 
   home-manager = {
-    extraSpecialArgs = {inherit inputs inputs' username;};
+    extraSpecialArgs = {inherit inputs inputs' self self';};
     backupFileExtension = "bak";
-    users.${username} = {
-      home.username = username;
+    users.${config.my.username} = {
+      home.username = config.my.username;
       home.stateVersion = "25.11";
 
       catppuccin = {

modules/home/desktop/niri.nix

···
   pkgs,
   ...
 }: {
-  config = lib.mkIf (osConfig.desktop.enable && osConfig.desktop.niri) {
+  config = lib.mkIf (osConfig.desktop.enable && osConfig.desktop.enable) {
     home.packages = [pkgs.nautilus]; # xdg-desktop-portal-gnome wants it
     programs.niri = {
       settings = {

modules/home/desktop/waybar.nix

···
           "backlight"
         ];
 
-        modules-center = lib.optional osConfig.desktop.niri "niri/workspaces";
+        modules-center = lib.optional osConfig.desktop.enable "niri/workspaces";
 
         modules-right = [
           "pulseaudio"

modules/home/dev/helix.nix

···
   lib,
   pkgs,
   inputs',
+  self',
   ...
 }: let
   jj-patch = pkgs.fetchurl {
···
               name = "nu";
               language-servers = ["nu-lsp"];
               formatter = {
-                command = "${lib.getExe inputs'.self.packages.topiary-nu}";
+                command = "${lib.getExe self'.packages.topiary-nu}";
                 args = [
                   "format"
                   "--language"

modules/nixos/desktop.nix

···
   config,
   lib,
   pkgs,
+  inputs,
   ...
 }: let
   cfg = config.desktop;
 in {
-  options.desktop = let
-    defaultWallpaper = pkgs.fetchurl {
-      url = "https://raw.githubusercontent.com/HoulFloof/wallpapers/f23c1010b93cb97baa7ad7c94fd552f7601496d2/misc/waves_right_colored.png";
-      hash = "sha256-NqqE+pGnCIWAitH86sxu1EudVEEaSO82y3NqbhtDh9k=";
-    };
-  in {
-    enable =
-      lib.mkEnableOption "desktop usage"
-      // {
-        default = lib.lists.any (isTrue: isTrue) [
-          cfg.niri
-        ];
-      };
+  options.desktop = {
+    enable = lib.mkEnableOption "desktop usage";
     wallpaper = lib.mkOption {
-      default = "${defaultWallpaper}";
+      default = pkgs.fetchurl {
+        url = "https://raw.githubusercontent.com/HoulFloof/wallpapers/f23c1010b93cb97baa7ad7c94fd552f7601496d2/misc/waves_right_colored.png";
+        hash = "sha256-NqqE+pGnCIWAitH86sxu1EudVEEaSO82y3NqbhtDh9k=";
+      };
       type = lib.types.path;
       description = "the wallpaper to use";
     };
-    niri = lib.mkEnableOption "enable niri";
   };
+
+  imports = [inputs.niri.nixosModules.niri];
 
   config = lib.mkIf cfg.enable {
     hardware = {
···
     };
 
     programs = {
-      niri = lib.mkIf cfg.niri {
+      niri = {
         enable = true;
       };
 

modules/nixos/nix.nix

···
 {
   inputs,
-  username,
   lib,
   config,
   pkgs,
···
       package = pkgs.lix;
 
       registry.nixpkgs.flake = inputs.nixpkgs;
+      registry.self.flake = inputs.self;
       channel.enable = false;
 
       settings = {
···
 
     programs.nh = {
       enable = true;
-      flake = "/home/${username}/dotfiles";
+      flake = "/home/${config.my.username}/dotfiles";
     };
   };
 }

modules/nixos/shell.nix

···
 {
   config,
   lib,
-  username,
   pkgs,
   ...
 }: {
···
     users.defaultUserShell = pkgs.nushell;
     environment.shells = [pkgs.nushell];
 
-    environment.sessionVariables.EDITOR = lib.attrByPath ["home-manager" "users" username "home" "sessionVariables" "EDITOR"] "nano" config;
-    programs.nano.enable = !(lib.attrByPath ["home-manager" "users" username "programs" "helix" "enable"] false config);
+    environment.sessionVariables.EDITOR = lib.attrByPath ["home-manager" "users" config.my.username "home" "sessionVariables" "EDITOR"] "nano" config;
+    programs.nano.enable = !(lib.attrByPath ["home-manager" "users" config.my.username "programs" "helix" "enable"] false config);
   };
 }