Flakelight

Flakelight is a modular Nix flake framework designed to simplify flake definitions by minimizing boilerplate. It supports various flake types including projects, shells, NixOS configurations, and config monorepos.

Key capabilities include:

• Automatic generation of per-system attributes.
• Extensibility via a module system.
• Automatic generation of package and overlay outputs from package definitions.
• Automatic importing of attributes from .nix files located in a ./nix directory.
• Built-in support for multi-file type formatters.
• Easy migration via outputs/perSystem options.

Flakelight can automatically import attributes from .nix files located in a ./nix directory. For example, you can move your package definition to ./nix/package.nix to keep your flake.nix clean.

# ./flake.nix
{
  description = "My C application.";
  inputs.flakelight.url = "github:nix-community/flakelight";
  outputs = { flakelight, ... }: 
    flakelight ./. {
      license = "AGPL-3.0-or-later";
      devShell.packages = pkgs: with pkgs; [ clang-tools coreutils ];
      formatters = {
        "*.h" = "clang-format -i";
        "*.c" = "clang-format -i";
      };
    };
}

# ./nix/package.nix
{
  stdenv, defaultMeta 
}: stdenv.mkDerivation {
  name = "hello-world";
  src = ./.;
  installPhase = ''
    runHook preInstall
    make DESTDIR=$out install
    runHook postInstall
  '';
  meta = defaultMeta;
}

If your Flakelight configuration requires access to module arguments (like lib or config), you can pass a function instead of a static attribute set. This function receives the module arguments as its parameters.

{
  inputs.flakelight.url = "github:nix-community/flakelight";
  outputs = { flakelight, ... }: 
    flakelight ./. ({ lib, config, ... }: {
      # Your flake configuration here
    });
}

Flakelight allows you to define your flake outputs using a module-based configuration. You can use Flakelight by calling it directly in your outputs function, which implicitly invokes mkFlake.

{
  inputs.flakelight.url = "github:nix-community/flakelight";
  outputs = { flakelight, ... }: 
    flakelight ./. {
      # Your flake configuration here
    };
}

To create a devshell, use the flakelight function in your outputs. You can define the packages required for the shell using the devShell.packages option, which provides access to the pkgs set. By default, Flakelight generates devShell.${system}.default attributes for configured systems.

{
  inputs.flakelight.url = "github:nix-community/flakelight";
  outputs = { flakelight, ... }: 
    flakelight ./. {
      devShell.packages = pkgs: [ pkgs.hello pkgs.coreutils ];
    };
}

The functor option allows you to make your flake callable. If set to a function, that function is assigned to the __functor attribute of your flake outputs. Flakelight uses this so that calling your flakelight input invokes flakelight.lib.mkFlake.

Example of a callable flake:

{
  inputs.flakelight.url = "github:nix-community/flakelight";
  outputs = { flakelight, ... }: 
    flakelight ./. {
      outputs.testvalue = 5;
      functor = self: x: x + self.testvalue;
    }
}

The package and packages options allow you to define packages that will be exported in packages.${system}, included in overlays.default, and checked via checks.${system}.

• package: Sets packages.default.
• packages: An attribute set of package definitions. If a function, it receives system as an argument.
• pname: Use this to manually specify the attribute name in the package set to avoid automatic derivation from the derivation's pname.

{
  inputs.flakelight.url = "github:nix-community/flakelight";
  outputs = { flakelight, ... }: 
    flakelight ./. {
      packages = { system, ... }: if (system == "x86_64-linux") then {
        pkg1 = { stdenv }: stdenv.mkDerivation { ... };
      } else { };
    };
}

The systems option defines which per-system outputs are generated. If omitted, it defaults to x86_64-linux and aarch64-linux.

To support specific additional systems:

{
  inputs.flakelight.url = "github:nix-community/flakelight";
  outputs = { flakelight, ... }: 
    flakelight ./. { 
      systems = [ "x86_64-linux" "aarch64-linux" "i686-linux" "armv7l-linux" ]; 
    };
}

The inputs option allows you to pass flake inputs to Flakelight modules. These are available as inputs and inputs' in the package set. By default, Flakelight initializes these from your flake.lock, but this excludes the self argument. To ensure full CLI functionality (including --override-input support), you should pass inputs explicitly.

To pass all inputs (including a custom nixpkgs):

{
  inputs = {
    flakelight.url = "github:nix-community/flakelight";
    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
  };
  outputs = { flakelight, ... }@inputs:
    flakelight ./. {
      inherit inputs;
    };
}