flake.nix: switch to flake parts

Currently, there has been no functional change to the structure of this
flake. I have simply wrapped the current flake outputs in the root
flake-parts module.

flake.lock

@@ -273,6 +273,24 @@
       }
     },
     "flake-parts": {
+      "inputs": {
+        "nixpkgs-lib": "nixpkgs-lib"
+      },
+      "locked": {
+        "lastModified": 1738453229,
+        "narHash": "sha256-7H9XgNiGLKN1G1CgRh0vUL4AheZSYzPm+zmZ7vxbJdo=",
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "rev": "32ea77a06711b758da0ad9bd6a844c5740a87abd",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "type": "github"
+      }
+    },
+    "flake-parts_2": {
       "inputs": {
         "nixpkgs-lib": [
           "lanzaboote",
@@ -966,7 +984,7 @@
       "inputs": {
         "crane": "crane",
         "flake-compat": "flake-compat_2",
-        "flake-parts": "flake-parts",
+        "flake-parts": "flake-parts_2",
         "nixpkgs": [
           "nixpkgs"
         ],
@@ -1113,6 +1131,18 @@
         "type": "github"
       }
     },
+    "nixpkgs-lib": {
+      "locked": {
+        "lastModified": 1738452942,
+        "narHash": "sha256-vJzFZGaCpnmo7I6i416HaBLpC+hvcURh/BQwROcGIp8=",
+        "type": "tarball",
+        "url": "https://github.com/NixOS/nixpkgs/archive/072a6db25e947df2f31aab9eccd0ab75d5b2da11.tar.gz"
+      },
+      "original": {
+        "type": "tarball",
+        "url": "https://github.com/NixOS/nixpkgs/archive/072a6db25e947df2f31aab9eccd0ab75d5b2da11.tar.gz"
+      }
+    },
     "nixpkgs-nix-du": {
       "locked": {
         "lastModified": 1722785290,
@@ -1231,6 +1261,7 @@
       "inputs": {
         "agenix": "agenix",
         "base16": "base16",
+        "flake-parts": "flake-parts",
         "home-manager": "home-manager_2",
         "home-manager-unstable": "home-manager-unstable",
         "hypridle": "hypridle",

flake.nix

@@ -11,6 +11,8 @@
     # this seems to be a popular way to declare systems
     systems.url = "github:nix-systems/default";
 
+    flake-parts.url = "github:hercules-ci/flake-parts";
+
     home-manager = {
       url = "github:nix-community/home-manager/release-23.11";
       inputs.nixpkgs.follows = "nixpkgs";
@@ -102,380 +104,459 @@
     };
   };
 
-  outputs = { self, nixpkgs, nixpkgs-unstable, ... }@inputs: 
+  outputs = {
-  let
+    self,
-    inherit (self) outputs;
+    flake-parts,
-    # inputs is already defined
+    ...
-    lib = nixpkgs.lib;
+  } @ inputs:
-    systems = [ "x86_64-linux" "aarch64-linux" ];
+    flake-parts.lib.mkFlake {inherit inputs;} ({
+        inputs,
+        self,
+        ...
+      } @ flakeArgs: let
+        inherit (inputs) nixpkgs nixpkgs-unstable;
+        inherit (self) outputs;
+        # inputs is already defined
+        lib = nixpkgs.lib;
+        systems = ["x86_64-linux" "aarch64-linux"];
 
-    overlays = let
+        overlays = let
-      nix-minecraft-patched-overlay = let
+          nix-minecraft-patched-overlay = let
-        normal = inputs.nix-minecraft-upstream.overlays.default;
+            normal = inputs.nix-minecraft-upstream.overlays.default;
-        quilt = inputs.nix-minecraft.overlays.default;
+            quilt = inputs.nix-minecraft.overlays.default;
-      in lib.composeExtensions
+          in
-        normal
+            lib.composeExtensions
-        (final: prev: let
+            normal
-          x=quilt final prev;
+            (final: prev: let
-        in {
+              x = quilt final prev;
-          inherit (x) quiltServers quilt-server;
+            in {
-          minecraftServers = prev.minecraftServers // x.quiltServers;
+              inherit (x) quiltServers quilt-server;
-        });
+              minecraftServers = prev.minecraftServers // x.quiltServers;
-    in [
+            });
-      (final: prev: let
+        in [
-        packages = import ./pkgs { inherit (prev) pkgs; };
+          (final: prev: let
-      in {
+            packages = import ./pkgs {inherit (prev) pkgs;};
-        inherit (packages) mopidy-autoplay google-fonts;
+          in {
-        atool-wrapped = packages.atool;
+            inherit (packages) mopidy-autoplay google-fonts;
-      })
+            atool-wrapped = packages.atool;
-
-      # various temporary fixes that automatically revert
-      self.overlays.mitigations
-
-      # auto backports from nixpkgs unstable
-      self.overlays.backports
-
-      # modpacks (keeps modpack version in sync between hosts so i can reverse
-      # proxy create track map because it's broken)
-      self.overlays.modpacks
-
-      inputs.hyprwm-contrib.overlays.default
-      inputs.rust-overlay.overlays.default
-      inputs.nixfiles-assets.overlays.default
-      nix-minecraft-patched-overlay
-    ];
-
-    ### Configuration
-    # My username
-    username = "nullbite";
-    # My current timezone for any mobile devices (i.e., my laptop)
-    mobileTimeZone = "Europe/Amsterdam";
-
-    # Variables to be passed to NixOS modules in the vars attrset
-    vars = {
-      inherit username mobileTimeZone self;
-    };
-
-    # funciton to generate packages for each system
-    eachSystem = lib.genAttrs (import inputs.systems);
-
-    # This function produces a module that adds the home-manager module to the
-    # system and configures the given module to the user's Home Manager
-    # configuration
-    homeManagerInit = let _username=username; _nixpkgs=nixpkgs;
-    in { system,
-        nixpkgs ? _nixpkgs, # this is so modules can know which flake the system is using
-        home-manager ? inputs.home-manager,
-        username ? _username,
-        module ? _ : {},
-        rootModule ? (import ./home/root.nix),
-        userModules ? { ${username} = [ module ] ; root = [ rootModule ]; },
-        stateVersion }:
-      { config, lib, pkgs, ... }:
-      let
-        mapUserModules = lib.attrsets.mapAttrs (user: modules: {...}:
-        {
-          imports = [
-            ./home
-          ] ++ modules;
-          config = {
-            home = { inherit stateVersion; };
-          };
-        });
-        users = mapUserModules userModules;
-      in
-      {
-        imports = [
-          home-manager.nixosModules.home-manager
-        ];
-
-        home-manager = {
-          useGlobalPkgs = true;
-          useUserPackages = true;
-          backupFileExtension = "hm.bak";
-          inherit users;
-          extraSpecialArgs = {
-            inherit inputs outputs vars nixpkgs home-manager;
-          };
-        };
-      };
-
-    # TODO rewrite this so it follows the same wrapper pattern as mkHome
-    # This function produces a nixosSystem which imports configuration.nix and
-    # a Home Manager home.nix for the given user from ./hosts/${hostname}/
-    mkSystemN = let
-      _username = username;
-      _overlays = overlays;
-    in { nixpkgs ? inputs.nixpkgs,
-          home-manager ? inputs.home-manager,
-          username ? _username,
-          entrypoint ? ./system,
-          modules ? [ ],
-          stateVersion ? null,
-          config ? { },
-          overlays ? _overlays,
-          system,
-          ... }@args: let
-        _modules = [ entrypoint config ] ++ modules ++ [{
-          nixpkgs.config = {
-            inherit overlays;
-            allowUnfree = true;
-          };
-        }] ++ lib.optional (args ? stateVersion) { config.system.stateVersion = stateVersion; };
-      in nixpkgs.lib.nixosSystem {
-      };
-    mkSystem = let _username=username; _overlays=overlays; _nixpkgs=nixpkgs;
-    in { system,
-        nixpkgs ? _nixpkgs,
-        home-manager ? inputs.home-manager,
-        overlays ? _overlays,
-        hostname,
-        username ? _username,
-        stateVersion,
-        extraModules ? [] }:
-
-      nixpkgs.lib.nixosSystem {
-        inherit system;
-        modules = [
-          ./system
-          ({pkgs, config, lib, ...}@args: 
-            {
-              # Values for every single system that would not conceivably need
-              # to be made modular
-              system.stateVersion = stateVersion;
-              nixpkgs = {
-                inherit overlays;
-                config = {
-                  # not having the freedom to install unfree programs is unfree
-                  allowUnfree = true;
-                };
-              };
-              nix.settings.experimental-features = ["nix-command" "flakes" ];
-            })
-          ./hosts/${hostname}/configuration.nix
-          (homeManagerInit {
-            inherit nixpkgs home-manager;
-            module = import ./hosts/${hostname}/home.nix;
-            inherit username system stateVersion;
           })
-        ] ++ extraModules;
+
-        specialArgs = {
+          # various temporary fixes that automatically revert
-          inherit inputs outputs vars nixpkgs home-manager;
+          self.overlays.mitigations
+
+          # auto backports from nixpkgs unstable
+          self.overlays.backports
+
+          # modpacks (keeps modpack version in sync between hosts so i can reverse
+          # proxy create track map because it's broken)
+          self.overlays.modpacks
+
+          inputs.hyprwm-contrib.overlays.default
+          inputs.rust-overlay.overlays.default
+          inputs.nixfiles-assets.overlays.default
+          nix-minecraft-patched-overlay
+        ];
+
+        ### Configuration
+        # My username
+        username = "nullbite";
+        # My current timezone for any mobile devices (i.e., my laptop)
+        mobileTimeZone = "Europe/Amsterdam";
+
+        # Variables to be passed to NixOS modules in the vars attrset
+        vars = {
+          inherit username mobileTimeZone self;
         };
-      };
 
-    mkWSLSystem = let _username=username; in
+        # funciton to generate packages for each system
-      {username ? _username, extraModules ? [], ...}@args: let
+        eachSystem = lib.genAttrs (import inputs.systems);
-        WSLModule = {...}: {
-          imports = [
-            inputs.nix-wsl.nixosModules.wsl
-          ];
-          wsl.enable = true;
-          wsl.defaultUser = username;
-        };
-        override = {extraModules = extraModules ++ [WSLModule];};
-      in
-        mkSystem (args // override);
 
-    mkISOSystem = system: inputs.nixpkgs-unstable.lib.nixosSystem {
+        # This function produces a module that adds the home-manager module to the
-      inherit system;
+        # system and configures the given module to the user's Home Manager
-      modules = [
+        # configuration
-        "${inputs.nixpkgs-unstable}/nixos/modules/installer/cd-dvd/installation-cd-minimal-new-kernel-no-zfs.nix"
+        homeManagerInit = let
-        ({ config, pkgs, lib, ... }:
+          _username = username;
-        {
+          _nixpkgs = nixpkgs;
-          environment.systemPackages = with pkgs; [
+        in
-            neovim
+          {
-            gparted
+            system,
-          ];
+            nixpkgs ? _nixpkgs, # this is so modules can know which flake the system is using
-        })
+            home-manager ? inputs.home-manager,
-      ];
+            username ? _username,
-    };
+            module ? _: {},
+            rootModule ? (import ./home/root.nix),
+            userModules ? {
+              ${username} = [module];
+              root = [rootModule];
+            },
+            stateVersion,
+          }: {
+            config,
+            lib,
+            pkgs,
+            ...
+          }: let
+            mapUserModules = lib.attrsets.mapAttrs (user: modules: {...}: {
+              imports =
+                [
+                  ./home
+                ]
+                ++ modules;
+              config = {
+                home = {inherit stateVersion;};
+              };
+            });
+            users = mapUserModules userModules;
+          in {
+            imports = [
+              home-manager.nixosModules.home-manager
+            ];
 
-    # values to be passed to nixosModules and homeManagerModules wrappers
+            home-manager = {
-    moduleInputs = {
+              useGlobalPkgs = true;
-    };
+              useUserPackages = true;
-
+              backupFileExtension = "hm.bak";
-    # Make a home-manager standalone configuration. This implementation is
+              inherit users;
-    # better than mkSystem because it extends homeManagerConfiguration.
+              extraSpecialArgs = {
-    mkHome = let
+                inherit inputs outputs vars nixpkgs home-manager;
-      _home-manager = inputs.home-manager;
+              };
-      _nixpkgs = inputs.nixpkgs;
-      _username = username;
-    in { home-manager ? _home-manager,
-          nixpkgs ? _nixpkgs,
-          username ? _username,
-          homeDirectory ? "/home/${username}",
-          entrypoint ? ./home/standalone.nix,
-          modules ? [ ],
-          stateVersion ? null,
-          config ? { },
-          system,
-          ... }@args: let
-      _modules = [ entrypoint ] ++ modules ++ [ config ] ++ [
-        {
-          config = {
-            home = {
-              inherit username homeDirectory;
-            };
-            nixpkgs.config = {
-              allowUnfree = true;
             };
           };
-        }
-      ] ++ lib.optional (args ? stateVersion) { config.home.stateVersion = stateVersion; };
-    in home-manager.lib.homeManagerConfiguration ({
-      modules = _modules;
-      pkgs = import nixpkgs {inherit system overlays; };
 
-      extraSpecialArgs = {
+        # TODO rewrite this so it follows the same wrapper pattern as mkHome
-        inherit inputs outputs vars nixpkgs home-manager;
+        # This function produces a nixosSystem which imports configuration.nix and
+        # a Home Manager home.nix for the given user from ./hosts/${hostname}/
+        mkSystemN = let
+          _username = username;
+          _overlays = overlays;
+        in
+          {
+            nixpkgs ? inputs.nixpkgs,
+            home-manager ? inputs.home-manager,
+            username ? _username,
+            entrypoint ? ./system,
+            modules ? [],
+            stateVersion ? null,
+            config ? {},
+            overlays ? _overlays,
+            system,
+            ...
+          } @ args: let
+            _modules =
+              [entrypoint config]
+              ++ modules
+              ++ [
+                {
+                  nixpkgs.config = {
+                    inherit overlays;
+                    allowUnfree = true;
+                  };
+                }
+              ]
+              ++ lib.optional (args ? stateVersion) {config.system.stateVersion = stateVersion;};
+          in
+            nixpkgs.lib.nixosSystem {
+            };
+        mkSystem = let
+          _username = username;
+          _overlays = overlays;
+          _nixpkgs = nixpkgs;
+        in
+          {
+            system,
+            nixpkgs ? _nixpkgs,
+            home-manager ? inputs.home-manager,
+            overlays ? _overlays,
+            hostname,
+            username ? _username,
+            stateVersion,
+            extraModules ? [],
+          }:
+            nixpkgs.lib.nixosSystem {
+              inherit system;
+              modules =
+                [
+                  ./system
+                  ({
+                      pkgs,
+                      config,
+                      lib,
+                      ...
+                    } @ args: {
+                      # Values for every single system that would not conceivably need
+                      # to be made modular
+                      system.stateVersion = stateVersion;
+                      nixpkgs = {
+                        inherit overlays;
+                        config = {
+                          # not having the freedom to install unfree programs is unfree
+                          allowUnfree = true;
+                        };
+                      };
+                      nix.settings.experimental-features = ["nix-command" "flakes"];
+                    })
+                  ./hosts/${hostname}/configuration.nix
+                  (homeManagerInit {
+                    inherit nixpkgs home-manager;
+                    module = import ./hosts/${hostname}/home.nix;
+                    inherit username system stateVersion;
+                  })
+                ]
+                ++ extraModules;
+              specialArgs = {
+                inherit inputs outputs vars nixpkgs home-manager;
+              };
+            };
 
-        # this is needed because modules don't use the default arg for some reason???
+        mkWSLSystem = let
-        osConfig = {};
+          _username = username;
-      };
+        in
-    } // builtins.removeAttrs args
+          {
-      [ "system" "nixpkgs" "home-manager" "modules" "username" "homeDirectory" "stateVersion" "entrypoint" "config" ]);
+            username ? _username,
+            extraModules ? [],
+            ...
+          } @ args: let
+            WSLModule = {...}: {
+              imports = [
+                inputs.nix-wsl.nixosModules.wsl
+              ];
+              wsl.enable = true;
+              wsl.defaultUser = username;
+            };
+            override = {extraModules = extraModules ++ [WSLModule];};
+          in
+            mkSystem (args // override);
 
-  in {
+        mkISOSystem = system:
-    # for repl debugging via :lf .
+          inputs.nixpkgs-unstable.lib.nixosSystem {
-    inherit inputs vars;
+            inherit system;
-
+            modules = [
-    devShells = eachSystem (system: let
+              "${inputs.nixpkgs-unstable}/nixos/modules/installer/cd-dvd/installation-cd-minimal-new-kernel-no-zfs.nix"
-      pkgs = import nixpkgs-unstable { inherit system; };
+              ({
-    in {
+                config,
-      ci = pkgs.mkShell {
+                pkgs,
-        buildInputs = with pkgs; [
+                lib,
-          nix-update
+                ...
-          nix-fast-build
+              }: {
-        ];
+                environment.systemPackages = with pkgs; [
-      };
+                  neovim
-      default = pkgs.mkShell {
+                  gparted
-        buildInputs = with pkgs; [
+                ];
-          nix-update
+              })
-          inputs.agenix.packages.${system}.default
+            ];
-        ];
-      };
-    });
-
-    # nix flake modules are meant to be portable so we cannot rely on
-    # (extraS|s)pecialArgs to pass variables
-    nixosModules = (import ./modules/nixos) moduleInputs;
-    homeManagerModules = (import ./modules/home-manager) moduleInputs;
-    packages = eachSystem (system: let pkgs = import nixpkgs-unstable { inherit system; };
-      in (
-        import ./pkgs { inherit pkgs; }) // {
-          iso = let
-            isoSystem = mkISOSystem system;
-          in isoSystem.config.system.build.isoImage;
-        }
-      );
-    apps = eachSystem (system: import ./pkgs/apps.nix
-      { inherit (self.outputs) packages; inherit system; });
-
-    overlays = import ./overlays self;
-
-    nixosConfigurations = {
-      iso = mkISOSystem "x86_64-linux";
-      slab = mkSystem {
-        nixpkgs = inputs.nixpkgs-unstable;
-        home-manager = inputs.home-manager-unstable;
-        system = "x86_64-linux";
-        hostname = "slab";
-        stateVersion = "23.11";
-      };
-
-      nullbox = mkSystem {
-        nixpkgs = inputs.nixpkgs-unstable;
-        home-manager = inputs.home-manager-unstable;
-        system = "x86_64-linux";
-        hostname = "nullbox";
-        stateVersion = "23.11";
-      };
-
-      nixos-wsl = mkWSLSystem {
-        nixpkgs = inputs.nixpkgs-unstable;
-        home-manager = inputs.home-manager-unstable;
-        system = "x86_64-linux";
-        stateVersion = "23.11";
-        hostname = "nixos-wsl";
-      };
-
-      # for eval testing
-      rpi4-x86_64 = mkSystem {
-        nixpkgs = inputs.nixpkgs-unstable;
-        home-manager = inputs.home-manager-unstable;
-        system = "x86_64-linux";
-        stateVersion = "24.11";
-        hostname = "rpi4";
-        extraModules = [{
-            nixpkgs.hostPlatform = "x86_64-linux";
-        }];
-      };
-
-      rpi4 = mkSystem {
-        nixpkgs = inputs.nixpkgs-unstable;
-        home-manager = inputs.home-manager-unstable;
-        system = "aarch64-linux";
-        stateVersion = "24.11";
-        hostname = "rpi4";
-      };
-    }; # end nixosConfigurations
-
-    homeConfigurations = {
-      # minimal root config
-      "root@rpi4" = mkHome {
-        system = "aarch64-linux";
-        stateVersion = "23.11";
-        username = "root";
-        homeDirectory = "/root";
-        config = { pkgs, ...}: {
-          programs.bash.enable = true;
-
-          # update nix system-wide since it's installed via root profile
-          home.packages = with pkgs; [ btdu nix ];
-        };
-        nixpkgs = inputs.nixpkgs-unstable;
-        home-manager = inputs.home-manager-unstable;
-      };
-
-      "nullbite@rpi4" = mkHome {
-        system = "aarch64-linux";
-        stateVersion = "23.11";
-        config = { pkgs, ...} : {
-          programs = {
-            zsh.enable = false;
-            keychain.enable = false;
           };
-          home.packages = with pkgs; [ btdu ];
+
+        # values to be passed to nixosModules and homeManagerModules wrappers
+        moduleInputs = {
         };
-        nixpkgs = inputs.nixpkgs-unstable;
+
-        home-manager = inputs.home-manager-unstable;
+        # Make a home-manager standalone configuration. This implementation is
-      };
+        # better than mkSystem because it extends homeManagerConfiguration.
-      "deck" = mkHome {
+        mkHome = let
-        system = "x86_64-linux";
+          _home-manager = inputs.home-manager;
-        stateVersion = "23.11";
+          _nixpkgs = inputs.nixpkgs;
-        username = "deck";
+          _username = username;
-        modules = [ ./users/deck/home.nix ];
+        in
-        nixpkgs = inputs.nixpkgs-unstable;
+          {
-        home-manager = inputs.home-manager-unstable;
+            home-manager ? _home-manager,
-      };
+            nixpkgs ? _nixpkgs,
-      "testuser" = mkHome {
+            username ? _username,
-        username = "testuser";
+            homeDirectory ? "/home/${username}",
-        system = "x86_64-linux";
+            entrypoint ? ./home/standalone.nix,
-        modules = [ ./users/testuser/home.nix ];
+            modules ? [],
-        stateVersion = "23.11";
+            stateVersion ? null,
-        nixpkgs = inputs.nixpkgs-unstable;
+            config ? {},
-        home-manager = inputs.home-manager-unstable;
+            system,
-      };
+            ...
-      "nix-on-droid" = mkHome {
+          } @ args: let
-        username = "nix-on-droid";
+            _modules =
-        homeDirectory = "/data/data/com.termux.nix/files/home";
+              [entrypoint]
-        modules = [ ./users/nix-on-droid/home.nix ];
+              ++ modules
-        system = "aarch64-linux";
+              ++ [config]
-        stateVersion = "23.11";
+              ++ [
-        nixpkgs = inputs.nixpkgs-unstable;
+                {
-        home-manager = inputs.home-manager-unstable;
+                  config = {
-      };
+                    home = {
-    };
+                      inherit username homeDirectory;
-  }; # end outputs
+                    };
-} # end flake
+                    nixpkgs.config = {
+                      allowUnfree = true;
+                    };
+                  };
+                }
+              ]
+              ++ lib.optional (args ? stateVersion) {config.home.stateVersion = stateVersion;};
+          in
+            home-manager.lib.homeManagerConfiguration ({
+                modules = _modules;
+                pkgs = import nixpkgs {inherit system overlays;};
+
+                extraSpecialArgs = {
+                  inherit inputs outputs vars nixpkgs home-manager;
+
+                  # this is needed because modules don't use the default arg for some reason???
+                  osConfig = {};
+                };
+              }
+              // builtins.removeAttrs args
+              ["system" "nixpkgs" "home-manager" "modules" "username" "homeDirectory" "stateVersion" "entrypoint" "config"]);
+      in {
+        flake = {
+          # for repl debugging via :lf .
+          inherit inputs vars;
+
+          devShells = eachSystem (system: let
+            pkgs = import nixpkgs-unstable {inherit system;};
+          in {
+            ci = pkgs.mkShell {
+              buildInputs = with pkgs; [
+                nix-update
+                nix-fast-build
+              ];
+            };
+            default = pkgs.mkShell {
+              buildInputs = with pkgs; [
+                nix-update
+                inputs.agenix.packages.${system}.default
+              ];
+            };
+          });
+
+          # nix flake modules are meant to be portable so we cannot rely on
+          # (extraS|s)pecialArgs to pass variables
+          nixosModules = (import ./modules/nixos) moduleInputs;
+          homeManagerModules = (import ./modules/home-manager) moduleInputs;
+          packages = eachSystem (
+            system: let
+              pkgs = import nixpkgs-unstable {inherit system;};
+            in
+              (
+                import ./pkgs {inherit pkgs;}
+              )
+              // {
+                iso = let
+                  isoSystem = mkISOSystem system;
+                in
+                  isoSystem.config.system.build.isoImage;
+              }
+          );
+          apps = eachSystem (system:
+            import ./pkgs/apps.nix
+            {
+              inherit (self.outputs) packages;
+              inherit system;
+            });
+
+          overlays = import ./overlays self;
+
+          nixosConfigurations = {
+            iso = mkISOSystem "x86_64-linux";
+            slab = mkSystem {
+              nixpkgs = inputs.nixpkgs-unstable;
+              home-manager = inputs.home-manager-unstable;
+              system = "x86_64-linux";
+              hostname = "slab";
+              stateVersion = "23.11";
+            };
+
+            nullbox = mkSystem {
+              nixpkgs = inputs.nixpkgs-unstable;
+              home-manager = inputs.home-manager-unstable;
+              system = "x86_64-linux";
+              hostname = "nullbox";
+              stateVersion = "23.11";
+            };
+
+            nixos-wsl = mkWSLSystem {
+              nixpkgs = inputs.nixpkgs-unstable;
+              home-manager = inputs.home-manager-unstable;
+              system = "x86_64-linux";
+              stateVersion = "23.11";
+              hostname = "nixos-wsl";
+            };
+
+            # for eval testing
+            rpi4-x86_64 = mkSystem {
+              nixpkgs = inputs.nixpkgs-unstable;
+              home-manager = inputs.home-manager-unstable;
+              system = "x86_64-linux";
+              stateVersion = "24.11";
+              hostname = "rpi4";
+              extraModules = [
+                {
+                  nixpkgs.hostPlatform = "x86_64-linux";
+                }
+              ];
+            };
+
+            rpi4 = mkSystem {
+              nixpkgs = inputs.nixpkgs-unstable;
+              home-manager = inputs.home-manager-unstable;
+              system = "aarch64-linux";
+              stateVersion = "24.11";
+              hostname = "rpi4";
+            };
+          }; # end nixosConfigurations
+
+          homeConfigurations = {
+            # minimal root config
+            "root@rpi4" = mkHome {
+              system = "aarch64-linux";
+              stateVersion = "23.11";
+              username = "root";
+              homeDirectory = "/root";
+              config = {pkgs, ...}: {
+                programs.bash.enable = true;
+
+                # update nix system-wide since it's installed via root profile
+                home.packages = with pkgs; [btdu nix];
+              };
+              nixpkgs = inputs.nixpkgs-unstable;
+              home-manager = inputs.home-manager-unstable;
+            };
+
+            "nullbite@rpi4" = mkHome {
+              system = "aarch64-linux";
+              stateVersion = "23.11";
+              config = {pkgs, ...}: {
+                programs = {
+                  zsh.enable = false;
+                  keychain.enable = false;
+                };
+                home.packages = with pkgs; [btdu];
+              };
+              nixpkgs = inputs.nixpkgs-unstable;
+              home-manager = inputs.home-manager-unstable;
+            };
+            "deck" = mkHome {
+              system = "x86_64-linux";
+              stateVersion = "23.11";
+              username = "deck";
+              modules = [./users/deck/home.nix];
+              nixpkgs = inputs.nixpkgs-unstable;
+              home-manager = inputs.home-manager-unstable;
+            };
+            "testuser" = mkHome {
+              username = "testuser";
+              system = "x86_64-linux";
+              modules = [./users/testuser/home.nix];
+              stateVersion = "23.11";
+              nixpkgs = inputs.nixpkgs-unstable;
+              home-manager = inputs.home-manager-unstable;
+            };
+            "nix-on-droid" = mkHome {
+              username = "nix-on-droid";
+              homeDirectory = "/data/data/com.termux.nix/files/home";
+              modules = [./users/nix-on-droid/home.nix];
+              system = "aarch64-linux";
+              stateVersion = "23.11";
+              nixpkgs = inputs.nixpkgs-unstable;
+              home-manager = inputs.home-manager-unstable;
+            };
+          };
+        };
+        systems = (import inputs.systems);
+      }); # end outputs
+}
+# end flake
+