{
  description = "Thor system configuration";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/release-22.11";
    nixpkgs-u.url = "github:NixOS/nixpkgs/nixos-unstable";
    home-manager = { url = "github:nix-community/home-manager/release-22.05"; inputs.nixpkgs.follows = "nixpkgs"; };

    agenix = { url = "github:ryantm/agenix"; inputs.nixpkgs.follows = "nixpkgs"; };
    deploy-rs = { url = "github:serokell/deploy-rs"; inputs = { nixpkgs.follows = "nixpkgs"; }; };
    flake-utils.url = "github:numtide/flake-utils";
    nixos-generators = { url = "github:nix-community/nixos-generators"; inputs = { nixpkgs.follows = "nixpkgs"; }; };
    nixos-hardware.url = "github:NixOS/nixos-hardware";
    nix-rice = { url = "github:bertof/nix-rice"; inputs = { nixpkgs.follows = "nixpkgs"; flake-utils.follows = "flake-utils"; }; };
    pre-commit-hooks = { url = "github:cachix/pre-commit-hooks.nix"; inputs = { nixpkgs.follows = "nixpkgs"; flake-utils.follows = "flake-utils"; }; };
  };

  outputs =
    { self
    , nixpkgs
    , nixpkgs-u
    , home-manager
    , agenix
    , deploy-rs
    , flake-utils
    , nixos-generators
    , nixos-hardware
    , nix-rice
    , pre-commit-hooks
    }:
    let
      config = {
        allowUnfree = true;
        extraOptions = "experimental-features = nix-command flakes";
        permittedInsecurePackages = [
          "electron-9.4.4" # authy dependency
          "qtwebkit-5.212.0-alpha4" # mendeley dependency
        ];
      };

      overlays = [
        # Combine stable and unstable packages
        (_: _: {
          stable = import nixpkgs { inherit config overlays; };
          unstable = import nixpkgs-u { inherit config overlays; };
        })

        # Nix rice
        nix-rice.overlays.default
        (import ./rice.nix)

        # Flakes packages
        (self: _: {
          clipedit = self.callPackage ./custom/clipedit { };
          update-background = self.callPackage ./custom/update-background {
            backgrounds_directory = "$HOME/Immagini/Sfondi/1080+/1440+";
          };
          lockscreen = self.callPackage ./custom/lockscreen {
            palette = self.rice.colorPalette;
            font = self.rice.font.normal;
          };
          sddm-theme-clairvoyance = self.callPackage ./custom/sddm-theme-clairvoyance {
            wallpaper = ./wallpapers/comfy_waves.jpg;
          };
        })
      ];

      basic = with flake-utils.lib; eachDefaultSystem (system:
        let
          pkgs = import nixpkgs-u { inherit system config overlays; };
        in
        {
          formatter = pkgs.nixpkgs-fmt;

          checks = {
            pre-commit-check = pre-commit-hooks.lib.${system}.run {
              src = ./.;
              hooks = {
                deadnix.enable = true;
                nixpkgs-fmt.enable = true;
                nix-linter.enable = true;
                statix.enable = true;
              };
            };
          };

          devShells.default = pkgs.mkShell {
            buildInputs = with pkgs; [
              deploy-rs.packages.${system}.deploy-rs
            ];
            shellHook = ''
              ${self.checks.${system}.pre-commit-check.shellHook}
            '';
            LOCAL_KEY = "/etc/nix/key";
          };
        });

      commonModules = [
        # Nix configuration
        {
          nixpkgs = { inherit overlays config; };
          nix = {
            extraOptions = "experimental-features = nix-command flakes";
            registry = {
              stable = { from = { id = "stable"; type = "indirect"; }; flake = nixpkgs; };
              unstable = { from = { id = "unstable"; type = "indirect"; }; flake = nixpkgs-u; };
            };
          };
        }

        # Home manager configuration
        home-manager.nixosModules.home-manager
        { home-manager = { useGlobalPkgs = true; useUserPackages = true; }; }
        agenix.nixosModule
        {
          # age.secrets.oauth_proxy_client_credentials.file = ./secrets/oauth_proxy_client_credentials.age;
        }

        ./nixos_modules/bertof_user.nix
        ./nixos_modules/distributed.nix
        ./nixos_modules/remote-deploy.nix
        ./nixos_modules/extended_registry.nix
        ./nixos_modules/automatic-garbage-collection.nix
        ./nixos_modules/automatic-upgrade.nix
        ./nixos_modules/zerotier.nix
      ];

      thorConfig = {
        nixosConfigurations = {
          thor = nixpkgs.lib.nixosSystem rec {
            system = "x86_64-linux";
            modules = commonModules ++ [
              { nixpkgs.config = config // { cudaSupport = true; }; }
              ./thor/hardware-configuration.nix
              nixos-hardware.nixosModules.common-cpu-amd
              nixos-hardware.nixosModules.common-pc-ssd
              ./thor/configuration.nix

              ./nixos_modules/pro_audio.nix
              ./nixos_modules/sesar.nix
              ./nixos_modules/pentablet.nix

              { home-manager.users.bertof = import ./thor/hm.nix; }
            ];
          };
        };
      };

      odinConfig = {
        nixosConfigurations =
          let
            odinCommonModules = [
              nixos-hardware.nixosModules.common-cpu-intel
              nixos-hardware.nixosModules.common-pc-laptop
              nixos-hardware.nixosModules.common-pc-laptop-ssd
              ./odin/hardware-configuration.nix
              ./odin/common_configuration.nix

              ./nixos_modules/pro_audio.nix
              ./nixos_modules/sesar.nix
              ./nixos_modules/pentablet.nix

              { home-manager.users.bertof = import ./odin/hm.nix; }
            ];
          in
          rec {
            odin-nvidia = nixpkgs.lib.nixosSystem rec {
              system = "x86_64-linux";
              modules = commonModules ++ odinCommonModules ++ [
                { nixpkgs.config = config // { cudaSupport = true; }; }
                ./odin/configuration-nvidia.nix
              ];
            };

            odin-intel = nixpkgs.lib.nixosSystem rec {
              system = "x86_64-linux";
              modules = commonModules ++ odinCommonModules ++ [
                ./odin/configuration-intel.nix
              ];
            };

            odin = odin-intel;
          };
      };

      # freyaConfig = {
      #   nixosConfigurations = rec {
      #     freya = nixpkgs.lib.nixosSystem rec {
      #       system = "aarch64-linux";
      #       modules = commonModules ++ [
      #         nixos-hardware.nixosModules.raspberry-pi-4
      #         ./freya/hardware-configuration.nix
      #         ./freya/configuration.nix
      #         { home-manager.users.bertof = import ./freya/hm.nix; }
      #       ];
      #     };
      #   };
      # };

      baldurConfig = {
        nixosConfigurations = rec {
          baldur = nixpkgs.lib.nixosSystem rec {
            system = "x86_64-linux";
            modules = commonModules ++ [
              ./baldur/hardware-configuration.nix
              ./baldur/configuration.nix
              ./nixos_modules/digitalocean.nix
              { home-manager.users.bertof = import ./baldur/hm.nix; }
            ];
          };
        };
      };

      lokiConfig = {
        nixosConfigurations = rec {
          loki = nixpkgs.lib.nixosSystem rec {
            system = "x86_64-linux";
            modules = commonModules ++ [
              nixos-hardware.nixosModules.common-cpu-intel
              nixos-hardware.nixosModules.common-pc-ssd
              ./loki/hardware-configuration.nix
              ./loki/configuration.nix
              { home-manager.users.bertof = import ./loki/hm.nix; }
            ];
          };
        };
      };

      deployments = {
        # Deploy-rs checks
        checks = builtins.mapAttrs (_system: deployLib: deployLib.deployChecks self.deploy) deploy-rs.lib;

        # Map nodes to Deploy-rs deployments
        deploy.nodes = {
          loki = {
            hostname = "loki.local";
            profiles.system = {
              user = "root";
              path = deploy-rs.lib.x86_64-linux.activate.nixos self.nixosConfigurations.loki;
            };
          };

          baldur = {
            hostname = "baldur.bertof.net";
            profiles.system = {
              user = "root";
              path = deploy-rs.lib.x86_64-linux.activate.nixos self.nixosConfigurations.baldur;
            };
          };
        };
      };

      images = with flake-utils.lib; let
        installerModules = [
          # Nix configuration
          {
            nixpkgs = { inherit overlays config; };
            nix = {
              extraOptions = "experimental-features = nix-command flakes";
              registry = {
                stable = { from = { id = "stable"; type = "indirect"; }; flake = nixpkgs; };
                unstable = { from = { id = "unstable"; type = "indirect"; }; flake = nixpkgs-u; };
              };
            };
          }

          ./nixos_modules/bertof_user.nix
          ./nixos_modules/distributed.nix
          ./nixos_modules/extended_registry.nix
          ./nixos_modules/zerotier.nix
        ];
      in
      eachSystem [ system.x86_64-linux system.aarch64-linux ] (system:
        {
          packages = {
            # Installer ISO
            install-iso = nixos-generators.nixosGenerate {
              inherit system;
              modules = installerModules ++ [ ./nixos_modules/installer.nix ];
              format = "install-iso";
            };

            # Installer DigitalOcean
            do = nixos-generators.nixosGenerate {
              inherit system;
              modules = installerModules ++ [ ./nixos_modules/installer.nix ];
              format = "do";
            };
          };
        });

    in
    builtins.foldl' nixpkgs.lib.recursiveUpdate { } [
      basic
      thorConfig
      odinConfig
      # freyaConfig
      baldurConfig
      lokiConfig
      deployments
      images
    ];
}