Denix

https://github.com/yunfachi/denix
Admin
Denix is a Nix library designed to help build scalable and modular configurations for NixOS, Home...
Tokens:25,491
Snippets:188
Trust Score:7.8
License:MIT
Update:10 months ago
Show doc for...
Tokens:
Raw
### Example Nix Flake Output for Configurations

Source: https://github.com/yunfachi/denix/blob/master/docs/src/configurations/introduction.md

This example demonstrates how to define `nixosConfigurations`, `homeConfigurations`, and `darwinConfigurations` in a Nix flake using the `denix.lib.configurations` function. It sets up paths, special arguments, and allows for configuration generation based on the module system.

```nix
outputs = {denix, ...} @ inputs:
  let
    mkConfigurations = moduleSystem:
      denix.lib.configurations rec {
        inherit moduleSystem;
        homeManagerUser = "sjohn";

        paths = [./hosts ./modules ./rices];

        specialArgs = {
          inherit inputs moduleSystem homeManagerUser;
        };
      };
  in {
    nixosConfigurations = mkConfigurations "nixos";
    homeConfigurations = mkConfigurations "home";
    darwinConfigurations = mkConfigurations "darwin";
  }
```

--------------------------------

### Denix Option Creation Examples

Source: https://github.com/yunfachi/denix/blob/master/docs/src/options/introduction.md

Provides examples of different Denix functions for creating options: `strOption` for a string, `listOfOption` for a list of strings, and `lambdaToOption` for a lambda function returning an integer.

```nix
strOption "foo"
listOfOption str ["foo" "bar"]
lambdaToOption int (x: 123)
```

--------------------------------

### Host Module Configuration with Displays Option

Source: https://github.com/yunfachi/denix/blob/master/docs/src/hosts/examples.md

This Nix snippet illustrates a host module configuration featuring the `displays` option for monitor setup. It uses a list of submodules to define individual display properties like `enable`, `touchscreen`, `name`, `primary`, `refreshRate`, `width`, `height`, `x`, and `y`. Assertions for hostnames are included.

```nix
{delib, ...}:
delib.module {
  name = "hosts";

  options = with delib; let
    host = {config, ...}: {
      options =
        hostSubmoduleOptions
        // {
          displays = listOfOption (submodule {
            options = {
              enable = boolOption true;
              touchscreen = boolOption false;

              # e.g. DP-1, HDMI-A-1
              name = noDefault (strOption null);
              primary = boolOption (builtins.length config.displays == 1);
              refreshRate = intOption 60;

              width = intOption 1920;
              height = intOption 1080;
              x = intOption 0;
              y = intOption 0;
            };
          }) [];
        };
    };
  in {
    host = hostOption host;
    hosts = hostsOption host;
  };

  home.always = {myconfig, ...}: {
    assertions = delib.hostNamesAssertions myconfig.hosts;
  };
}
```

--------------------------------

### Install Alejandra Package with Nix

Source: https://github.com/yunfachi/denix/blob/master/docs/src/modules/examples.md

This snippet demonstrates how to enable and install the Alejandra code formatter package. It uses Nix's declarative module system to ensure the package is available in the user's environment when enabled.

```nix
{delib, pkgs, ...}:
delib.module {
  name = "programs.alejandra";

  options = delib.singleEnableOption true;

  home.ifEnabled.home.packages = [pkgs.alejandra];
}
```

--------------------------------

### Nixpkgs `lib.mkOption` Usage

Source: https://github.com/yunfachi/denix/blob/master/docs/src/modules/introduction-nixos.md

Demonstrates the standard way to declare options in Nixpkgs using `lib.mkOption`. It outlines common attributes like `type`, `default`, `example`, `description`, and `readOnly` for defining option properties.

```nix
optionName = lib.mkOption {
  # ...
};

```

--------------------------------

### Short Host Module Configuration without Assertions

Source: https://github.com/yunfachi/denix/blob/master/docs/src/hosts/examples.md

This is a concise Nix configuration for a host module, omitting the `delib.hostNamesAssertions`. While using assertions is recommended, this version provides a simpler structure for basic setups. It defines a 'hosts' module with options for individual and multiple hosts.

```nix
{delib, ...}:
delib.module {
  name = "hosts";

  options = with delib; let
    host.options = hostSubmoduleOptions;
  in {
    host = hostOption host;
    hosts = hostsOption host;
  };
}
```

--------------------------------

### Denix Module Options Basic Example

Source: https://github.com/yunfachi/denix/blob/master/docs/src/options/introduction.md

Illustrates the basic usage of `moduleOptions` to define multiple options for the current module. This is a more structured alternative to defining options directly.

```nix
# current module's name is "programs.category.example".
options = with delib;
  moduleOptions {
    enable = boolOption true;
    device = strOption "desktop";
  };

# `options` block above is the same as:
# options.programs.category.example = with delib;
#   {
#     enable = boolOption true;
#     device = strOption "desktop";
#   };

```

--------------------------------

### Host Module Configuration with Type Option

Source: https://github.com/yunfachi/denix/blob/master/docs/src/hosts/examples.md

This Nix example demonstrates the use of the `type` option within a host module configuration. The `type` option, an enum with 'desktop' and 'server' values, helps in setting default configurations like `isDesktop` and `isServer`. This simplifies managing settings based on the device type. Assertions for hostnames are included.

