{
  description = "Madeleine's dots for the illiterate (sydnix)";

  inputs = {
    disko.url = "github:nix-community/disko";

    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";

    impermanence.url = "github:nix-community/impermanence";

    home-manager = {
      url = "github:nix-community/home-manager";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    niri.url = "github:sodiboo/niri-flake";
  };

  outputs = { nixpkgs, ... }@inputs:
    let list-nix-directory = dir:
          builtins.attrNames
            (nixpkgs.lib.filterAttrs
              (k: _v: nixpkgs.lib.hasSuffix ".nix" k)
              (builtins.readDir dir));
    in {
      # REVIEW: Why don't we put each module under nixosModules.<name>?
      nixosModules.default =
        let modules = list-nix-directory ./modules/nixos;
        in { ... }: {
          imports =
            builtins.map (m: ./modules/nixos/${m}) modules;
        };

      homeManagerModules.default =
        let modules = list-nix-directory ./modules/home;
        in { ... }: {
          imports =
            builtins.map (m: ./modules/home/${m}) modules;
        };

      nixosConfigurations = (
        let mkHost = k: v: nixpkgs.lib.nixosSystem {
              specialArgs = inputs;
              system = import ./hosts/${k}/system.nix;
              # TODO: This is very ad-hoc, and I don't like it. Organise this better.
              modules = [
                ./hosts/${k}/configuration.nix
        
                inputs.self.nixosModules.default
        
                inputs.disko.nixosModules.disko
                inputs.impermanence.nixosModules.impermanence
        
                # Directory name should always match host name.
                ({ ... }: { networking.hostName = k; })
        
                # Get system users
                ({ config, lib, ... }: {
                  users.users =
                    (lib.mapAttrs
                      (k: v: (import ./users/${k}).systemUser)
                      (lib.filterAttrs
                        (k: _v: builtins.elem k config.sydnix.users.users)
                        (builtins.readDir ./users)));
                })
        
                # Nixpkgs configuration
                ({ pkgs, ... }: {
                  nixpkgs.config.allowUnfree = true;
        
                  documentation = {
                    man.enable = true;
                    info.enable = true;
                  };
        
                  environment.systemPackages = with pkgs; [
                    man-pages
                    stdman
                    man-pages-posix
                    stdmanpages
                  ];
                })
        
                # home-manager configuration.
                inputs.home-manager.nixosModules.home-manager
                ({ config, lib, self, ... }: {
                  home-manager.useGlobalPkgs = true;
                  home-manager.useUserPackages = true;
        
                  home-manager.users =
                    lib.filterAttrs
                      (k: _v: builtins.elem k config.sydnix.users.users)
                      self.homeConfigurations;
        
                  home-manager.extraSpecialArgs = inputs // { inherit self; };
                })
              ];
            };
        in
        builtins.mapAttrs mkHost (builtins.readDir ./hosts)
      );

      homeConfigurations =
        let users = builtins.readDir ./users;
            mkUser = username: _v: {
              # TODO: This is very ad-hoc, and I don't like it. Organise this better.
              imports = [
                (import ./users/${username}).home

                inputs.self.homeManagerModules.default

                ({ lib, ... }: {
                  home.username = username;
                })

                ({ pkgs, lib, ... }: {
                  nix = {
                    settings.experimental-features =
                      lib.mkDefault
                        [ "nix-command" "flakes" ];
                  };
                })

                inputs.impermanence.homeManagerModules.impermanence
              ];
            };
        in
          builtins.mapAttrs mkUser users;
    };
}