From 3e5c57da9e945b5add9c3fdfb311bd907d9b1751 Mon Sep 17 00:00:00 2001
From: NullBite <me@nullbite.com>
Date: Sat, 8 Feb 2025 19:29:36 -0500
Subject: [PATCH 1/5] flake: move legacy mkSystem code into library

---
 flake.nix                       | 234 +------------------------
 flake/configurations/home.nix   |   1 +
 flake/configurations/system.nix |   7 +
 flake/default.nix               |   2 +
 lib/nixfiles/default.nix        |   4 +
 lib/nixfiles/flake-legacy.nix   | 293 ++++++++++++++++++++++++++++++++
 lib/nixfiles/module.nix         |   4 +-
 7 files changed, 311 insertions(+), 234 deletions(-)
 create mode 100644 flake/configurations/home.nix
 create mode 100644 flake/configurations/system.nix
 create mode 100644 lib/nixfiles/flake-legacy.nix

diff --git a/flake.nix b/flake.nix
index d6c5150..b793bb3 100644
--- a/flake.nix
+++ b/flake.nix
@@ -116,6 +116,7 @@
         self,
         config,
         lib,
+        nixfiles-lib,
         ...
       } @ flakeArgs: {
         # flake-parts imports
@@ -133,6 +134,7 @@
 
           flake = let
             # {{{
+            inherit (nixfiles-lib.flake-legacy) mkSystem mkWSLSystem mkISOSystem mkHome;
             inherit (inputs) nixpkgs nixpkgs-unstable;
             inherit (self) outputs;
             # inputs is already defined
@@ -190,241 +192,9 @@
             # 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}/
-            # 
-            # nevermind i am migrating everything to flake-parts, i'm glad i
-            # never got around to this. i think the module system takes care of
-            # whatever the fuck godforsaken use-case i had for rewriting this
-            # (more ergonomic and/or default arguments or something).
-            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;
-                  };
-                };
-
-            mkWSLSystem = let
-              _username = username;
-            in
-              {
-                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);
-
-            mkISOSystem = system:
-              inputs.nixpkgs-unstable.lib.nixosSystem {
-                inherit system;
-                modules = [
-                  "${inputs.nixpkgs-unstable}/nixos/modules/installer/cd-dvd/installation-cd-minimal-new-kernel-no-zfs.nix"
-                  ({
-                    config,
-                    pkgs,
-                    lib,
-                    ...
-                  }: {
-                    environment.systemPackages = with pkgs; [
-                      neovim
-                      gparted
-                    ];
-                  })
-                ];
-              };
-
             # values to be passed to nixosModules and homeManagerModules wrappers
             moduleInputs = {
             };