```nix
{delib, ...}:
delib.module {
  name = "hosts";

  options = with delib; let
    host = {config, ...}: {
      options =
        hostSubmoduleOptions
        // {
          type = noDefault (enumOption ["desktop" "server"] null);

          isDesktop = boolOption (config.type == "desktop");
          isServer = boolOption (config.type == "server");
        };
    };
  in {
    host = hostOption host;
    hosts = hostsOption host;
  };

  home.always = {myconfig, ...}: {
    assertions = delib.hostNamesAssertions myconfig.hosts;
  };
}
```

--------------------------------

### Denix Option Type Allowance Examples

Source: https://github.com/yunfachi/denix/blob/master/docs/src/options/introduction.md

Illustrates how to use Denix functions to allow specific types for options. Includes examples for allowing strings, lists of strings, and lambda functions.

```nix
allowStr \
allowListOf str \
allowLambdaTo int
```

--------------------------------

### NixOS Module Example with Denix

Source: https://github.com/yunfachi/denix/blob/master/docs/src/getting_started/introduction.md

This snippet shows the equivalent functionality of the previous example, but implemented using the Denix library. It utilizes Denix's `module` function and specific option types like `boolOption` and `listOfOption` for a more concise definition.

```nix
{delib, ...}:
delib.module {
  name = "example";

  options.example = with delib; {
    enable = boolOption true;
    hostnames = listOfOption str [];
  };

  nixos.ifEnabled = {cfg, ...}: {
    networking.hosts."127.0.0.1" = cfg.hostnames;
  };
}
```

--------------------------------

### Minimal Recommended Host Configuration in Nix

Source: https://github.com/yunfachi/denix/blob/master/docs/src/hosts/introduction.md

This Nix code snippet demonstrates a minimal, recommended configuration for Denix hosts. It defines the 'hosts' module, setting up host-specific and global options, and includes assertions for host names. This serves as a foundational example for structuring host configurations.

```nix
{delib, ...}:

delib.module {
  name = "hosts";

  options = with delib; let
    host = {
      options = hostSubmoduleOptions;
    };
  in {
    host = hostOption host;
    hosts = hostsOption host;
  };

  home.always = {myconfig, ...}: {
    assertions = delib.hostNamesAssertions myconfig.hosts;
  };
}

```

--------------------------------

### Manage User and Groups in Nix for NixOS and Darwin

Source: https://github.com/yunfachi/denix/blob/master/docs/src/modules/examples.md

This snippet demonstrates user and group management. It includes configurations for both NixOS and Darwin environments, setting up user properties, initial passwords, and group memberships. It leverages constants for user details.

```nix
{delib, ...}:
delib.module {
  name = "user";

  # If you're not using NixOS, you can remove this entire block.
  nixos.always = {myconfig, ...}: let
    inherit (myconfig.constants) username;
  in {
    users = {
      groups.${username} = {};

      users.${username} = {
        isNormalUser = true;
        initialPassword = username;
        extraGroups = ["wheel"];
      };
    };
  };

  # If you're not using Nix-Darwin, you can remove this entire block.
  darwin.always = {myconfig, ...}: let
    inherit (myconfig.constants) username;
  in {
    users.users.${username} = {
      name = username;
      home = "/Users/${username}";
    };
  };
}
```

--------------------------------

### Override Nix Channels via delib.configurations Arguments

Source: https://github.com/yunfachi/denix/blob/master/docs/src/configurations/introduction.md

This example demonstrates overriding nixpkgs, home-manager, and nix-darwin channels directly as arguments to the `delib.configurations` function. This is useful when managing both stable and unstable channels separately for different host configurations.

```Nix
{
  inputs = {
    nixpkgs-unstable.url = "github:nixos/nixpkgs/nixos-unstable";
    nixpkgs-stable.url = "github:nixos/nixpkgs/nixos-25.05";

    home-manager-unstable = {
      url = "github:nix-community/home-manager/master";
      inputs.nixpkgs.follows = "nixpkgs-unstable";
    };
    home-manager-stable = {
      url = "github:nix-community/home-manager/release-25.05";
      inputs.nixpkgs.follows = "nixpkgs-stable";
    };

    nix-darwin-unstable = {
      url = "github:nix-darwin/nix-darwin/master";
      inputs.nixpkgs.follows = "nixpkgs-unstable";
    };
    nix-darwin-stable = {
      url = "github:nix-darwin/nix-darwin/nix-darwin-25.05";
      inputs.nixpkgs.follows = "nixpkgs-stable";
    };

    denix.url = "github:yunfachi/denix";
  };

  outputs = {
    denix,
    nixpkgs-unstable,
    nixpkgs-stable,
    home-manager-unstable,
    home-manager-stable,
    nix-darwin-unstable,
    nix-darwin-stable,
    ...
  } @ inputs: let
    _mkConfigurations = nixpkgs: home-manager: nix-darwin: hosts: moduleSystem:
      denix.lib.configurations {
        inherit moduleSystem nixpkgs home-manager nix-darwin;
        homeManagerUser = "sjohn";

        paths = [./modules ./rices] ++ hosts;

        specialArgs = {
          inherit inputs;
        };
      };

    mkConfigurations = moduleSystem:
      nixpkgs-unstable.lib.attrsets.mergeAttrsList
      (map (f: f moduleSystem) [
        (_mkConfigurations nixpkgs-stable home-manager-stable nix-darwin-stable [./hosts/stable])
        (_mkConfigurations nixpkgs-unstable home-manager-unstable nix-darwin-unstable [./hosts/unstable])
      ]);
  in {
    nixosConfigurations = mkConfigurations "nixos";
    homeConfigurations = mkConfigurations "home";
    darwinConfigurations = mkConfigurations "darwin";
  };
}

```

