nilla: add ci.check

.forgejo/workflows/build.yaml

@@ -8,4 +8,5 @@ jobs:
     runs-on: native
     steps:
       - uses: actions/checkout@v4
-      - run: nix flake check --all-systems
+      - run: nix-build -A ci.check
+      - run: ./result

.gitignore

@@ -1 +1,2 @@
 .direnv
+result

assets/default.nix

@@ -1,8 +1,8 @@
-{ lib, ... }:
+{ lib }:
 {
-  options.assets = lib.mkOption {
+  options.assets = lib.options.create {
-    type = lib.types.unspecified;
+    type = lib.types.raw;
-    readOnly = true;
+    writable = false;
   };
 
   config.assets = {

default.nix

@@ -0,0 +1,8 @@
+let
+  nilla = import ./nilla.nix { };
+  getPackage = name: nilla.packages.${name}.result.${builtins.currentSystem};
+in
+{
+  ci.check = getPackage "ci-check";
+  formatter = getPackage "formatter";
+}

flake.lock

@@ -1,5 +1,21 @@
 {
   "nodes": {
+    "__flake-compat": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1743033641,
+        "narHash": "sha256-7L0/So1J21N4VHaZRzdK6Ywj3+NLdHfM8z0o5XVuPeo=",
+        "ref": "refs/heads/main",
+        "rev": "5bbdeaea85d5f396f01e8af94bcb6f29d5af22f7",
+        "revCount": 83,
+        "type": "git",
+        "url": "https://git.lix.systems/lix-project/flake-compat.git"
+      },
+      "original": {
+        "type": "git",
+        "url": "https://git.lix.systems/lix-project/flake-compat.git"
+      }
+    },
     "agenix": {
       "inputs": {
         "darwin": [
@@ -79,11 +95,11 @@
     "conduit-src": {
       "flake": false,
       "locked": {
-        "lastModified": 1742005420,
+        "lastModified": 1742789401,
-        "narHash": "sha256-v4LCx7VUZ+8Hy1+6ziREVY/QEADjZbo8c0h9eU7nMVY=",
+        "narHash": "sha256-oZ8TPrtzPwXupsAfwMjLRI/s0/PokqL3q1ejeGVn5lE=",
         "owner": "famedly",
         "repo": "conduit",
-        "rev": "063d13a0e10619f17bc21f0dd291c5a733581394",
+        "rev": "a7e6f60b41122761422df2b7bcc0c192416f9a28",
         "type": "gitlab"
       },
       "original": {
@@ -115,11 +131,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1742382197,
+        "lastModified": 1743359449,
-        "narHash": "sha256-5OtFbbdKAkWDVuzjs1J9KwdFuDxsEvz0FZX3xR2jEUM=",
+        "narHash": "sha256-unjpn5SCn55Ma+/grXuTybICgUa/bcPGKxJMt9lLoIg=",
         "owner": "lnl7",
         "repo": "nix-darwin",
-        "rev": "643b57fd32135769f809913663130a95fe6db49e",
+        "rev": "fe625481e50d05aa452d684d5228e5059b4942d4",
         "type": "github"
       },
       "original": {
@@ -177,11 +193,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1742432361,
+        "lastModified": 1743383039,
-        "narHash": "sha256-FlqTrkzSn6oPR5iJTPsCQDd0ioMGzzxnPB+2wve9W2w=",
+        "narHash": "sha256-Palj4EeFRS3tLl2aK0FgE01SBWRbqD4vKE+SNBJaYo4=",
         "owner": "bandithedoge",
         "repo": "nixpkgs-firefox-darwin",
-        "rev": "c868ff433ea5123e837a62ae689543045187d7a4",
+        "rev": "96f1d9e12f0efbbc4cea47c0a06a1667ed90e5f8",
         "type": "github"
       },
       "original": {
@@ -244,26 +260,6 @@
       }
     },
     "flake-parts_2": {
-      "inputs": {
-        "nixpkgs-lib": [
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1741352980,
-        "narHash": "sha256-+u2UunDA4Cl5Fci3m7S643HzKmIDAe+fiXrLqYsR2fs=",
-        "owner": "hercules-ci",
-        "repo": "flake-parts",
-        "rev": "f4330d22f1c5d2ba72d3d22df5597d123fdb60a9",
-        "type": "github"
-      },
-      "original": {
-        "owner": "hercules-ci",
-        "repo": "flake-parts",
-        "type": "github"
-      }
-    },
-    "flake-parts_3": {
       "inputs": {
         "nixpkgs-lib": "nixpkgs-lib"
       },
@@ -359,11 +355,11 @@
         "rust-overlay": "rust-overlay"
       },
       "locked": {
-        "lastModified": 1742479163,
+        "lastModified": 1743346877,
-        "narHash": "sha256-YC0zdGyZMu7seA2Jm1mxtcxE4lSeVwvCPMfWzJ8+o/c=",
+        "narHash": "sha256-WczB9koq4xvdBZoMLW8VFT16RGaDrJXyA0rDTg2GFVU=",
         "owner": "helix-editor",
         "repo": "helix",
-        "rev": "b7d735ffe66a03ab5970e5f860923aada50d4e4c",
+        "rev": "e148d8b3110ace99505c0871714cd64391cc4ba3",
         "type": "github"
       },
       "original": {
@@ -379,11 +375,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1742501496,
+        "lastModified": 1743360001,
-        "narHash": "sha256-LYwyZmhckDKK7i4avmbcs1pBROpOaHi98lbjX1fmVpU=",
+        "narHash": "sha256-HtpS/ZdgWXw0y+aFdORcX5RuBGTyz3WskThspNR70SM=",
         "owner": "nix-community",
         "repo": "home-manager",
-        "rev": "d725df5ad8cee60e61ee6fe3afb735e4fbc1ff41",
+        "rev": "b6fd653ef8fbeccfd4958650757e91767a65506d",
         "type": "github"
       },
       "original": {
@@ -395,11 +391,11 @@
     "lix": {
       "flake": false,
       "locked": {
-        "lastModified": 1742411066,
+        "lastModified": 1743274305,
-        "narHash": "sha256-8vXOKPQFRzTjapsRnTJ1nuFjUfC+AGI2ybdK5cAEHZ8=",
+        "narHash": "sha256-gsPA3AAGi3pucRpzJbhWWyyOBv2/2OjAjU/SlcSE8Vc=",
         "ref": "refs/heads/main",
-        "rev": "2491b7cc2128ee440d24768c4521c38b1859fc28",
+        "rev": "d169c092fc28838a253be136d17fe7de1292c728",
-        "revCount": 17705,
+        "revCount": 17746,
         "type": "git",
         "url": "https://git.lix.systems/lix-project/lix.git"
       },
@@ -420,11 +416,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1741894565,
+        "lastModified": 1742945498,
-        "narHash": "sha256-2FD0NDJbEjUHloVrtEIms5miJsj1tvQCc/0YK5ambyc=",
+        "narHash": "sha256-MB/b/xcDKqaVBxJIIxwb81r8ZiGLeKEcqokATRRroo8=",
         "ref": "refs/heads/main",
-        "rev": "a6da43f8193d9e329bba1795c42590c27966082e",
+        "rev": "fa69ae26cc32dda178117b46487c2165c0e08316",
-        "revCount": 136,
+        "revCount": 138,
         "type": "git",
         "url": "https://git.lix.systems/lix-project/nixos-module.git"
       },
@@ -458,7 +454,7 @@
     },
     "niko-nur": {
       "inputs": {
-        "flake-parts": "flake-parts_3",
+        "flake-parts": "flake-parts_2",
         "nixpkgs": "nixpkgs"
       },
       "locked": {
@@ -475,6 +471,22 @@
         "type": "github"
       }
     },
+    "nilla": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1743409018,
+        "narHash": "sha256-fghnO1XmDnM0U6PdFu0GquNIRQNxH2IQ1AgifyZk6Wk=",
+        "owner": "nilla-nix",
+        "repo": "nilla",
+        "rev": "6747fe62879d7d15c96808bc370a52941287772c",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nilla-nix",
+        "repo": "nilla",
+        "type": "github"
+      }
+    },
     "nix-github-actions": {
       "inputs": {
         "nixpkgs": [
@@ -557,11 +569,11 @@
     },
     "nixpkgs_2": {
       "locked": {
-        "lastModified": 1742395137,
+        "lastModified": 1743259260,
-        "narHash": "sha256-WWNNjCSzQCtATpCFEijm81NNG1xqlLMVbIzXAiZysbs=",
+        "narHash": "sha256-ArWLUgRm1tKHiqlhnymyVqi5kLNCK5ghvm06mfCl4QY=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "2a725d40de138714db4872dc7405d86457aa17ad",
+        "rev": "eb0e0f21f15c559d2ac7633dc81d079d1caf5f5f",
         "type": "github"
       },
       "original": {
@@ -593,6 +605,7 @@
     },
     "root": {
       "inputs": {
+        "__flake-compat": "__flake-compat",
         "agenix": "agenix",
         "attic": "attic",
         "conduit-src": "conduit-src",
@@ -601,13 +614,13 @@
         "disko": "disko",
         "fenix": "fenix",
         "firefox-darwin": "firefox-darwin",
-        "flake-parts": "flake-parts_2",
         "helix": "helix",
         "home-manager": "home-manager",
         "lix": "lix",
         "lix-module": "lix-module",
         "mailserver": "mailserver",
         "niko-nur": "niko-nur",
+        "nilla": "nilla",
         "nixpkgs": "nixpkgs_2",
         "racket": "racket",
         "treefmt": "treefmt",
@@ -742,11 +755,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1742370146,
+        "lastModified": 1743081648,
-        "narHash": "sha256-XRE8hL4vKIQyVMDXykFh4ceo3KSpuJF3ts8GKwh5bIU=",
+        "narHash": "sha256-WRAylyYptt6OX5eCEBWyTwOEqEtD6zt33rlUkr6u3cE=",
         "owner": "numtide",
         "repo": "treefmt-nix",
-        "rev": "adc195eef5da3606891cedf80c0d9ce2d3190808",
+        "rev": "29a3d7b768c70addce17af0869f6e2bd8f5be4b7",
         "type": "github"
       },
       "original": {
@@ -814,11 +827,11 @@
         "rust-overlay": "rust-overlay_2"
       },
       "locked": {
-        "lastModified": 1741803511,
+        "lastModified": 1743151937,
-        "narHash": "sha256-DcCGBWvAvt+OWI+EcPRO+/IXZHkFgPxZUmxf2VLl8no=",
+        "narHash": "sha256-SjfGN+3wrzgRvzpziowTQUIr/o6ac5iMniua0ra6elo=",
         "owner": "dj95",
         "repo": "zjstatus",
-        "rev": "df9c77718f7023de8406e593eda6b5b0bc09cddd",
+        "rev": "2772e18d1bf57b5fe24c7e2c86a6cbec0475cd88",
         "type": "github"
       },
       "original": {

flake.nix

@@ -1,86 +1,8 @@
 {
-  outputs =
+  outputs = inputs: (import ./nilla.nix { inherit inputs; }).flake;
-    inputs@{ flake-parts, ... }:
-    flake-parts.lib.mkFlake { inherit inputs; } {
-      systems = [
-        "x86_64-linux"
-        "aarch64-linux"
-        "aarch64-darwin"
-      ];
-
-      imports = [
-        inputs.treefmt.flakeModule
-
-        ./assets
-        ./hosts
-        ./modules
-        ./wrappers
-        ./pkgs
-        ./services
-      ];
-
-      perSystem =
-        {
-          inputs',
-          self',
-          pkgs,
-          ...
-        }:
-        {
-          devShells.default = pkgs.mkShellNoCC {
-            packages = [
-              inputs'.agenix.packages.agenix
-              self'.packages.attic-client
-              # TODO: Contribute darwin support to nh
-              pkgs.nh
-            ];
-          };
-
-          packages = {
-            # Re-export it for convenience and for caching
-            inherit (inputs'.attic.packages) attic-client attic-server;
-            base-packages = pkgs.symlinkJoin {
-              name = "settei-base";
-              paths = with self'.packages; [
-                helix
-                fish
-                git-commit-last
-                git-fixup
-              ];
-            };
-          };
-
-          treefmt = {
-            programs.deadnix.enable = true;
-            programs.nixfmt.enable = true;
-            programs.statix.enable = true;
-            programs.fish_indent.enable = true;
-            programs.deno.enable = true;
-            programs.stylua.enable = true;
-            programs.shfmt.enable = true;
-            settings.global.excludes = [
-              # agenix
-              "*.age"
-
-              # racket
-              "*.rkt"
-              "**/rashrc"
-
-              # custom assets
-              "*.png"
-              "*.svg"
-            ];
-            settings.on-unmatched = "fatal";
-          };
-        };
-    };
 
   inputs = {
     nixpkgs.url = "github:nixos/nixpkgs?ref=nixpkgs-unstable";
-    flake-parts = {
-      url = "github:hercules-ci/flake-parts";
-      inputs.nixpkgs-lib.follows = "nixpkgs";
-    };
     disko = {
       url = "github:nix-community/disko";
       inputs.nixpkgs.follows = "nixpkgs";
@@ -168,27 +90,13 @@
       url = "github:numtide/treefmt-nix";
       inputs.nixpkgs.follows = "nixpkgs";
     };
+    __flake-compat = {
+      url = "git+https://git.lix.systems/lix-project/flake-compat.git";
+      flake = false;
+    };
+    nilla = {
+      url = "github:nilla-nix/nilla";
+      flake = false;
     };
-
-  /*
-    TODO: Uncomment once (if ever?) nixConfig makes sense in flakes
-    nixConfig = {
-      extra-substituters = [
-        "https://hyprland.cachix.org"
-        "https://cache.garnix.io"
-        "https://nix-community.cachix.org"
-        "https://hercules-ci.cachix.org"
-        "https://nrabulinski.cachix.org"
-        "https://cache.nrab.lol"
-      ];
-      extra-trusted-public-keys = [
-        "hyprland.cachix.org-1:a7pgxzMz7+chwVL3/pzj6jIBMioiJM7ypFP8PwtkuGc="
-        "cache.garnix.io:CTFPyKSLcx5RMJKfLo5EEPUObbA78b0YQ2DTCJXqr9g="
-        "nix-community.cachix.org-1:mB9FSh9qf2dCimDSUo8Zy7bkq5CX+/rkCWyvRCYg3Fs="
-        "hercules-ci.cachix.org-1:ZZeDl9Va+xe9j+KqdzoBZMFJHVQ42Uu/c/1/KMC5Lw0="
-        "nrabulinski.cachix.org-1:Q5FD7+1c68uH74CQK66UWNzxhanZW8xcg1LFXxGK8ic="
-        "cache.nrab.lol-1:CJl1TouOyuJ1Xh4tZSXLwm3Upt06HzUNZmeyuEB9EZg="
-      ];
   };
-  */
 }

hosts/default.nix

@@ -1,11 +1,11 @@
 {
   config,
-  self,
-  inputs,
-  ...
 }:
+let
+  inputs = builtins.mapAttrs (_: input: input.result) config.inputs;
+in
 {
-  imports = [
+  includes = [
     ./kazuki
     ./hijiri-vm
     ./hijiri
@@ -16,58 +16,40 @@
     ./youko
   ];
 
-  builders =
+  config.systems.builders =
     let
       sharedOptions = {
         _file = ./default.nix;
 
         settei.sane-defaults.allSshKeys = config.assets.sshKeys.user;
         settei.flake-qol.inputs = inputs // {
-          settei = self;
+          settei = inputs.self;
         };
       };
-
-      baseNixos = inputs.nixpkgs.lib.nixosSystem {
-        modules = [
-          self.nixosModules.combined
-          sharedOptions
-        ];
-        specialArgs.configurationName = "base";
-      };
-
-      baseDarwin = inputs.darwin.lib.darwinSystem {
-        modules = [
-          self.darwinModules.combined
-          sharedOptions
-        ];
-        specialArgs.configurationName = "base";
-      };
     in
     {
       nixos =
         name: module:
-        baseNixos.extendModules {
+        inputs.nixpkgs.lib.nixosSystem {
           modules = [
+            config.nixosModules.combined
+            sharedOptions
             module
-            config.__extraHostConfigs.${name} or { }
+            config.extraHostConfigs.${name} or { }
           ];
           specialArgs.configurationName = name;
         };
 
       darwin =
         name: module:
-        let
+        inputs.darwin.lib.darwinSystem {
-          eval = baseDarwin._module.args.extendModules {
           modules = [
+            config.darwinModules.combined
+            sharedOptions
             module
-              config.__extraHostConfigs.${name} or { }
+            config.extraHostConfigs.${name} or { }
           ];
           specialArgs.configurationName = name;
         };
-        in
-        eval
-        // {
-          system = eval.config.system.build.toplevel;
-        };
     };
 }

hosts/hijiri-vm/default.nix

@@ -1,5 +1,5 @@
 {
-  configurations.nixos.hijiri-vm =
+  config.systems.nixos.hijiri-vm.module =
     {
       modulesPath,
       lib,

hosts/hijiri/default.nix

@@ -1,5 +1,5 @@
 {
-  configurations.darwin.hijiri =
+  config.systems.darwin.hijiri.module =
     {
       config,
       pkgs,

hosts/installer/default.nix

@@ -1,6 +1,6 @@
 { lib, ... }:
 {
-  configurations.nixos =
+  config.configurations.nixos =
     let
       mkInstaller =
         system:

hosts/kazuki/default.nix

@@ -1,5 +1,5 @@
 {
-  configurations.nixos.kazuki =
+  config.systems.nixos.kazuki.module =
     {
       modulesPath,
       ...

hosts/kogata/default.nix

@@ -1,5 +1,5 @@
 {
-  configurations.darwin.kogata =
+  config.systems.darwin.kogata.module =
     { pkgs, ... }:
     {
       nixpkgs.system = "aarch64-darwin";

hosts/ude/default.nix

@@ -1,5 +1,5 @@
 {
-  configurations.nixos.ude =
+  config.systems.nixos.ude.module =
     {
       config,
       modulesPath,

hosts/youko/default.nix

@@ -1,5 +1,5 @@
 {
-  configurations.nixos.youko =
+  config.systems.nixos.youko.module =
     {
       config,
       lib,

inputs.nix

@@ -0,0 +1,15 @@
+let
+  lock = builtins.fromJSON (builtins.readFile ./flake.lock);
+  inherit (lock.nodes.__flake-compat.locked) narHash rev url;
+  flake-compat = builtins.fetchTarball {
+    url = "${url}/archive/${rev}.tar.gz";
+    sha256 = narHash;
+  };
+  flake = import flake-compat {
+    src = ./.;
+    copySourceTreeToStore = false;
+    useBuiltinsFetchTree = true;
+  };
+in
+# Workaround for https://github.com/nilla-nix/nilla/issues/14
+builtins.mapAttrs (_: input: input // { type = "derivation"; }) flake.inputs

modules/default.nix

@@ -1,29 +1,21 @@
 {
   config,
-  inputs,
-  ...
 }:
 let
-  flakeModule = import ./flake { inherit (inputs) nixpkgs darwin home-manager; };
+  inputs = builtins.mapAttrs (_: input: input.result) config.inputs;
+  perInput = system: flake: {
+    packages = flake.packages.${system};
+  };
 in
 {
-  imports = [
+  config.homeModules = rec {
-    flakeModule
-  ];
-
-  flake.homeModules = rec {
     settei = ./home;
     default = settei;
   };
 
-  flake.flakeModules = rec {
+  config.nixosModules = rec {
-    settei = flakeModule;
-    default = settei;
-  };
-
-  flake.nixosModules = rec {
     settei = import ./system {
-      inherit (config) perInput;
+      inherit perInput;
       isLinux = true;
     };
     combined = {
@@ -45,9 +37,9 @@ in
     default = combined;
   };
 
-  flake.darwinModules = rec {
+  config.darwinModules = rec {
     settei = import ./system {
-      inherit (config) perInput;
+      inherit perInput;
       isLinux = false;
     };
     combined = {

modules/flake/configurations.nix

@@ -1,54 +0,0 @@
-{
-  nixpkgs,
-  darwin,
-  home-manager,
-}:
-{
-  config,
-  lib,
-  ...
-}:
-with lib;
-{
-  _file = ./configurations.nix;
-
-  options = {
-    # Those functions take the final arguments and emit a valid configuration.
-    # Probably should hardly ever be overriden
-    builders = {
-      nixos = mkOption {
-        type = types.functionTo types.unspecified;
-        default = _name: nixpkgs.lib.nixosSystem;
-      };
-      darwin = mkOption {
-        type = types.functionTo types.unspecified;
-        default = _name: darwin.lib.darwinSystem;
-      };
-      home = mkOption {
-        type = types.functionTo types.unspecified;
-        default = _name: home-manager.lib.homeManagerConfiguration;
-      };
-    };
-
-    configurations = {
-      nixos = mkOption {
-        type = types.lazyAttrsOf types.deferredModule;
-        default = { };
-      };
-      darwin = mkOption {
-        type = types.lazyAttrsOf types.deferredModule;
-        default = { };
-      };
-      home = mkOption {
-        type = types.lazyAttrsOf types.deferredModule;
-        default = { };
-      };
-    };
-  };
-
-  config.flake = {
-    nixosConfigurations = mapAttrs config.builders.nixos config.configurations.nixos;
-    darwinConfigurations = mapAttrs config.builders.darwin config.configurations.darwin;
-    homeConfigurations = mapAttrs config.builders.home config.configurations.home;
-  };
-}

modules/flake/default.nix

@@ -1,13 +0,0 @@
-{
-  nixpkgs,
-  darwin,
-  home-manager,
-}:
-{
-  _file = ./default.nix;
-
-  imports = [
-    (import ./configurations.nix { inherit nixpkgs darwin home-manager; })
-    ./services.nix
-  ];
-}

modules/flake/services.nix

@@ -1,95 +0,0 @@
-# List of features I want this module to eventually have
-# TODO: Automatic port allocation
-# TODO: Making it possible to conveniently isolate services (running them in NixOS containers)
-# TODO: Handling specializations
-# TODO: Convenient http handling
-# TODO: Automatic backup
-{ config, lib, ... }:
-let
-  serviceModule =
-    { config, ... }:
-    {
-      options = {
-        host = lib.mkOption {
-          type = lib.types.str;
-        };
-        ports = lib.mkOption {
-          type = with lib.types; listOf port;
-          default = [ ];
-        };
-        hosts = lib.mkOption {
-          type = with lib.types; listOf str;
-          default = [ config.host ];
-        };
-        config = lib.mkOption {
-          type = lib.types.deferredModule;
-          default = { };
-        };
-        hostConfig = lib.mkOption {
-          type = with lib.types; attrsOf deferredModule;
-          default = { };
-        };
-      };
-    };
-
-  moduleToHostConfigs =
-    cfg:
-    lib.genAttrs cfg.hosts (host: {
-      imports = [
-        cfg.config
-        (cfg.hostConfig.${host} or { })
-      ];
-    });
-
-  maybeGetPreviousConfigs = acc: host: (acc.${host} or { imports = [ ]; }).imports;
-in
-{
-  _file = ./services.nix;
-
-  options = {
-    services = lib.mkOption {
-      type = with lib.types; attrsOf (submodule serviceModule);
-      default = { };
-    };
-
-    __extraHostConfigs = lib.mkOption {
-      type = with lib.types; attrsOf deferredModule;
-      readOnly = true;
-    };
-  };
-
-  config.__extraHostConfigs =
-    let
-      duplicatePorts = lib.pipe config.services [
-        lib.attrValues
-        (map (cfg: cfg.ports))
-        lib.flatten
-        (lib.groupBy' (cnt: _: cnt + 1) 0 toString)
-        (lib.filterAttrs (_: cnt: cnt > 1))
-        lib.attrNames
-      ];
-      assertMsg =
-        let
-          plural = lib.length duplicatePorts > 1;
-        in
-        "\nBad service config:\nThe following port${if plural then "s" else ""} ${
-          if plural then "were" else "was"
-        } declared multiple times: ${lib.concatStringsSep ", " duplicatePorts}";
-      # Here I collect all the services.<name>.config into a flat
-      # __extraHostConfigs.<host>.imports = [
-      #   ...
-      # ]
-      # so that I can easily import them in hosts/default.nix
-      hostConfigs = lib.pipe config.services [
-        lib.attrValues
-        (lib.foldl' (
-          acc: cfg:
-          acc
-          // lib.mapAttrs (host: c: {
-            imports = c.imports ++ (maybeGetPreviousConfigs acc host);
-          }) (moduleToHostConfigs cfg)
-        ) { })
-      ];
-    in
-    if duplicatePorts != [ ] then throw assertMsg else hostConfigs;
-}

modules/nilla/builders/custom-load.nix

@@ -0,0 +1,8 @@
+{ lib }:
+{
+  config.builders.custom-load = {
+    settings.type = lib.types.submodule { };
+    settings.default = { };
+    build = pkg: lib.attrs.generate pkg.systems (system: pkg.package { inherit system; });
+  };
+}

modules/nilla/builders/default.nix

@@ -0,0 +1,6 @@
+{
+  includes = [
+    ./nixpkgs-flake.nix
+    ./custom-load.nix
+  ];
+}

modules/nilla/builders/nixpkgs-flake.nix

@@ -0,0 +1,21 @@
+{
+  config,
+  lib,
+}:
+{
+  config.builders.nixpkgs-flake = {
+    settings.type = lib.types.submodule {
+      options.args = lib.options.create {
+        type = lib.types.any;
+        default.value = { };
+      };
+    };
+    settings.default = { };
+    build =
+      pkg:
+      lib.attrs.generate pkg.systems (
+        system:
+        config.inputs.nixpkgs.result.legacyPackages.${system}.callPackage pkg.package pkg.settings.args
+      );
+  };
+}

modules/nilla/default.nix

@@ -0,0 +1,9 @@
+{
+  includes = [
+    ./builders
+    ./services.nix
+    ./systems.nix
+    ./modules.nix
+    ./flake.nix
+  ];
+}

modules/nilla/flake.nix

@@ -0,0 +1,32 @@
+{ lib, config }:
+let
+  systems = [
+    "x86_64-linux"
+    "aarch64-linux"
+    "aarch64-darwin"
+  ];
+  transpose =
+    attrs: lib.attrs.generate systems (system: builtins.mapAttrs (_: pkg: pkg.result.${system}) attrs);
+in
+{
+  options.flake = lib.options.create {
+    type = lib.types.attrs.of lib.types.raw;
+  };
+
+  config.flake = {
+    inherit (config)
+      nixosModules
+      darwinModules
+      homeModules
+      ;
+
+    nixosConfigurations = builtins.mapAttrs (_: system: system.result) config.systems.nixos;
+    darwinConfigurations = builtins.mapAttrs (_: system: system.result) config.systems.darwin;
+    homeConfigurations = builtins.mapAttrs (_: system: system.result) config.systems.home;
+
+    devShells = transpose config.shells;
+    packages = transpose config.packages;
+
+    formatter = config.packages.formatter.result;
+  };
+}

modules/nilla/modules.nix

@@ -0,0 +1,17 @@
+{ lib }:
+{
+  options = {
+    nixosModules = lib.options.create {
+      type = lib.types.attrs.of lib.types.raw;
+      default.value = { };
+    };
+    darwinModules = lib.options.create {
+      type = lib.types.attrs.of lib.types.raw;
+      default.value = { };
+    };
+    homeModules = lib.options.create {
+      type = lib.types.attrs.of lib.types.raw;
+      default.value = { };
+    };
+  };
+}

modules/nilla/services.nix

@@ -0,0 +1,95 @@
+{ lib, config }:
+let
+  inherit (builtins)
+    attrNames
+    attrValues
+    concatStringsSep
+    mapAttrs
+    foldl'
+    groupBy
+    length
+    ;
+  serviceModule =
+    { config }:
+    {
+      options = {
+        host = lib.options.create {
+          type = lib.types.string;
+        };
+        ports = lib.options.create {
+          type = lib.types.list.of lib.types.port;
+          default.value = [ ];
+        };
+        hosts = lib.options.create {
+          type = lib.types.list.of lib.types.string;
+          default.value = [ config.host ];
+        };
+        module = lib.options.create {
+          type = lib.types.raw;
+          default.value = { };
+        };
+        hostModule = lib.options.create {
+          type = lib.types.attrs.of lib.types.raw;
+          default.value = { };
+        };
+      };
+    };
+
+  moduleToHostConfigs =
+    cfg:
+    lib.attrs.generate cfg.hosts (host: {
+      imports = [
+        cfg.module
+        (cfg.hostModule.${host} or { })
+      ];
+    });
+
+  maybeGetPreviousConfigs = acc: host: (acc.${host} or { imports = [ ]; }).imports;
+
+  # Copied from nixpkgs/lib/lists.nix
+  groupBy' =
+    op: nul: pred: lst:
+    mapAttrs (_name: foldl' op nul) (groupBy pred lst);
+  duplicatePorts = lib.fp.pipe [
+    attrValues
+    (map (cfg: cfg.ports))
+    lib.lists.flatten
+    (groupBy' (cnt: _: cnt + 1) 0 toString)
+    (lib.attrs.filter (_: cnt: cnt > 1))
+    attrNames
+  ] config.services;
+in
+{
+  options.services = lib.options.create {
+    type = lib.types.attrs.of (lib.types.submodule serviceModule);
+    default.value = { };
+  };
+
+  options.extraHostConfigs = lib.options.create {
+    type = lib.types.attrs.of lib.types.raw;
+    writable = false;
+    default.value = lib.fp.pipe [
+      attrValues
+      (foldl' (
+        acc: cfg:
+        acc
+        // mapAttrs (host: c: {
+          imports = c.imports ++ (maybeGetPreviousConfigs acc host);
+        }) (moduleToHostConfigs cfg)
+      ) { })
+    ] config.services;
+  };
+
+  config.assertions = [
+    {
+      assertion = duplicatePorts == [ ];
+      message =
+        let
+          plural = length duplicatePorts > 1;
+        in
+        "\nBad service config:\nThe following port${if plural then "s" else ""} ${
+          if plural then "were" else "was"
+        } declared multiple times: ${concatStringsSep ", " duplicatePorts}";
+    }
+  ];
+}

modules/nilla/systems.nix

@@ -0,0 +1,52 @@
+{ config, lib }:
+let
+  mkBuilderOption =
+    typ:
+    lib.options.create {
+      type = lib.types.function (lib.types.function lib.types.raw);
+      default.value = _name: _module: throw "Builder for systems.${typ} is not implemented";
+    };
+  inherit (config.systems) builders;
+  mkSystemModule =
+    typ:
+    { config, name }:
+    {
+      options = {
+        name = lib.options.create {
+          type = lib.types.string;
+          default.value = name;
+        };
+        module = lib.options.create {
+          type = lib.types.raw;
+          default.value = { };
+        };
+        builder = lib.options.create {
+          type = lib.types.function (lib.types.function lib.types.raw);
+          default.value = builders.${typ};
+        };
+        result = lib.options.create {
+          type = lib.types.raw;
+          writable = false;
+          default.value = config.builder config.name config.module;
+        };
+      };
+    };
+  mkSystemOption =
+    typ:
+    lib.options.create {
+      type = lib.types.attrs.of (lib.types.submodule (mkSystemModule typ));
+      default.value = { };
+    };
+in
+{
+  options = {
+    systems = {
+      builders.nixos = mkBuilderOption "nixos";
+      builders.darwin = mkBuilderOption "darwin";
+      builders.home = mkBuilderOption "home";
+      nixos = mkSystemOption "nixos";
+      darwin = mkSystemOption "darwin";
+      home = mkSystemOption "home";
+    };
+  };
+}

nilla.nix

@@ -0,0 +1,140 @@
+{
+  inputs ? import ./inputs.nix,
+}:
+(import inputs.nilla).create (
+  { config, lib }:
+  {
+    includes = [
+      ./modules/nilla
+      ./pkgs
+      ./wrappers
+      ./hosts
+      ./assets
+      ./services
+      ./modules
+    ];
+
+    config.inputs = builtins.mapAttrs (_: src: {
+      inherit src;
+      loader = "raw";
+    }) inputs;
+
+    config.packages =
+      let
+        systems = [
+          "x86_64-linux"
+          "aarch64-linux"
+          "aarch64-darwin"
+        ];
+        mkPackage = package: {
+          builder = "nixpkgs-flake";
+          inherit systems package;
+        };
+        mkPackageFlakeOutput =
+          {
+            input,
+            output ? input,
+          }:
+          {
+            inherit systems;
+            builder = "custom-load";
+            package = { system }: inputs.${input}.packages.${system}.${output};
+          };
+        getPkgs = system: builtins.mapAttrs (_: pkg: pkg.result.${system}) config.packages;
+      in
+      {
+        # Re-export for convenience and for caching
+        attic-client = mkPackageFlakeOutput {
+          input = "attic";
+          output = "attic-client";
+        };
+        attic-server = mkPackageFlakeOutput {
+          input = "attic";
+          output = "attic-server";
+        };
+        agenix = mkPackageFlakeOutput { input = "agenix"; };
+        base-packages = mkPackage (
+          { symlinkJoin, system }:
+          symlinkJoin {
+            name = "settei-base";
+            paths = with (getPkgs system); [
+              # TODO: wrappers
+              helix
+              fish
+              git-commit-last
+              git-fixup
+            ];
+          }
+        );
+        formatter = {
+          inherit systems;
+          builder = "custom-load";
+          package =
+            { system }:
+            let
+              eval = inputs.treefmt.lib.evalModule inputs.nixpkgs.legacyPackages.${system} ./treefmt.nix;
+            in
+            eval.config.build.wrapper;
+        };
+        __allPackages =
+          let
+            all-packages = builtins.attrValues (
+              builtins.removeAttrs config.packages [
+                "ci-check"
+                "__allPackages"
+              ]
+            );
+            all-packages' = lib.lists.flatten (map (pkg: builtins.attrValues pkg.result) all-packages);
+
+            nixos-systems = builtins.attrValues config.systems.nixos;
+            nixos-systems' = map (system: system.result.config.system.build.toplevel) nixos-systems;
+
+            darwin-systems = builtins.attrValues config.systems.darwin;
+            darwin-systems' = map (system: system.result.config.system.build.toplevel) darwin-systems;
+
+            all-drvs = all-packages' ++ nixos-systems' ++ darwin-systems';
+            all-drvs' = lib.strings.concatMapSep "\n" builtins.unsafeDiscardStringContext all-drvs;
+          in
+          mkPackage (
+            { runCommand }:
+            runCommand "eval-check" {
+              allDerivations = all-drvs';
+              passAsFile = [ "allDerivations" ];
+            } "touch $out"
+          );
+        ci-check = mkPackage (
+          {
+            writeShellScript,
+            lib,
+            system,
+          }:
+          writeShellScript "ci-check" ''
+            nix-instantiate --eval -E 'import ./nilla.nix {}' -A packages.__allPackages.result.${system}.outPath
+            "${lib.getExe config.packages.formatter.result.${system}}" --ci
+          ''
+        );
+      };
+
+    config.shells.default = {
+      systems = [
+        "x86_64-linux"
+        "aarch64-linux"
+        "aarch64-darwin"
+      ];
+      builder = "nixpkgs-flake";
+      shell =
+        {
+          mkShellNoCC,
+          system,
+          nh,
+        }:
+        mkShellNoCC {
+          packages = [
+            config.packages.agenix.result.${system}
+            config.packages.attic-client.result.${system}
+            nh
+          ];
+        };
+    };
+  }
+)

pkgs/conduit/default.nix

@@ -1,6 +1,8 @@
 {
   lib,
   stdenv,
+  pkgs,
+  system,
   fenix,
   crane,
   src,
@@ -11,12 +13,12 @@
 }:
 let
   rust =
-    with fenix;
+    with fenix.${system};
     combine [
       stable.cargo
       stable.rustc
     ];
-  crane' = crane.overrideToolchain rust;
+  crane' = (crane pkgs).overrideToolchain rust;
   rocksdb' = rocksdb.overrideAttrs (
     final: prev: {
       version = "9.1.1";

pkgs/default.nix

@@ -1,35 +1,52 @@
-{ inputs, ... }:
+{ config }:
-{
+let
-  perSystem =
+  systems = [
-    {
+    "x86_64-linux"
-      pkgs,
+    "aarch64-linux"
-      lib,
+    "aarch64-darwin"
-      inputs',
+  ];
-      ...
+  builder = "nixpkgs-flake";
-    }:
+  mkPackage = package: {
-    {
+    inherit systems package builder;
-      packages.conduit-next = pkgs.callPackage ./conduit {
-        src = inputs.conduit-src;
-        crane = inputs.crane.mkLib pkgs;
-        fenix = inputs'.fenix.packages;
   };
 
-      packages.git-commit-last = pkgs.writeShellApplication {
+in
+{
+  config.packages.conduit-next = {
+    inherit systems builder;
+    package = import ./conduit;
+    settings.args = {
+      src = config.inputs.conduit-src.result;
+      crane = config.inputs.crane.result.mkLib;
+      fenix = config.inputs.fenix.result.packages;
+    };
+  };
+
+  config.packages.git-commit-last = mkPackage (
+    { writeShellApplication }:
+    writeShellApplication {
       name = "git-commit-last";
       text = ''
         GITDIR="$(git rev-parse --git-dir)"
         git commit -eF "$GITDIR/COMMIT_EDITMSG"
       '';
-      };
+    }
+  );
 
-      packages.git-fixup = pkgs.writeShellApplication {
+  config.packages.git-fixup = mkPackage (
+    {
+      lib,
+      writeShellApplication,
+      fzf,
+    }:
+    writeShellApplication {
       name = "git-fixup";
       text = ''
         git log -n 50 --pretty=format:'%h %s' --no-merges | \
-          ${lib.getExe pkgs.fzf} | \
+        ${lib.getExe fzf} | \
         cut -c -7 | \
         xargs -o git commit --fixup
       '';
-      };
+    }
-    };
+  );
 }

services/attic.nix

@@ -1,12 +1,12 @@
 {
-  services.attic =
+  config.services.attic =
     let
       atticPort = 9476;
     in
     {
       host = "kazuki";
       ports = [ atticPort ];
-      config =
+      module =
         { config, ... }:
         {
           age.secrets.attic-creds = {

services/default.nix

@@ -1,5 +1,5 @@
 {
-  imports = [
+  includes = [
     ./attic.nix
     ./forgejo-runner.nix
     ./forgejo.nix

services/forgejo-runner.nix

@@ -1,10 +1,10 @@
 {
-  services.forgejo-runner = {
+  config.services.forgejo-runner = {
     hosts = [
       "ude"
       "youko"
     ];
-    config =
+    module =
       {
         config,
         lib,

services/forgejo.nix

@@ -1,8 +1,8 @@
 {
-  services.forgejo = {
+  config.services.forgejo = {
     host = "kazuki";
     ports = [ 3000 ];
-    config =
+    module =
       { config, pkgs, ... }:
       {
         age.secrets.rab-lol-cf = {

shell.nix

@@ -0,0 +1 @@
+(import ./nilla.nix { }).shells.default.result.${builtins.currentSystem}

treefmt.nix

@@ -0,0 +1,23 @@
+{
+  projectRootFile = "nilla.nix";
+  programs.deadnix.enable = true;
+  programs.nixfmt.enable = true;
+  programs.statix.enable = true;
+  programs.fish_indent.enable = true;
+  programs.deno.enable = true;
+  programs.stylua.enable = true;
+  programs.shfmt.enable = true;
+  settings.global.excludes = [
+    # agenix
+    "*.age"
+
+    # racket
+    "*.rkt"
+    "**/rashrc"
+
+    # custom assets
+    "*.png"
+    "*.svg"
+  ];
+  settings.on-unmatched = "fatal";
+}

wrappers/default.nix

@@ -1,10 +1,14 @@
-{ inputs, ... }:
+{ lib, config }:
-{
+let
-  perSystem =
+  systems = [
-    { pkgs, inputs', ... }:
+    "x86_64-linux"
-    let
+    "aarch64-linux"
-      wrapped = inputs.wrapper-manager-hm-compat.lib {
+    "aarch64-darwin"
-        inherit pkgs;
+  ];
+  wrappedPerSystem = lib.attrs.generate systems (
+    system:
+    config.inputs.wrapper-manager-hm-compat.result.lib {
+      pkgs = config.inputs.nixpkgs.result.legacyPackages.${system};
       modules = [
         ./starship
         ./helix
@@ -13,13 +17,16 @@
         ./fish
         ./wezterm
       ];
-        specialArgs = {
+      specialArgs.inputs = builtins.mapAttrs (_: input: input.result) config.inputs;
-          inherit inputs inputs';
+    }
-        };
+  );
-      };
+  wrappedPerSystem' = builtins.mapAttrs (_: wrapped: wrapped.config.build.packages) wrappedPerSystem;
-      all-packages = wrapped.config.build.packages;
+  wrapperNames = builtins.attrNames wrappedPerSystem'."x86_64-linux";
-    in
+in
-    {
+{
-      packages = all-packages;
+  config.packages = lib.attrs.generate wrapperNames (wrapper: {
-    };
+    inherit systems;
+    builder = "custom-load";
+    package = { system }: wrappedPerSystem'.${system}.${wrapper};
+  });
 }

wrappers/helix/default.nix

@@ -1,8 +1,8 @@
-{ pkgs, inputs', ... }:
+{ pkgs, inputs, ... }:
 {
   programs.helix = {
     enable = true;
-    package = inputs'.helix.packages.default;
+    package = inputs.helix.packages.${pkgs.system}.default;
     settings = {
       theme = "base16_default_dark";
       editor = {

wrappers/rash/default.nix

@@ -1,6 +1,6 @@
 {
   pkgs,
-  inputs',
+  inputs,
   config,
   ...
 }:
@@ -13,7 +13,7 @@
         rev = "8eb52c163d6ea7c3cec2cc6b1011ce00738942e1";
         hash = "sha256-1yU0ZUBQqYEn85j4T2pLs02MTyJnO5BbYALIa88iomY=";
       };
-      racket-with-libs = inputs'.racket.packages.racket.newLayer {
+      racket-with-libs = inputs.racket.packages.${pkgs.system}.racket.newLayer {
         withRacketPackages =
           ps: with ps; [
             readline-gpl