How to inherit from a snowfall flake?

[n0rad]

👋 ,
I would like to define some common things in a parent flake using snowfall that then can be used in a downstream flake (also using the lib in my case).

Some parts are working but I cannot get the whole think working for now, especially when it comes to the fact that the namespace, pretty helpful inside a flake, becomes a drawback in a downstream one.

{
  outputs = inputs:
   # inputs.parent.outputs // inputs.parent.inputs.snowfall-lib.mkFlake {
    inputs.parent.inputs.snowfall-lib.mkFlake {
      inputs = inputs.parent.inputs // inputs;
      src = ./.;
      snowfall.namespace = "my";
      systems.modules.nixos = [
        inputs.parent.nixosModules.module1
        inputs.parent.nixosModules.module2
      ];
    } ;

  #################################

  inputs = {
    parent = {
      url = "github:something/something";
    };
  };
}

different problems I found, but I think all are linked to the namespace:

• modules in the parent are namespaced, but not when going in the output, making them hard to import in the downstream flake
• modules are referencing each other by the namespace that is unknown to the downstream flake
• packages in modules are referenced by the namespace, that is unknown when being the downstream flake, since it does not exists in the output

By hacking the output of the downstream flake I was able to import modules and packages from the parent, but the loss of the namespace makes it impossible to use them correctly as soon as there are references between modules.
Did somebody, with more knowledge than me on nix, have an idea on how to have, or rebuilding the namespace in a downstream flake?

[usmcamp0811]

@n0rad I think I have been able to do what you are asking. So I have my primary dotfiles here that I wish to use as an input to a downstream flake that I want to use many or most the modules I created in my dotfiles. This is mainly that this flake is meant for other purposes but has a lot of overlap and I don't want to have to update/maintain the same type of modules in multiple places. This is what I did:

{
  description = "Alternate Campground Config";
  inputs = {
    unstable.url = "github:nixos/nixpkgs/nixos-unstable";
    nixpkgs.url = "github:nixos/nixpkgs/release-25.05";
    campground.url = "gitlab:usmcamp0811/dotfiles/nixos";
    snowfall-lib.url = "github:snowfallorg/lib";
    snowfall-lib.inputs.nixpkgs.follows = "nixpkgs";
    home-manager.url = "github:nix-community/home-manager/release-25.05";
    home-manager.inputs.nixpkgs.follows = "nixpkgs";
    pre-commit-hooks.url = "github:cachix/pre-commit-hooks.nix";
    pre-commit-hooks.inputs.nixpkgs.follows = "nixpkgs";
    terranix.url = "github:terranix/terranix";
    terranix.inputs.nixpkgs.follows = "nixpkgs";
    nixos-generators.url = "github:nix-community/nixos-generators";
    nixos-generators.inputs.nixpkgs.follows = "nixpkgs";
    vault-service = {
      url = "github:DeterminateSystems/nixos-vault-service";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    mdatp.url = "github:epetousis/nix-mdatp";
    darwin = {
      url = "github:nix-darwin/nix-darwin/nix-darwin-25.05";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    nix-rosetta-builder = {
      url = "github:cpick/nix-rosetta-builder";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };

  outputs = inputs: let
    campgroundInputs = inputs.campground.inputs;
    lib = inputs.snowfall-lib.mkLib {
      inherit inputs;
      src = ./.;
      snowfall = {
        meta = {
          name = "alt-namespace";
          title = "Alternate Nix Config";
        };
        namespace = "alt-namespace";
      };
    };

    # Debug: Let's see what modules are available
    availableModules = builtins.attrNames (inputs.campground.nixosModules or {});
  in
    lib.mkFlake {
      channels-config = {
        allowUnfree = true;
        permittedInsecurePackages = ["python-2.7.18.6" "python-2.7.18.7" "gradle-7.6.6" "qtwebkit-5.212.0-alpha4"];
      };

      overlays = with inputs;
        [
          # Add your overlays here
        ]
        ++ (
          if (inputs.campground ? overlays)
          then builtins.attrValues inputs.campground.overlays
          else []
        );

      homes.modules = with inputs; (
        [
          # your overlays here
        ]
        ++ (
          if inputs.campground ? homeModules
          then builtins.attrValues inputs.campground.homeModules
          else []
        )
      );

      systems.modules.darwin = with inputs; [
        home-manager.darwinModules.home-manager
        nix-rosetta-builder.darwinModules.default
        {
          home-manager = {
            useGlobalPkgs = true;
            useUserPackages = true;
          };
        }
      ];
      systems.modules.nixos = with inputs;
        [
          home-manager.nixosModules.home-manager
          mdatp.nixosModules.mdatp
          campgroundInputs.crystal-forge.nixosModules.crystal-forge
          campgroundInputs.authentik-nix.nixosModules.default
          campgroundInputs.nixtheplanet.nixosModules.macos-ventura
          campgroundInputs.vault-service.nixosModules.nixos-vault-service
          campgroundInputs.nix-topology.nixosModules.default
          campgroundInputs.catppuccin.nixosModules.catppuccin
          campgroundInputs.flakeforge.nixosModules.flakeforge
          campgroundInputs.crowdsec.nixosModules.crowdsec
          campgroundInputs.funkwhale.nixosModules.default
          # Add your system modules here
          # Debug module to show available campground modules
          {
            warnings = [
              "Available campground modules: ${builtins.toJSON availableModules}"
            ];
          }
        ]
        ++ (
          if (inputs.campground ? nixosModules)
          then builtins.attrValues inputs.campground.nixosModules
          else []
        );

      # Fixed bug in Amazon image builder: https://github.com/nix-community/nixos-generators/issues/150
      systems.hosts.base.modules = [({...}: {amazonImage.sizeMB = 32 * 1024;})];

      deploy = lib.campground.mkDeploy {inherit (inputs) self;};
      outputs-builder = channels: {
        # this needs to be `hooks` not `checks` because `checks` will get run with `deploy` and
        # which will break `deploy`.
        hooks.pre-commit-check = inputs.pre-commit-hooks.lib.${channels.nixpkgs.system}.run {
          src = ./.;
          hooks = {
            nixpkgs-fmt.enable = true;
            # flake8.enable = true;
            # markdownlint.enable = true;
            # yamllint.enable = true;
            # deadnix.enable = true;
          };
        };
        nixidyEnvs = inputs.nixidy.lib.mkEnvs {
          pkgs = channels.nixpkgs;
          envs = {dev.modules = [./kubernetes/dev.nix];};
        };
      };

      terranixModule.modules = lib.findDefaultNixFiles ./modules/terraform;
    };
}

This lets me be able to have effectively two namespaces, I have campground my upstream dotfiles names space and I have alt-namespace my downstream name space. You can use either in a system/home config. Its not perfect and there are maybe some rough edges here and there but it seems to do the job.