--------------------------------

### Denix Module Options with Parent Argument Example

Source: https://github.com/yunfachi/denix/blob/master/docs/src/options/introduction.md

Shows how to use `moduleOptions` when the options depend on passed arguments, such as `parent`. This allows options to be configured based on parent module settings.

```nix
# once again, `options` block above is the same as:
# options = with delib;
#   {
#     parent,
#     ...
#   }: {
#     programs.category.example = {
#       enable = boolOption parent.enable;
#       device = strOption "desktop";
#     };
#   };

```

--------------------------------

### Denix Module Pseudocode Example

Source: https://github.com/yunfachi/denix/blob/master/docs/src/modules/structure.md

This pseudocode illustrates the structure of a Denix module, showing how 'options', 'myconfig', 'nixos', 'home', and 'darwin' configurations are defined and conditionally executed based on module system and enable status.

```nix
delib.module {
  name = "";

  # options.${myConfigName} = ...
  options = {name, cfg, parent, myconfig, ...}: {};

  # config.${myConfigName} = ...
  myconfig.ifEnabled = {name, cfg, parent, myconfig, ...}: {};
  myconfig.ifDisabled = {name, cfg, parent, myconfig, ...}: {};
  myconfig.always = {name, cfg, parent, myconfig, ...}: {};

  # if moduleSystem == "nixos"
  # then {config = ...;}
  # else {}
  nixos.ifEnabled = {name, cfg, parent, myconfig, ...}: {};
  nixos.ifDisabled = {name, cfg, parent, myconfig, ...}: {};
  nixos.always = {name, cfg, parent, myconfig, ...}: {};

  # if moduleSystem == "home"
  # then {config = ...;}
  # else {config.home-manager.users.${homeManagerUser} = ...;}
  home.ifEnabled = {name, cfg, parent, myconfig, ...}: {};
  home.ifDisabled = {name, cfg, parent, myconfig, ...}: {};
  home.always = {name, cfg, parent, myconfig, ...}: {};

  # if moduleSystem == "darwin"
  # then {config = ...;}
  # else {}
  darwin.ifEnabled = {name, cfg, parent, myconfig, ...}: {};
  darwin.ifDisabled = {name, cfg, parent, myconfig, ...}: {};
  darwin.always = {name, cfg, parent, myconfig, ...}: {};
}
```

--------------------------------

### Denix Configuration Pseudocode Example (Nix)

Source: https://github.com/yunfachi/denix/blob/master/docs/src/configurations/structure.md

This snippet demonstrates how to define Denix configurations using Nix. It showcases the usage of various arguments like module names, extensions, Nix package sets, and paths for importing modules, hosts, and rices. It also includes settings for Home Manager and system module types.

```nix
delib.configurations rec {
  myconfigName = "myconfig";
  denixLibName = "delib";
  extensions = with delib.extensions; [];
  nixpkgs = inputs.nixpkgs;
  home-manager = inputs.home-manager;
  nix-darwin = inputs.nix-darwin;
  homeManagerNixpkgs = nixpkgs;
  useHomeManagerModule = true;
  homeManagerUser = "sjohn";
  moduleSystem = "nixos";
  paths = [./modules ./hosts ./rices];
  exclude = [./modules/deprecated];
  recursive = true;
  specialArgs = {
    inherit inputs;
  };
}
```

--------------------------------

### Configure Home Manager with Constants in Nix

Source: https://github.com/yunfachi/denix/blob/master/docs/src/modules/examples.md

This snippet configures the Home Manager settings, utilizing predefined constants for the username and constructing the home directory path based on the operating system (Darwin or other Unix-like systems).

```nix
{delib, pkgs, ...}:
delib.module {
  name = "home";

  home.always = {myconfig, ...}: let
    inherit (myconfig.constants) username;
  in {
    home = {
      inherit username;
      # If you don't need Nix-Darwin, or if you're using it exclusively,
      # you can keep the string here instead of the condition.
      homeDirectory =
        if pkgs.stdenv.isDarwin
        then "/Users/${username}"
        else "/home/${username}";
    };
  };
}
```

--------------------------------

### Verify Denix Project Setup with Nix

Source: https://github.com/yunfachi/denix/blob/master/docs/src/getting_started/initialization.md

Command to check if the Denix project configuration is set up correctly. This command uses Nix to perform a flake check on the current directory.

```sh
nix flake check .#

```

--------------------------------

### NixOS Git Configuration Module

Source: https://github.com/yunfachi/denix/blob/master/docs/src/modules/introduction-nixos.md

Provides an example of a NixOS module for configuring Git. It uses `lib.mkEnableOption` to conditionally enable Git and its LFS feature, setting the default branch.

```nix
{lib, config, ...}:
{
  options.myconfig.programs.git = {
    enable = lib.mkEnableOption "git" // {default = true;};
  };

  config = lib.mkIf config.myconfig.programs.git.enable {
    programs.git = {
      enable = true;
      lfs.enable = true;

      config = {
        init.defaultBranch = "master";
      };
    };
  };
}

```

--------------------------------

### Minimal Recommended Host Module Configuration

Source: https://github.com/yunfachi/denix/blob/master/docs/src/hosts/examples.md

This snippet shows a basic, minimally recommended host module configuration in Nix. It serves as a foundation for more complex settings. It defines a module named 'hosts' with options for individual hosts and a collection of hosts, and includes assertions for hostnames.

