{
  inputs.flake-utils.url = "github:numtide/flake-utils";

  outputs = {
    self,
    nixpkgs,
    flake-utils,
  }: let
    mapOverlayOverride = namespace: overlay: final: prev: let
      overlayPkgs = overlay final prev;
    in
      {
        "${namespace}" = builtins.removeAttrs overlayPkgs ["override"];
      }
      // (overlayPkgs.override or {});
  in
    flake-utils.lib.eachDefaultSystem (system: {
      formatter = (import nixpkgs {inherit system;}).alejandra;
    })
    // {
      templates = let
        system-flake = {
          path = ./templates/system-flake;
          description = "Opinionated flake for a NixOS system with Home Manager";
        };
      in {
        inherit system-flake;

        default = system-flake;
      };

      overlays = let
        overlay = mapOverlayOverride "trivium" (import ./pkgs);
      in {
        default = overlay;
        trivium = overlay;
      };

      lib = {
        mkSystemFlake = {
          flakes,
          system,
          formatter ? "alejandra",
          localOverlayPath ? /. + "${flakes.self}" + /pkgs,
          nixpkgsConfigPath ? localOverlayPath + /config,
          nixosSourcePath ? /. + "${flakes.self}" + /sys,
          nixosPlatformsPath ?
            if nixosSourcePath != null
            then nixosSourcePath + /platform
            else null,
          hmSourcePath ? /. + "${flakes.self}" + /home,
          hmPlatformsPath ?
            if hmSourcePath != null
            then hmSourcePath + /platform
            else null,
        }: let
          optionalFlake = name:
            if flakes ? "${name}"
            then flakes.${name}
            else null;

          requireFlake = name:
            if flakes ? "${name}"
            then flakes.${name}
            else throw "Required flake input '${name}' is required but was not provided";

          nur = optionalFlake "nur";
          nixpkgs = requireFlake "nixpkgs";
          unstable = optionalFlake "unstable";

          home-manager =
            if hmSourcePath != null
            then requireFlake "home-manager"
            else null;

          pkgs = importPkgs nixpkgs;

          importPkgs = flake:
            import flake ({
                inherit system;

                config = import ./pkgs/config nixpkgs.lib;
                overlays = let
                  conditions = [
                    {
                      overlay = nur.overlays.default;
                      condition = nur != null;
                    }
                    # NB: Preserve the relative order
                    {
                      overlay = self.overlays.trivium;
                      condition = true;
                    }
                    {
                      overlay = flakes.self.overlays.default;
                      condition = true;
                    }
                  ];
                in
                  builtins.map (cond: cond.overlay) (builtins.filter (cond: cond.condition) conditions);
              }
              // (
                if nixpkgsConfigPath != null
                then {
                  config = import nixpkgsConfigPath {inherit (nixpkgs) lib;};
                }
                else {}
              ));

          inherit (pkgs.trivium.lib) importAll;
        in
          with pkgs.lib;
            {
              formatter.${system} =
                if formatter == "alejandra"
                then pkgs.alejandra
                else if formatter == "nixpkgs-fmt"
                then pkgs.nixpkgs-fmt
                else throw "Unknown formatter: '${formatter}'";

              packages.${system} = pkgs.local;

              overlays.default = final: prev: let
                overlay =
                  if localOverlayPath != null
                  then import localOverlayPath
                  else (final: prev: {});
              in
                mapOverlayOverride "local" overlay final prev
                // optionalAttrs (unstable != null) {
                  unstable = importPkgs unstable;
                };
            }
            // optionalAttrs (nixosSourcePath != null) {
              nixosConfigurations = let
                nixosSystem = {modules}:
                  makeOverridable nixpkgs.lib.nixosSystem {
                    inherit modules pkgs system;

                    specialArgs = {
                      inherit flakes;
                    };
                  };

                hostConfig = platform:
                  nixosSystem {
                    modules = [
                      ./nixos
                      nixosSourcePath
                      platform
                    ];
                  };
              in
                mapAttrs (_: hostConfig) (importAll {root = nixosPlatformsPath;});
            }
            // optionalAttrs (hmSourcePath != null) {
              homeConfigurations = let
                registry = {...}: {
                  config.nix.registry =
                    mapAttrs
                    (_: value: {flake = value;})
                    flakes;
                };

                home = name: platform:
                  home-manager.lib.homeManagerConfiguration {
                    inherit pkgs;

                    extraSpecialArgs = {
                      inherit flakes;
                    };

                    modules = [
                      ./hm
                      hmSourcePath
                      platform
                      registry
                    ];
                  };
              in
                mapAttrs home (importAll {root = hmPlatformsPath;});
            };
      };
    };
}