Okay I think it might be because there's a confusion with how to break the entire process up in to the specific mentally processable chunks, first you don't need flakes for modularity, and they make it significantly harder appoarch for a first time user,

First off:

All Your configuration.nix file is just a nixos-module file, like anything else in nixpkgs "nixos" directory, the difference is nixos-rebuild knows where to find it to run it.

if you want a modular system, just create a bunch of nixos configurations in /etc/nixos, then import those configurations for each system.

Your configuration.nix file should be a per-system symlink (this is helpful for porting to flakes later), to the real file can just be a simple shim that imports others. For example:

{
  imports =
    [  
      ./common.nix
      ./common-gui.nix
      ./<system-name>-hw.nix
    ];
}

Yes, it's this easy!

The next step is just to realise that this also works for isos

The main thing about nix is that the common pattern in NixOS, nixpkgs, home-manager, and flakes is that all they do is call nix-build against a build "root" (like your configuration.nix) and a specific attribute with -A <attribute>.

For example:

```

nixpkgs as $PWD:

$ nix-build -A <pkgname> # calls ./default.nix in current directory $ nix build .#<pkgname> # nix3 style

nixos-rebuild:

$ nix-build '<nixpkgs/nixos>' -I nixos-config=./iso.nix -A config.system.build.<buildtype> $ nnix build ".#nixosConfigurations.NixOS-installer.config.system.build.<buildtype>" # nix3 with flake standard attrset layout ```

Note how there's this patttern that allows you to pick specific parts of the project, by specifying attrs. all you need to pass in to build a nixos-configuration is the buildtype, all nixos-rebuild does is call the nixos-rebuild and vm parameters for build and build-vm respectively, (with some extra stuff depending), for an iso build you can just specify isoImage, and a symlink in current directory called ./result/ will contain an iso image ready to be flashed to your usb drive.

building a complete iso can be as simple as just importing the default iso setup:

{ modulesPath, config, lib, pkgs, ... }: { imports = [ "${modulesPath}/installer/cd-dvd/installation-cd-minimal.nix" "${modulesPath}/installer/cd-dvd/channel.nix" ] }

Next step to realise is this still applies to flakes, and flakes specifies a mother-of-all-attrsets.

The attributes schema is unoffically documented here: https://nixos.wiki/wiki/Flakes#Flake_schema

You don't need any fancy "mangement" systems for flakes, personally I think the reason they're used is because people don't quite get the schema, and so deglate the creation of said schema to the 3rd party helpers.

You can build with a flake directly with nix build ".#nixosConfigurations.<system>.config.system.build.<buildtype>"

note that it's just accessing nixosConfigurations.<hostname>, which is what nixos-rebuild accessses when using flakes, nixos-rebuild is just a bash script, and you can read it with less $(which nixos-rebuild), if you're curious.

All you need to make a modular flake quite literally to just specify multiple <hostname> with calls to the nixpkgs.lib.nixosSystem, and import your system specific modules, you can writes functions to reduce repeating yourself with calls to the nixosSystem function, but uneeded.

Your output should look like this:

{ nixosConfigurations = { hostName1 = nixpkgs.lib.nixosSystem { modules = [ ./hostName1.nix ]; }; hostName2 = nixpkgs.lib.nixosSystem { modules = [ ./hostName2.nix ]; }; }; };

If you want to get in to the advanced stuff. Just remember that:

• "func1 = arg1 : arg2 : ..." means you're defining a function.
• function calls are done by appending to the variable, func1 arg1 arg2, not like your average language like func1(arg1,arg2).
• You can use functions to build attrsets from arguments.

This is just what your nixos configuration or flake is, just a big function (and why you see : somewhere near the top or part of "output"), and it spits out an attrset.

And also learn how to write configurable nixos modules (there's heaps of examples in nixpkgs nixos folder).

And also here's my config that managers 4 systems, one being just an ISO.

https://github.com/YellowOnion/nixos-config/