```nix
{delib, ...}:
delib.module {
  name = "hosts";

  options = with delib; let
    host = {
      options = hostSubmoduleOptions;
    };
  in {
    host = hostOption host;
    hosts = hostsOption host;
  };

  home.always = {myconfig, ...}: {
    assertions = delib.hostNamesAssertions myconfig.hosts;
  };
}
```

--------------------------------

### Initialize Denix Minimal Flake Template

Source: https://github.com/yunfachi/denix/blob/master/README.md

Initializes a new Nix flake using the recommended minimal template for Denix. This template includes hosts, rices, and initial modules for a quick setup.

```sh
nix flake init -t github:yunfachi/denix#minimal
```

--------------------------------

### Switching NixOS Configuration to a Different Rice

Source: https://github.com/yunfachi/denix/blob/master/docs/src/configurations/introduction.md

This example shows how to switch a NixOS host to a different rice configuration using `nixos-rebuild switch`. It illustrates the command-line syntax for targeting a specific host and rice combination, and explains how only the `${myConfigName}.rice` option is affected.

```bash
nixos-rebuild switch --flake .#desktop --use-remote-sudo
```

```bash
nixos-rebuild switch --flake .#desktop-dark --use-remote-sudo
```

--------------------------------

### Nix Module Imports Example

Source: https://github.com/yunfachi/denix/blob/master/docs/src/modules/introduction-nixos.md

Shows different ways to specify imports within a Nix module, including relative paths, absolute paths, and inline functions or attribute sets. This enables modularity and code reuse.

```nix
{
  imports = [
    ./pureModule.nix
    /etc/nixos/impureModule.nix
    {pkgs, ...}: {
      # ...
    }
  ];
}

```

--------------------------------

### Denix Single Enable Option Example

Source: https://github.com/yunfachi/denix/blob/master/docs/src/options/introduction.md

Shows how to use `singleEnableOption` to create an enable attribute for a module, commonly used in `delib.module :: options`. The default value is provided as an argument.

```nix
options = delib.singleEnableOption <default>;
```

--------------------------------

### Denix Rice Configuration Example

Source: https://github.com/yunfachi/denix/blob/master/docs/src/getting_started/introduction.md

This snippet illustrates how to define a 'rice' (system settings, particularly appearance) using Denix. It sets the name of the rice and configures stylistic elements, such as `stylix` polarity and colors.

```nix
{delib, ...}:
delib.rice {
  name = "dark";

  home.stylix = {
    polarity = "dark";
    colors = {
      # ...
    };
  };
}
```

--------------------------------

### Denix Module Options Declaration

Source: https://github.com/yunfachi/denix/blob/master/docs/src/modules/introduction-nixos.md

Presents an example of how to declare options using Denix's `delib.module` helper. It showcases Denix's specific types like `boolOption`, `listOfOption`, and `strOption`, along with `noDefault` and `allowNull`.

```nix
{delib, ...}:
delib.module {
  name = "coolmodule";

  options.coolmodule = with delib; {
    # boolOption <default>
    enable = boolOption false;
    # noDefault (listOf) <default>
    ports = noDefault (listOfOption port null);
    # allowNull (strOption) <default>
    email = allowNull (strOption null);
  };
}

```

--------------------------------

### Denix Host Configuration Example

Source: https://github.com/yunfachi/denix/blob/master/docs/src/getting_started/introduction.md

This snippet demonstrates how to define a host configuration using Denix. It specifies the host's name, rice, type, and system architecture, along with shared configuration for services like SSH.

```nix
{delib, ...}:
delib.host {
  name = "macbook";

  rice = "dark";
  type = "desktop";

  homeManagerSystem = "x86_64-darwin";
  home.home.stateVersion = "24.05";

  shared.myconfig = {
    services.openssh.authorizedKeys = ["ssh-ed25519 ..."];
  };
}
```

--------------------------------

### Define Constants in Nix

Source: https://github.com/yunfachi/denix/blob/master/docs/src/modules/examples.md

This snippet defines various constants used throughout the configuration, such as username, full name, and email. It uses Nix's declarative module system and options.

```nix
{delib, ...}:
delib.module {
  name = "constants";

  options.constants = with delib;
    {
      username = readOnly (strOption "sjohn");
      userfullname = readOnly (strOption "John Smith");
      useremail = readOnly (strOption "johnsmith@example.com");
    };
}
```

--------------------------------

### Define Custom Modules with delib.module (Nix)

Source: https://context7.com/yunfachi/denix/llms.txt

This Nix snippet illustrates how to define a custom module using `delib.module`. It allows for defining reusable configuration components with options and conditional logic for different module systems. The example shows how to set options, apply configurations based on enablement, and include system-specific settings for NixOS and Home Manager.

```nix
{ delib, ... }:
delib.module {
  # Unique identifier for the module (supports nested paths like "services.myservice")
  name = "example";

  # Define module options using Denix option helpers
  options.example = with delib; {
    enable = boolOption true;
    hostnames = listOfOption str [];
    port = intOption 8080;
    package = packageOption pkgs.example;
  };

  # Configuration applied to custom options (myconfig namespace)
  myconfig.ifEnabled = { cfg, myconfig, ... }: {
    example.hostnames = [ "localhost" "example.com" ];
  };

  # NixOS-specific configuration when module is enabled
  nixos.ifEnabled = { cfg, ... }: {
    networking.hosts."127.0.0.1" = cfg.hostnames;
    networking.firewall.allowedTCPPorts = [ cfg.port ];
  };

  # Home Manager configuration when module is enabled
  home.ifEnabled = { cfg, ... }: {
    home.file.".config/example/config.toml".text = ''
      hostnames = ${builtins.toJSON cfg.hostnames}
      port = ${toString cfg.port}
    '';
  };

  # Configuration applied when module is disabled
  nixos.ifDisabled = {
    networking.firewall.enable = true;
  };

  # Configuration always applied regardless of enable state
  darwin.always = {
    system.defaults.NSGlobalDomain.AppleShowAllExtensions = true;
  };
}

```