-
-            # Make a home-manager standalone configuration. This implementation is
-            # better than mkSystem because it extends homeManagerConfiguration.
-            mkHome = let
-              _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 = {
-                      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 {
             # for repl debugging via :lf .
diff --git a/flake/configurations/home.nix b/flake/configurations/home.nix
new file mode 100644
index 0000000..c915eb0
--- /dev/null
+++ b/flake/configurations/home.nix
@@ -0,0 +1 @@
+{ ... }: { }
diff --git a/flake/configurations/system.nix b/flake/configurations/system.nix
new file mode 100644
index 0000000..bc9e949
--- /dev/null
+++ b/flake/configurations/system.nix
@@ -0,0 +1,7 @@
+{ config, lib, nixfiles-lib, ... }:
+let
+  cfg = config.nixfiles.hosts;
+  inherit (lib) types mkOption mkIf;
+  inherit (nixfiles-lib.flake-legacy) mkSystem mkHome mkWSLSystem mkISOSystem;
+in { }
+
diff --git a/flake/default.nix b/flake/default.nix
index 07448e1..bf9245c 100644
--- a/flake/default.nix
+++ b/flake/default.nix
@@ -2,5 +2,7 @@
 {
   imports = [
     ./packages.nix
+    ./configurations/home.nix
+    ./configurations/system.nix
   ];
 }
diff --git a/lib/nixfiles/default.nix b/lib/nixfiles/default.nix
index 70a6430..89d2efd 100644
--- a/lib/nixfiles/default.nix
+++ b/lib/nixfiles/default.nix
@@ -25,3 +25,7 @@ in
   // lib.optionalAttrs (attrs ? pkgs) {
     minecraft = (import ./minecraft.nix) attrs';
   }
+  # modules that rely on `self` (flake)
+  // lib.optionalAttrs (attrs ? self) {
+    flake-legacy = (import ./flake-legacy.nix) attrs';
+  }
diff --git a/lib/nixfiles/flake-legacy.nix b/lib/nixfiles/flake-legacy.nix
new file mode 100644
index 0000000..3177d0a
--- /dev/null
+++ b/lib/nixfiles/flake-legacy.nix
@@ -0,0 +1,293 @@
+{
+  self,
+  lib,
+  ...
+}: let
+  overlays = let
+    nix-minecraft-patched-overlay = let
+      normal = inputs.nix-minecraft-upstream.overlays.default;
+      quilt = inputs.nix-minecraft.overlays.default;
+    in
+      lib.composeExtensions
+      normal
+      (final: prev: let
+        x = quilt final prev;
+      in {
+        inherit (x) quiltServers quilt-server;
+        minecraftServers = prev.minecraftServers // x.quiltServers;
+      });
+  in [
+    (final: prev: let
+      packages = import ./pkgs {inherit (prev) pkgs;};
+    in {
+      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);
+
+  # values to be passed to nixosModules and homeManagerModules wrappers
+  moduleInputs = {
+  };
+  inherit (self) inputs outputs;
+  inherit (inputs) nixpkgs nixpkgs-unstable home-manager home-manager-unstable;
+in rec {
+  # 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 (self + "/home/root.nix")),
+      userModules ? {
+        ${username} = [module];
+        root = [rootModule];
+      },
+      stateVersion,
+    }: {
+      config,
+      lib,
+      pkgs,
+      ...
+    }: let
+      mapUserModules = lib.attrsets.mapAttrs (user: modules: {...}: {
+        imports =
+          [
+            (self + "/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}/
+  #
+  # nevermind i am migrating everything to flake-parts, i'm glad i
+  # never got around to this. i think the module system takes care of
+  # whatever the fuck godforsaken use-case i had for rewriting this
+  # (more ergonomic and/or default arguments or something).
+  mkSystemN = let
+    _username = username;
+    _overlays = overlays;
+  in
+    {
+      nixpkgs ? inputs.nixpkgs,
+      home-manager ? inputs.home-manager,
+      username ? _username,
+      entrypoint ? (self + "/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 =
+          [
+            (self + "/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"];
+              })
+            (self + "/hosts/${hostname}/configuration.nix")
+            (homeManagerInit {
+              inherit nixpkgs home-manager;
+              module = import (self + "/hosts/${hostname}/home.nix");
+              inherit username system stateVersion;
+            })
+          ]
+          ++ extraModules;
+        specialArgs = {
+          inherit inputs outputs vars nixpkgs home-manager;
+        };
+      };
+
+  mkWSLSystem = let
+    _username = username;
+  in
+    {
+      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);
+
+  mkISOSystem = system:
+    inputs.nixpkgs-unstable.lib.nixosSystem {
+      inherit system;
+      modules = [
+        "${inputs.nixpkgs-unstable}/nixos/modules/installer/cd-dvd/installation-cd-minimal-new-kernel-no-zfs.nix"
+        ({
+          config,
+          pkgs,
+          lib,
+          ...
+        }: {
+          environment.systemPackages = with pkgs; [
+            neovim
+            gparted
+          ];
+        })
+      ];
+    };
+  # Make a home-manager standalone configuration. This implementation is
+  # better than mkSystem because it extends homeManagerConfiguration.
+  mkHome = let
+    _home-manager = inputs.home-manager;
+    _nixpkgs = inputs.nixpkgs;
+    _username = username;
+  in
+    {
+      home-manager ? _home-manager,
+      nixpkgs ? _nixpkgs,
+      username ? _username,
+      homeDirectory ? "/home/${username}",
+      entrypoint ? (self + "/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 = {
+            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"]);
+}
diff --git a/lib/nixfiles/module.nix b/lib/nixfiles/module.nix
index 0734491..bbb0a1f 100644
--- a/lib/nixfiles/module.nix
+++ b/lib/nixfiles/module.nix
@@ -1,6 +1,6 @@
-{lib, ...}: let
+{lib, self, ...}: let
   inherit (lib) types;
-  nixfiles-lib = (import ./.) {inherit lib;};
+  nixfiles-lib = (import ./.) {inherit lib self;};
 in {
   options.nixfiles.lib = lib.mkOption {
     description = "nixfiles library";

From a6bd0191e022d5b2c8610db0967bc002f8cd4814 Mon Sep 17 00:00:00 2001
From: NullBite <me@nullbite.com>
Date: Sat, 8 Feb 2025 19:35:09 -0500
Subject: [PATCH 2/5] flake: move modules

---
 flake/default.nix                     | 4 ++--
 flake/{configurations => }/home.nix   | 0
 flake/{configurations => }/system.nix | 0
 3 files changed, 2 insertions(+), 2 deletions(-)
 rename flake/{configurations => }/home.nix (100%)
 rename flake/{configurations => }/system.nix (100%)

diff --git a/flake/default.nix b/flake/default.nix
index bf9245c..cb6f6cb 100644
--- a/flake/default.nix
+++ b/flake/default.nix
@@ -2,7 +2,7 @@
 {
   imports = [
     ./packages.nix
-    ./configurations/home.nix
-    ./configurations/system.nix
+    ./home.nix
+    ./system.nix
   ];
 }
diff --git a/flake/configurations/home.nix b/flake/home.nix
similarity index 100%
rename from flake/configurations/home.nix
rename to flake/home.nix
diff --git a/flake/configurations/system.nix b/flake/system.nix
similarity index 100%
rename from flake/configurations/system.nix
rename to flake/system.nix

From 5e40d0ca6010f6753b4dfb83c0bdaad7d1497836 Mon Sep 17 00:00:00 2001
From: NullBite <me@nullbite.com>
Date: Sun, 9 Feb 2025 01:44:57 -0500
Subject: [PATCH 3/5] flake: functional prototype of modular systems

---
 flake.nix                         |  75 ++++++++---
 flake/default.nix                 |   5 +-
 flake/meta.nix                    |  11 ++
 flake/overlays.nix                |  19 +++
 flake/system.nix                  | 209 +++++++++++++++++++++++++++++-
 hosts/nixos-wsl/configuration.nix |   3 +
 lib/nixfiles/flake-legacy.nix     |  38 +-----
 lib/nixfiles/module.nix           |   8 +-
 lib/nixfiles/types.nix            |  22 +++-
 9 files changed, 321 insertions(+), 69 deletions(-)
 create mode 100644 flake/meta.nix
 create mode 100644 flake/overlays.nix

diff --git a/flake.nix b/flake.nix
index b793bb3..5222c93 100644
--- a/flake.nix
+++ b/flake.nix
@@ -3,6 +3,7 @@
   description = "NixOS Configuration";
 
   inputs = {
+    # {{{
     nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.11";
     #              ^^^^^^^^^^^^^ this part is optional
     nixpkgs-unstable.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
@@ -103,7 +104,7 @@
       inputs.nixpkgs.follows = "nixpkgs";
       inputs.systems.follows = "systems";
     };
-  };
+  }; # }}}
 
   outputs = {
     self,
@@ -130,13 +131,69 @@
           # flake-parts systems (still uses nix-systems)
           systems = import inputs.systems;
 
+          # expose vars to nix repl
           debug = lib.mkDefault true;
 
+          nixfiles = {
+            vars = {
+              ### Configuration
+              # My username
+              username = "nullbite";
+              # My current timezone for any mobile devices (i.e., my laptop)
+              mobileTimeZone = "America/New_York";
+            };
+
+            common.overlays = let
+              nix-minecraft-patched-overlay = let
+                normal = inputs.nix-minecraft-upstream.overlays.default;
+                quilt = inputs.nix-minecraft.overlays.default;
+              in
+                lib.composeExtensions
+                normal
+                (final: prev: let
+                  x = quilt final prev;
+                in {
+                  inherit (x) quiltServers quilt-server;
+                  minecraftServers = prev.minecraftServers // x.quiltServers;
+                });
+
+              packagesOverlay = final: prev: let
+                packages = import ./pkgs {inherit (prev) pkgs;};
+              in {
+                inherit (packages) mopidy-autoplay google-fonts;
+                atool-wrapped = packages.atool;
+              };
+            in [
+              packagesOverlay
+              # 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
+            ];
+
+            systems.testsys = {
+              system = "x86_64-linux";
+              enable = false;
+            };
+          };
+
           flake = let
             # {{{
             inherit (nixfiles-lib.flake-legacy) mkSystem mkWSLSystem mkISOSystem mkHome;
             inherit (inputs) nixpkgs nixpkgs-unstable;
             inherit (self) outputs;
+            inherit (config.nixfiles.vars) username mobileTimeZone;
+
             # inputs is already defined
             lib = nixpkgs.lib;
             systems = ["x86_64-linux" "aarch64-linux"];
@@ -178,18 +235,7 @@
               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
+            # function to generate packages for each system
             eachSystem = lib.genAttrs (import inputs.systems);
 
             # values to be passed to nixosModules and homeManagerModules wrappers
@@ -197,9 +243,6 @@
             };
             # }}}
           in {
-            # for repl debugging via :lf .
-            inherit inputs vars;
-
             devShells = eachSystem (system: let
               pkgs = import nixpkgs-unstable {inherit system;};
             in {
diff --git a/flake/default.nix b/flake/default.nix
index cb6f6cb..b99bc33 100644
--- a/flake/default.nix
+++ b/flake/default.nix
@@ -1,8 +1,9 @@
-{ ... }:
-{
+{...}: {
   imports = [
     ./packages.nix
     ./home.nix
     ./system.nix
+    ./meta.nix
+    ./overlays.nix
   ];
 }
diff --git a/flake/meta.nix b/flake/meta.nix
new file mode 100644
index 0000000..3293185
--- /dev/null
+++ b/flake/meta.nix
@@ -0,0 +1,11 @@
+{
+  config,
+  lib,
+  ...
+}: {
+  options.nixfiles.vars = lib.mkOption {
+    description = "Global variables";
+    type = lib.types.attrs;
+    default = {};
+  };
+}
diff --git a/flake/overlays.nix b/flake/overlays.nix
new file mode 100644
index 0000000..1f38b80
--- /dev/null
+++ b/flake/overlays.nix
@@ -0,0 +1,19 @@
+{
+  config,
+  lib,
+  inputs,
+  ...
+}: let
+  overlayType = lib.mkOptionType {
+    name = "nixpkgs-overlay";
+    description = "nixpkgs overlay";
+    check = lib.isFunction;
+    merge = lib.mergeOneOption;
+  };
+in {
+  options.nixfiles.common.overlays = lib.mkOption {
+    description = "List of overlays shared between various parts of the flake.";
+    type = lib.types.listOf overlayType;
+    default = [];
+  };
+}
diff --git a/flake/system.nix b/flake/system.nix
index bc9e949..9047500 100644
--- a/flake/system.nix
+++ b/flake/system.nix
@@ -1,7 +1,204 @@
-{ config, lib, nixfiles-lib, ... }:
-let
-  cfg = config.nixfiles.hosts;
-  inherit (lib) types mkOption mkIf;
-  inherit (nixfiles-lib.flake-legacy) mkSystem mkHome mkWSLSystem mkISOSystem;
-in { }
+{
+  config,
+  options,
+  lib,
+  nixfiles-lib,
+  inputs,
+  self,
+  ...
+}: let
+  cfg = config.nixfiles.systems;
+  inherit
+    (lib)
+    types
+    mkOption
+    mkIf
+    filterAttrs
+    mapAttrs
+    ;
 
+  inherit (builtins) attrNames;
+
+  inherit (nixfiles-lib.flake-legacy) mkSystem mkHome mkWSLSystem mkISOSystem;
+  inherit (nixfiles-lib.types) mkCheckedType;
+
+  mkConfigurationOption = systemType:
+    mkOption {
+      description = "${systemType} configuration type";
+      type = with types; nullOr mkCheckedType "configuration";
+      default = null;
+    };
+in {
+  options.nixfiles.systems = let
+    systemModule = let
+      outerConfig = config;
+      outerOptions = options;
+    in
+      {
+        name,
+        config,
+        ...
+      }: {
+        options = {
+          enable =
+            lib.mkEnableOption ""
+            // {
+              description = ''
+                Whether to install this configuration into the flake outputs.
+              '';
+              default = true;
+            };
+
+          nixpkgs = mkOption {
+            description = "nixpkgs input to build system with";
+            type = nixfiles-lib.types.flake;
+            default = inputs.nixpkgs-unstable;
+          };
+
+          extraConfig = mkOption {
+            description = ''
+              Arguments to pass to nixpkgs.lib.nixosSystem
+            '';
+            type = types.attrs;
+            default = {};
+          };
+
+          system = mkOption {
+            description = "Nix system value";
+            type = types.str;
+            example = "x86_64-linux";
+          };
+
+          modules = mkOption {
+            description = "NixOS modules";
+            type = with types; listOf deferredModule;
+            default = [];
+          };
+
+          name = mkOption {
+            description = ''
+              Name of NixOS configuration. This influences the default
+              directory to load configuration from. This does *not* modify the
+              system's hostname, but should probably be set to the same value.
+            '';
+            type = lib.types.str;
+            default = name;
+          };
+
+          configPath = mkOption {
+            description = "Path to main system configuration module.";
+            type = lib.types.path;
+            default = self + "/hosts/${config.name}/configuration.nix";
+          };
+
+          home-manager = {
+            enable =
+              lib.mkEnableOption ""
+              // {
+                description = ''
+                  Whether to enable home-manager for this configuration.
+                '';
+                default = true;
+              };
+
+            input = mkOption {
+              description = "home-manager input";
+              type = nixfiles-lib.types.flake;
+              default = inputs.home-manager-unstable;
+            };
+
+            configPath = mkOption {
+              description = "Path to main home configuration module.";
+              type = lib.types.path;
+              default = self + "/hosts/${config.name}/home.nix";
+            };
+
+            modules = mkOption {
+              description = "home-manager modules";
+              type = with types; listOf deferredModule;
+            };
+          };
+
+          wsl =
+            lib.mkEnableOption ""
+            // {
+              description = ''
+                Whether to import WSL related configuration
+              '';
+            };
+
+          result = lib.mkOption {
+            description = "Resulting system configuration";
+            type = with types; nullOr (mkCheckedType "configuration");
+          };
+        };
+
+        config = {
+          home-manager.input = lib.mkIf (config.nixpkgs == inputs.nixpkgs) (lib.mkDefault inputs.home-manager);
+
+          modules = let
+            nixfilesModule = self + "/system";
+            defaultsModule = {...}: {
+              # Values for every single system that would not conceivably need
+              # to be made modular
+
+              # this should be set in the system config
+              # system.stateVersion = stateVersion;
+              nixpkgs = {
+                inherit (outerConfig.nixfiles.common) overlays;
+                config = {
+                  # not having the freedom to install unfree programs is unfree
+                  allowUnfree = true;
+                };
+              };
+              # this should be on by default and there is no reason to turn it
+              # off because this flake will literally stop working otheriwse
+              nix.settings.experimental-features = ["nix-command" "flakes"];
+            };
+            wslModule = {...}: {
+              imports = [
+                inputs.nix-wsl.nixosModules.wsl
+              ];
+              wsl.enable = true;
+              wsl.defaultUser = outerConfig.nixfiles.vars.username;
+            };
+          in
+            [
+              nixfilesModule
+              defaultsModule
+              # TODO
+              # import /hosts/ path
+              # home manager init
+            ]
+            ++ lib.optionals config.wsl wslModule;
+          extraConfig = {
+            inherit (config) system modules;
+            # TODO get rid of specialArgs and pass things as a module
+            specialArgs = let
+              inherit (self) outputs;
+            in {
+              inherit inputs outputs;
+              inherit (outerConfig.nixfiles) vars;
+              inherit (config) nixpkgs;
+              inherit (config.home-manager) input;
+            };
+          };
+          result = config.nixpkgs.lib.nixosSystem config.extraConfig;
+        };
+      };
+  in
+    lib.mkOption {
+      description = ''
+        NixOS system configurations
+      '';
+      type = with types; attrsOf (submodule systemModule);
+      default = {};
+    };
+
+  config = {
+    flake.nixosConfigurations = let
+      enabledSystems = filterAttrs (n: v: v.enable) cfg;
+    in
+      mapAttrs (_: v: v.result) enabledSystems;
+  };
+}
diff --git a/hosts/nixos-wsl/configuration.nix b/hosts/nixos-wsl/configuration.nix
index b9f59cd..228e40f 100644
--- a/hosts/nixos-wsl/configuration.nix
+++ b/hosts/nixos-wsl/configuration.nix
@@ -47,5 +47,8 @@
       device = "/";
       options = [ "bind" ];
     };
+
+    # standard disclaimer don't change this for any reason whatsoever
+    system.stateVersion = "23.11";
   };
 }
diff --git a/lib/nixfiles/flake-legacy.nix b/lib/nixfiles/flake-legacy.nix
index 3177d0a..5c4f336 100644
--- a/lib/nixfiles/flake-legacy.nix
+++ b/lib/nixfiles/flake-legacy.nix
@@ -1,44 +1,10 @@
 {
   self,
   lib,
+  moduleAttrs,
   ...
 }: let
-  overlays = let
-    nix-minecraft-patched-overlay = let
-      normal = inputs.nix-minecraft-upstream.overlays.default;
-      quilt = inputs.nix-minecraft.overlays.default;
-    in
-      lib.composeExtensions
-      normal
-      (final: prev: let
-        x = quilt final prev;
-      in {
-        inherit (x) quiltServers quilt-server;
-        minecraftServers = prev.minecraftServers // x.quiltServers;
-      });
-  in [
-    (final: prev: let
-      packages = import ./pkgs {inherit (prev) pkgs;};
-    in {
-      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
-  ];
+  inherit (moduleAttrs.config.nixfiles.common) overlays;
 
   ### Configuration
   # My username
diff --git a/lib/nixfiles/module.nix b/lib/nixfiles/module.nix
index bbb0a1f..131f450 100644
--- a/lib/nixfiles/module.nix
+++ b/lib/nixfiles/module.nix
@@ -1,6 +1,10 @@
-{lib, self, ...}: let
+{
+  lib,
+  self,
+  ...
+} @ moduleAttrs: let
   inherit (lib) types;
-  nixfiles-lib = (import ./.) {inherit lib self;};
+  nixfiles-lib = (import ./.) {inherit lib self moduleAttrs;};
 in {
   options.nixfiles.lib = lib.mkOption {
     description = "nixfiles library";
diff --git a/lib/nixfiles/types.nix b/lib/nixfiles/types.nix
index b81e3bd..04f5aa8 100644
--- a/lib/nixfiles/types.nix
+++ b/lib/nixfiles/types.nix
@@ -1,13 +1,21 @@
-{ pkgs, ... }:
-let
+{pkgs, ...}: let
   inherit (pkgs) lib;
   inherit (lib.types) mkOptionType;
   inherit (lib.options) mergeEqualOption;
-in
-{
+in {
+  mkCheckedType = type:
+    mkOptionType {
+      name = "${type}";
+      description = "Attribute set of type ${type}";
+      descriptionClass = "noun";
+      merge = mergeEqualOption;
+      check = value: value._type or "" == "${type}";
+    };
   flake = mkOptionType {
-    name="flake";
-    description="Nix flake";
+    name = "flake";
+    description = "Nix flake";
     descriptionClass = "noun";
-    merge = mergeEqualOption; check = (value: value._type or "" == "flake"); };
+    merge = mergeEqualOption;
+    check = value: value._type or "" == "flake";
+  };
 }

From 4aac8ea9add58b2394838f520214d7174c2169f1 Mon Sep 17 00:00:00 2001
From: NullBite <me@nullbite.com>
Date: Fri, 14 Feb 2025 00:29:55 -0500
Subject: [PATCH 4/5] flake/system: fully working mkSystem replacement

for some reason, the toplevel derivation is different for some systems,
but nix-diff only shows one file being different, specifically the order
of some config relating to kernel modules. however, the produced system
is functionally identical. i have no idea what could be responsible for
this change.
---
 flake/system.nix              | 74 ++++++++++++++++++++++++++++-------
 lib/nixfiles/flake-legacy.nix |  6 +--
 2 files changed, 62 insertions(+), 18 deletions(-)

diff --git a/flake/system.nix b/flake/system.nix
index 9047500..5507855 100644
--- a/flake/system.nix
+++ b/flake/system.nix
@@ -17,9 +17,9 @@
     mapAttrs
     ;
 
-  inherit (builtins) attrNames;
+  inherit (builtins) attrNames isNull;
 
-  inherit (nixfiles-lib.flake-legacy) mkSystem mkHome mkWSLSystem mkISOSystem;
+  inherit (nixfiles-lib.flake-legacy) mkSystem mkHome mkWSLSystem mkISOSystem homeManagerInit;
   inherit (nixfiles-lib.types) mkCheckedType;
 
   mkConfigurationOption = systemType:
@@ -70,7 +70,7 @@ in {
           };
 
           modules = mkOption {
-            description = "NixOS modules";
+            description = "Extra NixOS configuration modules.";
             type = with types; listOf deferredModule;
             default = [];
           };
@@ -85,10 +85,16 @@ in {
             default = name;
           };
 
-          configPath = mkOption {
-            description = "Path to main system configuration module.";
+          configRoot = mkOption {
+            description = "Path to directory containing system and home configuration modules.";
             type = lib.types.path;
-            default = self + "/hosts/${config.name}/configuration.nix";
+            default = self + "/hosts/${config.name}";
+          };
+
+          configuration = mkOption {
+            description = "Path/module of main NixOS configuration.";
+            type = with types; nullOr deferredModule;
+            default = config.configRoot + "/configuration.nix";
           };
 
           home-manager = {
@@ -107,14 +113,14 @@ in {
               default = inputs.home-manager-unstable;
             };
 
-            configPath = mkOption {
-              description = "Path to main home configuration module.";
-              type = lib.types.path;
-              default = self + "/hosts/${config.name}/home.nix";
+            configuration = mkOption {
+              description = "Path/module of main home-manager configuration.";
+              type = with types; nullOr deferredModule;
+              default = config.configRoot + "/home.nix";
             };
 
             modules = mkOption {
-              description = "home-manager modules";
+              description = "Extra home-manager modules";
               type = with types; listOf deferredModule;
             };
           };
@@ -162,15 +168,53 @@ in {
               wsl.enable = true;
               wsl.defaultUser = outerConfig.nixfiles.vars.username;
             };
+
+            homeManagerModule = let
+              homeManagerModuleInner = homeManagerInit {
+                inherit (config) nixpkgs system;
+                inherit (outerConfig.nixfiles.vars) username;
+                home-manager = config.home-manager.input;
+                module =
+                  if (isNull config.home-manager.configuration)
+                  then {}
+                  else config.home-manager.configuration;
+              };
+            in
+              {
+                config,
+                pkgs,
+                lib,
+                ...
+              }: let
+                inheritStateVersionModule = {lib, ...}: {
+                  config = {
+                    home.stateVersion = lib.mkDefault config.system.stateVersion;
+                  };
+                };
+              in {
+                imports = [
+                  # TODO placeholder using old function
+                  homeManagerModuleInner
+                ];
+
+                # previously, home-manager inherited stateVersion from nixos in
+                # a really hacky way that depended on the wrapper function.
+                # this should preserve that behavior in a much safer way by
+                # directly setting it in a module. ideally, it should probably
+                # be set manually, but I want to maintain backwards
+                # compatibility for now
+                options.home-manager.users = lib.mkOption {
+                  type = with lib.types; attrsOf (submodule inheritStateVersionModule);
+                };
+              };
           in
             [
               nixfilesModule
               defaultsModule
-              # TODO
-              # import /hosts/ path
-              # home manager init
             ]
-            ++ lib.optionals config.wsl wslModule;
+            ++ lib.optional (!(isNull config.configuration)) config.configuration
+            ++ lib.optional config.home-manager.enable homeManagerModule
+            ++ lib.optional config.wsl wslModule;
           extraConfig = {
             inherit (config) system modules;
             # TODO get rid of specialArgs and pass things as a module
diff --git a/lib/nixfiles/flake-legacy.nix b/lib/nixfiles/flake-legacy.nix
index 5c4f336..3d2a3e2 100644
--- a/lib/nixfiles/flake-legacy.nix
+++ b/lib/nixfiles/flake-legacy.nix
@@ -44,21 +44,21 @@ in rec {
         ${username} = [module];
         root = [rootModule];
       },
-      stateVersion,
+      stateVersion ? null,
     }: {
       config,
       lib,
       pkgs,
       ...
     }: let
-      mapUserModules = lib.attrsets.mapAttrs (user: modules: {...}: {
+      mapUserModules = lib.attrsets.mapAttrs (user: modules: {lib, ...}: {
         imports =
           [
             (self + "/home")
           ]
           ++ modules;
         config = {
-          home = {inherit stateVersion;};
+          home = lib.mkIf (!(builtins.isNull stateVersion)) {inherit stateVersion;};
         };
       });
       users = mapUserModules userModules;

From c869ec0fe34756d5a7e6d38bcba6d028dad169e2 Mon Sep 17 00:00:00 2001
From: NullBite <me@nullbite.com>
Date: Fri, 14 Feb 2025 00:39:50 -0500
Subject: [PATCH 5/5] flake: migrate nixosConfigurations to new config

---
 flake.nix | 70 +++++++++++++++++--------------------------------------
 1 file changed, 21 insertions(+), 49 deletions(-)

diff --git a/flake.nix b/flake.nix
index 5222c93..bb64e1c 100644
--- a/flake.nix
+++ b/flake.nix
@@ -181,10 +181,27 @@
               nix-minecraft-patched-overlay
             ];
 
-            systems.testsys = {
-              system = "x86_64-linux";
-              enable = false;
-            };
+            systems = {
+              slab.system = "x86_64-linux";
+              nullbox.system = "x86_64-linux";
+              rpi4.system = "aarch64-linux";
+
+              nixos-wsl = {
+                system = "x86_64-linux";
+                wsl = true;
+              };
+
+              # for eval testing
+              rpi4-x86_64 = {
+                system = "x86_64-linux";
+                name = "rpi4";
+                modules = [
+                  {
+                    nixpkgs.hostPlatform = "x86_64-linux";
+                  }
+                ];
+              };
+            }; # end systems
           };
 
           flake = let
@@ -284,51 +301,6 @@
 
             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 = {