--------------------------------

### Minimal Rice Module Configuration (Nix)

Source: https://github.com/yunfachi/denix/blob/master/docs/src/rices/examples.md

This Nix code defines a minimal rice module configuration. It sets up options for 'rice' and 'rices' using provided 'delib' functions and includes an assertion for rice names. This serves as a baseline for further customization.

```nix
{delib, ...}:
delib.module {
  name = "rices";

  options = with delib; let
    rice = {
      options = riceSubmoduleOptions;
    };
  in {
    rice = riceOption rice;
    rices = ricesOption rice;
  };

  home.always = {myconfig, ...}: {
    assertions = delib.riceNamesAssertions myconfig.rices;
  };
}
```

--------------------------------

### Default Nix Channel Usage (No Overrides)

Source: https://github.com/yunfachi/denix/blob/master/docs/src/configurations/introduction.md

This configuration uses the Denix flake without explicitly overriding any Nix channels. It relies on the default inputs provided by Denix, making it a simple option for single-channel setups, though less flexible.

```Nix
{
  inputs = {
    denix.url = "github:yunfachi/denix";
  };

  outputs = {denix, ...} @ inputs: let
    mkConfigurations = moduleSystem:
      denix.lib.configurations {
        inherit moduleSystem;
        homeManagerUser = "sjohn";

        paths = [./hosts ./modules ./rices];

        specialArgs = {
          inherit inputs;
        };
      };
  in {
    nixosConfigurations = mkConfigurations "nixos";
    homeConfigurations = mkConfigurations "home";
    darwinConfigurations = mkConfigurations "darwin";
  };
}

```

--------------------------------

### Create Rices with delib.rice (Nix)

Source: https://context7.com/yunfachi/denix/llms.txt

Defines reusable configuration profiles (rices) using `delib.rice`. Rices can be applied across multiple hosts and support inheritance from other rices. This example shows settings for NixOS, Home Manager, and Nix-Darwin.

```nix
{ delib, pkgs, ... }:
delib.rice {
  # Unique rice identifier
  name = "dark";

  # Inherit configurations from other rices
  inherits = [ "base" ];

  # If true, this rice won't generate standalone configurations (used only for inheritance)
  inheritanceOnly = false;

  # Custom options applied when using this rice
  myconfig = { name, cfg, myconfig, ... }: {
    theme.colors = {
      primary = "#1e1e2e";
      secondary = "#313244";
      accent = "#89b4fa";
    };
  };

  # NixOS configuration for this rice
  nixos = {
    console = {
      font = "Lat2-Terminus16";
      keyMap = "us";
    };
  };

  # Home Manager configuration for this rice
  home = {
    gtk = {
      enable = true;
      theme = {
        name = "Adwaita-dark";
        package = pkgs.gnome-themes-extra;
      };
    };

    programs.alacritty = {
      enable = true;
      settings = {
        colors = {
          primary = {
            background = "#1e1e2e";
            foreground = "#cdd6f4";
          };
        };
      };
    };
  };

  # Nix-Darwin configuration for this rice
  darwin = {
    system.defaults.NSGlobalDomain = {
      AppleInterfaceStyle = "Dark";
      AppleAccentColor = 4;
    };
  };
}

```

--------------------------------

### Short Rice Module Configuration (Nix)

Source: https://github.com/yunfachi/denix/blob/master/docs/src/rices/examples.md

This Nix code presents a shorter version of a rice module configuration. It omits the `delib.riceNamesAssertions` while still defining options for 'rice' and 'rices'. This configuration is suitable when explicit name assertions are not required.

```nix
{delib, ...}:
delib.module {
  name = "rices";

  options = with delib; let
    rice.options = riceSubmoduleOptions;
  in {
    rice = riceOption rice;
    rices = ricesOption rice;
  };
}
```

--------------------------------

### Configure Git Settings with Constants in Nix

Source: https://github.com/yunfachi/denix/blob/master/docs/src/modules/examples.md

This snippet configures Git settings, including enabling Git and Git LFS. It sets the user's name and email for Git commits using values from the defined constants. This configuration is applied conditionally if Git is enabled.

```nix
{delib, ...}:
delib.module {
  name = "programs.git";

  options.programs.git = with delib;
    {
      enable = boolOption true;
      enableLFS = boolOption true;
    };

  home.ifEnabled.programs.git = {myconfig, cfg, ...}: {
    enable = true;
    lfs.enable = cfg.enableLFS;

    userName = myconfig.constants.username;
    userEmail = myconfig.constants.useremail;
  };
}
```

--------------------------------

### Initialize Nix Flake from Template

Source: https://github.com/yunfachi/denix/blob/master/docs/src/getting_started/initialization.md

Commands to initialize a Nix flake project using a specific template from a Git repository. Useful for quickly setting up a new project with a predefined structure.

```sh
nix flake init -t github:yunfachi/denix#minimal
```

```sh
nix flake init -t github:yunfachi/denix#minimal-no-rices
```

--------------------------------

### Use Option Helpers with delib.module (Nix)

Source: https://context7.com/yunfachi/denix/llms.txt

Demonstrates simplified option creation using `delib.module`'s helper functions. These reduce boilerplate for defining module options, including basic types, required, nullable, read-only, enums, and nested attributes.

```nix
{ delib, ... }:
delib.module {
  name = "constants";

  options.constants = with delib; {
    # Basic type options with defaults
    username = strOption "sjohn";
    age = intOption 30;
    ratio = floatOption 1.5;
    enabled = boolOption true;
    packages = listOfOption package [];

    # Options without defaults (required)
    email = noDefault (strOption null);

    # Nullable options
    optionalPath = allowNull (pathOption null);

    # Read-only options
    version = readOnly (strOption "1.0.0");

    # Options with descriptions
    port = description (intOption 8080) "The port to listen on";

    # Enum options
    logLevel = enumOption [ "debug" "info" "warn" "error" ] "info";

    # Nested attribute options
    server = attrsOption {
      host = "localhost";
      port = 3000;
    };

    # Submodule options
    service = submoduleOption {
      enable = boolOption false;
      name = strOption "myservice";
    } { enable = true; name = "default"; };

    # Complex nested options
    database = attrsOfOption (submodule {
      host = strOption "localhost";
      port = intOption 5432;
    }) {};
  };

  # Module configurations can reference these options
  myconfig.always = { cfg, myconfig, ... }: {
    # Access options via myconfig namespace
    example.username = myconfig.constants.username;
  };
}

```

--------------------------------

### Minimal Recommended Rice Configuration (Nix)

Source: https://github.com/yunfachi/denix/blob/master/docs/src/rices/introduction.md

This snippet provides a minimal recommended configuration structure for Denix rices. It defines the necessary options (`rice` and `rices`) within a module and sets up assertions for rice names, ensuring proper validation of the applied rices.

```nix
{delib, ...}:

delib.module {
  name = "rices";

  options = with delib; let
    rice = {
      options = riceSubmoduleOptions;
    };
  in {
    rice = riceOption rice;
    rices = ricesOption rice;
  };

  home.always = {myconfig, ...}: {
    assertions = delib.riceNamesAssertions myconfig.rices;
  };
}

```

--------------------------------

### Denix Option Attribute Set Modification Examples

Source: https://github.com/yunfachi/denix/blob/master/docs/src/options/introduction.md

Demonstrates Denix functions for modifying the attribute set of an option. Includes `noDefault`, `noNullDefault`, `readOnly`, `apply`, and `description`.

```nix
noDefault <option>
noNullDefault <option>
readOnly <option>
apply <option> <apply>
description <option> <description>
```

--------------------------------

### Configure Home Directory without Constants Module (Nix)

Source: https://github.com/yunfachi/denix/blob/master/docs/src/getting_started/initialization.md

Configures the user's home directory without relying on a constants module. This involves directly specifying the username and the home directory path, with conditional logic for Darwin systems. Place this in 'home.nix'.

```nix
{delib, pkgs, ...}:
delib.module {
  name = "home";

  home.always.home = {
    username = "sjohn"; #!!! REPLACEME
    # If you don't need Nix-Darwin, or if you're using it exclusively,
    # you can keep the string here instead of the condition.
    homeDirectory =
      if pkgs.stdenv.isDarwin
      then "/Users/sjohn" #!!! REPLACEME
      else "/home/sjohn"; #!!! REPLACEME
  };
}
```

--------------------------------

### Create Scalable Configurations with delib.configurations (Nix)

Source: https://context7.com/yunfachi/denix/llms.txt

This snippet demonstrates how to use `delib.configurations` to generate NixOS, Home Manager, or Nix-Darwin system configurations. It requires specifying the module system, Home Manager username (if applicable), and directories to import Nix files from. Extensions can be added to enhance functionality, and special arguments can be passed to modules.

```nix
{
  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
    home-manager = {
      url = "github:nix-community/home-manager/master";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    nix-darwin = {
      url = "github:nix-darwin/nix-darwin/master";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    denix = {
      url = "github:yunfachi/denix";
      inputs.nixpkgs.follows = "nixpkgs";
      inputs.home-manager.follows = "home-manager";
      inputs.nix-darwin.follows = "nix-darwin";
    };
  };

  outputs = { denix, ... }@inputs:
    let
      mkConfigurations = moduleSystem:
        denix.lib.configurations {
          # Specify which module system to use: "nixos", "home", or "darwin"
          inherit moduleSystem;

          # Home Manager username (required for Home Manager and when using Home Manager module)
          homeManagerUser = "sjohn";

          # Directories to recursively import .nix files from
          paths = [
            ./hosts
            ./modules
            ./rices
          ];

          # Extensions to enhance Denix functionality
          extensions = with denix.lib.extensions; [
            args
            (base.withConfig {
              args.enable = true;
            })
          ];

          # Additional arguments available in your modules
          specialArgs = {
            inherit inputs;
          };
        };
    in
    {
      nixosConfigurations = mkConfigurations "nixos";
      homeConfigurations = mkConfigurations "home";
      darwinConfigurations = mkConfigurations "darwin";
    };
}

```

--------------------------------

### Denix Project Configuration Directory Tree

Source: https://github.com/yunfachi/denix/blob/master/docs/src/getting_started/initialization.md

The expected directory structure for the Denix project after following setup instructions. This includes files for host configurations, system modules, and rice configurations.

```plaintext
hosts
- desktop
  - default.nix
  - hardware.nix
modules
- config
  - constants.nix
  - home.nix
  - hosts.nix (if you have not used the `base` extension)
  - rices.nix (if you have not used the `base` extension)
  - user.nix
rices (if you have used rices)
- dark
  - default.nix
flake.nix
```

--------------------------------

### Denix Single Cascade Enable Option Example

Source: https://github.com/yunfachi/denix/blob/master/docs/src/options/introduction.md

Demonstrates `singleCascadeEnableOption` which sets the default value of an enable option to its parent's enable option. This is useful for hierarchical enabling in modules.

```nix
# if current module's name is "programs.category.example",
# enable it by default if "programs.category" is enabled.
# will error if "programs.category.enable" is missing.
options = delib.singleCascadeEnableOption;
```

--------------------------------

### Define Rice Configuration (default.nix)

Source: https://github.com/yunfachi/denix/blob/master/docs/src/getting_started/initialization.md

Defines a 'rice' configuration, which likely refers to a set of customizations or themes for a specific environment. This file is placed within a 'rices' directory and should have its `name` attribute updated.

```nix
{delib, ...}:
    delib.rice {
      name = "dark"; #!!! REPLACEME
    }
```

--------------------------------

### Configure User Settings without Constants Module (Nix)

Source: https://github.com/yunfachi/denix/blob/master/docs/src/getting_started/initialization.md

Sets up user and group configurations for NixOS and Nix-Darwin without relying on a constants module. This involves hardcoding usernames, passwords, and home directory paths. The file should be named 'user.nix'.

```nix
{delib, ...}:
delib.module {
  name = "user";

  # If you're not using NixOS, you can remove this entire block.
  nixos.always.users = {
    groups.sjohn = {}; #!!! REPLACEME

    users.sjohn = { #!!! REPLACEME
      isNormalUser = true;
      initialPassword = "sjohn"; #!!! REPLACEME
      extraGroups = ["wheel"];
    };
  };

  # If you're not using Nix-Darwin, you can remove this entire block.
  darwin.always.users.users."sjohn" = { #!!! REPLACEME
    name = "sjohn"; #!!! REPLACEME
    home = "/Users/sjohn"; #!!! REPLACEME
  };
}
```

--------------------------------

### Nix Pseudocode for Delib Rice Configuration

Source: https://github.com/yunfachi/denix/blob/master/docs/src/rices/structure.md

This pseudocode outlines the structure and conditional logic for defining a 'rice' configuration using Nix. It shows how arguments like 'name', 'inherits', and 'inheritanceOnly' are used, and demonstrates the conditional assignment for 'myconfig', 'nixos', 'home', and 'darwin' based on matching rice names and module systems.

```nix
delib.rice {
  name = "";

  inherits = [];

  inheritanceOnly = [];

  # if config.${myconfigName}.rice == name
  # then {config.${myconfigName} = ...;}
  # else {}
  myconfig = {name, cfg, myconfig, ...}: {};

  # if config.${myconfigName}.rice == name, then
  #   if moduleSystem == "nixos"
  #   then {config = ...;}
  #   else {}
  # else {}
  nixos = {name, cfg, myconfig, ...}: {};

  # if config.${myconfigName}.rice == name, then
  #   if moduleSystem == "home"
  #   then {config = ...;}
  #   else {config.home-manager.users.${homeManagerUser} = ...;}
  # else {}
  home = {name, cfg, myconfig, ...}: {};

  # if config.${myconfigName}.rice == name, then
  #   if moduleSystem == "darwin"
  #   then {config = ...;}
  #   else {}
  # else {}
  darwin = {name, cfg, myconfig, ...}: {};
}
```

--------------------------------

### Initialize Denix Minimal No-Rices Flake Template

Source: https://github.com/yunfachi/denix/blob/master/README.md

Initializes a new Nix flake using the minimal-no-rices template for Denix. This template includes hosts and initial modules but omits rices for a leaner setup.

```sh
nix flake init -t github:yunfachi/denix#minimal-no-rices
```

--------------------------------

### Configure Rice Settings (Nix)

Source: https://github.com/yunfachi/denix/blob/master/docs/src/getting_started/initialization.md

Sets up rice (customization) options for the system. This module should be defined in 'modules/config/rices.nix'. After defining the module, you need to specify a 'rice' attribute in your host's 'default.nix' file.

```nix
delib.module {
  name = "rices";

  options = with delib; let
    rice = {
      options = riceSubmoduleOptions;
    };
  in {
    rice = riceOption rice;
    rices = ricesOption rice;
  };

  home.always = {myconfig, ...}:
    {
      assertions = delib.riceNamesAssertions myconfig.rices;
    };
}
```

```nix
{delib, ...}:
delib.host {
  name = "desktop"; #!!! REPLACEME

  rice = "dark" #!!! REPLACEME

  # ...
}
```

--------------------------------

### Define Host Hardware Configuration (hardware.nix)

Source: https://github.com/yunfachi/denix/blob/master/docs/src/getting_started/initialization.md

Specifies hardware-specific configurations for a host, catering to both NixOS and Darwin (macOS) environments. It includes settings for `homeManagerSystem`, `home.home.stateVersion`, `nixpkgs.hostPlatform`, and `system.stateVersion`. Users should uncomment and configure the relevant sections based on their operating system.

```nix
{delib, ...}:
    delib.host {
      name = "desktop"; #!!! REPLACEME

      homeManagerSystem = "x86_64-linux"; #!!! REPLACEME
      home.home.stateVersion = "24.05"; #!!! REPLACEME

      # If you're not using NixOS, you can remove this entire block.
      nixos = {
        nixpkgs.hostPlatform = "x86_64-linux"; #!!! REPLACEME
        system.stateVersion = "24.05"; #!!! REPLACEME

        # nixos-generate-config --show-hardware-config
        # other generated code here...
      };

      # If you're not using Nix-Darwin, you can remove this entire block.
      darwin = {
        nixpkgs.hostPlatform = "aarch64-darwin"; #!!! REPLACEME
        system.stateVersion = 6; #!!! REPLACEME
      };
    }
```

--------------------------------

### NixOS Module Structure

Source: https://github.com/yunfachi/denix/blob/master/docs/src/modules/introduction-nixos.md

Demonstrates the basic structure of a NixOS module, including imports, option declarations, and configuration assignments. This is the foundational layout for defining system configurations in NixOS.

```nix
{
  imports = [
    # Paths to other modules or Nix expressions.
  ];

  options = {
    # Declaration of options.
  };

  config = {
    # Assigning values to previously declared options.
    # For example, networking.hostName = "denix";
  };

  # However, values are usually assigned to options not in config, but here.
  # For example, networking.hostName = "denix";
}

```

--------------------------------

### Include extensions in Denix configuration

Source: https://github.com/yunfachi/denix/blob/master/docs/src/extensions/introduction.md

This is an example of how to integrate various types of extensions into the main Denix configuration using the `extensions` argument. It includes default extensions, configured extensions, single file extensions, and extensions loaded from a directory.

```nix
delib.configurations {
  # ...
  extensions =
    with delib.extensions;
    with delib.callExtensions { paths = [./myExtensions]; };
    [
      args
      (base.withConfig (final: prev: {
        args.enable = true;
        hosts.type.types = prev.hosts.type.types ++ ["laptop"];
      }))
      (delib.callExtension ./myExtension.nix)
      extensionFromMyExtensions
      (anotherExtensionFromMyExtensions.withConfig { someConfig = "someValue"; })
    ];
}
```

--------------------------------

### Denix Git Configuration Module

Source: https://github.com/yunfachi/denix/blob/master/docs/src/modules/introduction-nixos.md

Shows the equivalent of the NixOS Git configuration module but implemented using Denix. It utilizes `delib.module` and `delib.singleEnableOption` for a more declarative approach to enabling and configuring the git program.

```nix
{delib, ...}:
delib.module {
  name = "programs.git";

  options = delib.singleEnableOption true;

  nixos.ifEnabled.programs.git = {
    enable = true;
    lfs.enable = true;

    config = {
      init.defaultBranch = "master";
    };
  };
}

```

--------------------------------

### Set up Hyprland Module in Nix

Source: https://github.com/yunfachi/denix/blob/master/docs/src/getting_started/first_modules.md

This Nix module configures the Hyprland Wayland compositor. It enables Hyprland based on the host's 'isDesktop' option and sets basic window manager settings like gaps and mod key. It also defines keybindings for window manipulation and application launching.

```nix
{delib, ...}:
delib.module {
  name = "programs.hyprland";

  options = {myconfig, ...} @ args:
    delib.singleEnableOption myconfig.host.isDesktop args;

  nixos.ifEnabled.programs.hyprland.enable = true;
  home.ifEnabled.wayland.windowManager.hyprland.enable = true;
}
```

```nix
{delib, ...}:
delib.module {
  name = "programs.hyprland";

  home.ifEnabled.wayland.windowManager.hyprland.settings = {
    "$mod" = "SUPER";

    general = {
      gaps_in = 5;
      gaps_out = 10;
    };
  };
}
```

```nix
{delib, ...}:
delib.module {
  name = "programs.hyprland";

  home.ifEnabled.wayland.windowManager.hyprland.settings = {
    bindm = [
      "$mod, mouse:272, movewindow"
      "$mod, mouse:273, resizewindow"
    ];

    bind = [
      "$mod, q, killactive,"
      "CTRLALT, Delete, exit,"

      "$mod, Return, exec, kitty" # your terminal
    ];
  };
}
```

--------------------------------

### NixOS Module Example without Denix

Source: https://github.com/yunfachi/denix/blob/master/docs/src/getting_started/introduction.md

This snippet demonstrates how to define a custom NixOS module without using the Denix library. It includes options for enabling a feature and specifying hostnames, and conditionally configures networking based on the 'enable' option.

```nix
{ lib, config, ... }:
{
  options = {
    example = {
      enable = lib.mkEnableOption "example" // {default = true;};
      hostnames = lib.mkOption {
        type = lib.types.listOf lib.types.str;
        default = [];
      };
    };
  };

  config = lib.mkIf (!config.example.enable) {
    networking.hosts."127.0.0.1" = config.example.hostnames;
  };
}
```

--------------------------------

### Define Host Configuration (default.nix)

Source: https://github.com/yunfachi/denix/blob/master/docs/src/getting_started/initialization.md

Defines a host configuration for Denix. This file is typically placed within a 'hosts' directory and specifies basic host information. The `name` attribute should be replaced with the actual hostname.

```nix
{delib, ...}:
    delib.host {
      name = "desktop"; #!!! REPLACEME
    }
```
Tokens:
Raw