_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

This option is also available to all submodules. Submodules do not inherit args from their parent module, nor do they provide args to their parent module or sibling submodules. The sole exception to this is the argument name which is provided by parent modules to a submodule and contains the attribute name the submodule is bound to, or a unique generated name if it is not bound to an attribute.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

"alacritty.toml"

alacritty.toml configuration file.

Type: submodule

Default:

{
  path = <derivation alacritty.toml>;
}

"alacritty.toml".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"alacritty.toml".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

settings

Configuration of alacritty. See alacritty(5) or https://alacritty.org/config-alacritty.html

Type: TOML value

Default: { }

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

"btop.conf"

Configuration for btop.

Type: submodule

Default:

{
  content = "";
}

"btop.conf".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"btop.conf".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

"config.jsonc"

fastfetch config file

Type: submodule

Default:

{
  path = <derivation fastfetch-config>;
}

"config.jsonc".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"config.jsonc".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

settings

fastfetch settings see https://github.com/fastfetch-cli/fastfetch/wiki/Configuration

Type: JSON value

Default: { }

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

"foot.ini"

foot.init configuration file.

Type: submodule

Default:

{
  path = <derivation foot.ini>;
}

"foot.ini".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"foot.ini".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

settings

Configuration of foot terminal. See foot.ini(5)

Type: attribute set of (INI atom (null, bool, int, float or string) or a list of them for duplicate keys or attribute set of (INI atom (null, bool, int, float or string) or a list of them for duplicate keys))

Default: { }

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

"fuzzel.ini"

This option has no description.

Type: submodule

Default:

{
  path = <derivation fuzzel.ini>;
}

"fuzzel.ini".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"fuzzel.ini".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

settings

Configuration of fuzzel. See fuzzel.ini(5)

Type: attribute set of section of an INI file (attrs of INI atom (null, bool, int, float or string))

Default: { }

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

configFile

Configuration of ghostty. See ghostty(5) or https://ghostty.org/docs/config/reference

Type: submodule

Default:

{
  path = <derivation ghostty-config>;
}

configFile.content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

configFile.path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

settings

Configuration of ghostty. See ghostty(5) or https://ghostty.org/docs/config/reference

Type: attribute set of (atom (null, bool, int, float or string) or a list of them for duplicate keys)

Default: { }

Example:

{
  background = "272822";
  cursor-color = "ffffff";
  cursor-text = "000000";
  foreground = "ffffff";
  palette = [
    "0=#272822"
    "1=#F92672"
    "2=#82B414"
    "3=#FD971F"
    "4=#268BD2"
    "5=#8C54FE"
    "6=#56C2D5"
    "7=#FFFFFF"
    "8=#5C5C5C"
    "9=#FF5995"
    "10=#A6E22E"
    "11=#E6DB74"
    "12=#62ADE3"
    "13=#AE81FF"
    "14=#66D9EF"
    "15=#CCCCCC"
  ];
}

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

configFile

Generated git configuration file.

Type: submodule

Default:

{
  path = "/nix/store/x06q44kyb1mai5sq0xg1g2aikqv78fvp-gitconfig";
}

configFile.content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

configFile.path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

settings

Git configuration settings. See git-config(1) for available options.

Type: attribute set of attribute set of (INI atom (null, bool, int, float or string) or attribute set of (INI atom (null, bool, int, float or string)))

Default: { }

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

"config.toml"

This option has no description.

Type: submodule

Default:

{
  path = <derivation halloy-config>;
}

"config.toml".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"config.toml".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

extraFiles

Additional files to be placed in the config directory

Type: list of (submodule)

Default: [ ]

extraFiles.*.file

File or path to add in the halloy config directory

Type: submodule

extraFiles.*.file.content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

extraFiles.*.file.path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extraFiles.*.name

File name in the halloy config directory

Type: non-empty string

settings

This option has no description.

Type: TOML value

Default: { }

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

"config.toml"

This option has no description.

Type: submodule

Default:

{
  path = <derivation helix-config>;
}

"config.toml".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"config.toml".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

extraFiles

Additional files to be placed in the config directory

Type: list of (submodule)

Default: [ ]

extraFiles.*.file

File or path to add in the helix config directory

Type: submodule

extraFiles.*.file.content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

extraFiles.*.file.path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extraFiles.*.name

File name in the helix config directory

Type: non-empty string

extraSettings

Extra lines appended to the config file. This can be used to maintain order for settings.

Type: strings concatenated with “\n”

Default: ""

ignoreFile

This option has no description.

Type: submodule

ignoreFile.content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

ignoreFile.path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

ignores

List of paths to be ignored by the file-picker. The format is the same as in .gitignore.

Type: list of non-empty string

Default: [ ]

languages

Language specific settings See https://docs.helix-editor.com/languages.html

Type: TOML value

Default: { }

"languages.toml"

This option has no description.

Type: submodule

Default:

{
  path = <derivation helix-languages.toml>;
}

"languages.toml".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"languages.toml".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

settings

General settings See https://docs.helix-editor.com/configuration.html

Type: TOML value

Default: { }

themes

Themes to add to config. See https://docs.helix-editor.com/themes.html

Type: attribute set of (TOML value or strings concatenated with “\n”)

Default: { }

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

"hypr.conf"

for basic setup of one hypr.conf file

Type: submodule

Default:

{
  content = "";
}

"hypr.conf".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"hypr.conf".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

"config.toml"

inori configuration file.

Type: submodule

Default:

{
  path = <derivation config.toml>;
}

"config.toml".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"config.toml".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

settings

Configuration of inori. See https://github.com/eshrh/inori/blob/master/CONFIGURATION.md

Type: TOML value

Default: { }

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

"config.toml"

This option has no description.

Type: submodule

Default:

{
  path = <derivation config.toml>;
}

"config.toml".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"config.toml".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

settings

Configuration of jjui. See https://github.com/idursun/jjui/wiki/Configuration

Type: TOML value

Default: { }

themeFiles

This option has no description.

Type: attribute set of (submodule)

Default: { }

themeFiles.<name>.content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

themeFiles.<name>.path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

themes

Themes to add to config. See https://github.com/idursun/jjui/wiki/Themes

Type: attribute set of (TOML value or strings concatenated with “\n”)

Default: { }

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

settings

Configuration for jujutsu. See https://jj-vcs.github.io/jj/latest/config/

Type: TOML value

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

configFile

Kanshi configuration file. See kanshi(5) for the configuration format.

Type: submodule

Default:

{
  content = "";
}

Example:

''
  profile {
    output LVDS-1 disable
    output "Some Company ASDF 4242" mode 1600x900 position 0,0
  }
  
  profile nomad {
    output LVDS-1 enable scale 2
  }
''

configFile.content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

configFile.path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

extraSettings

Extra lines appended to the config file. This can be used to maintain order for settings.

Type: strings concatenated with “\n”

Default: ""

"kitty.conf"

Raw configuration for kitty.

Type: submodule

Default:

{
  path = <derivation kitty.conf>;
}

"kitty.conf".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"kitty.conf".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

settings

Configuration for kitty. The fast, feature-rich, GPU based terminal emulator.

Type: attribute set of (atom (null, bool, int, float or string) or a list of them for duplicate keys)

Default: { }

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

configFile

This option has no description.

Type: submodule

Default:

{
  path = <derivation mako-settings>;
}

configFile.content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

configFile.path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

settings

Configuration settings for mako. Can include both global settings and sections. All available options can be found here: https://github.com/emersion/mako/blob/master/doc/mako.5.scd.

Default: { }

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

"input.conf"

This option has no description.

Type: submodule

Default:

{
  content = "";
}

"input.conf".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"input.conf".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

"mpv.conf"

This option has no description.

Type: submodule

Default:

{
  content = "";
}

"mpv.conf".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"mpv.conf".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

scripts

Scripts to add to mpv via override.

Type: list of package

Default: [ ]

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

"config.kdl"

Configuration file for Niri. See https://github.com/YaLTeR/niri/wiki/Configuration:-Introduction

Type: submodule

Default:

{
  path = <derivation niri.kdl>;
}

Example:

''
  input {
    keyboard {
        numlock
    }
  
    touchpad {
        tap
        natural-scroll
    }
  }
''

"config.kdl".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"config.kdl".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

settings

This option has no description.

Type: open submodule of (attribute set)

settings.binds

Bindings of niri

Type: attribute set

Default: { }

Example:

{
  "Mod+0" = {
    focus-workspace = 0;
  };
  "Mod+J" = {
    focus-column-or-monitor-left = null;
  };
  "Mod+N" = {
    spawn = [
      "alacritty"
      "msg"
      "create-windown"
    ];
  };
  "Mod+T" = {
    _attrs = {
      repeat = false;
    };
    spawn-sh = "alacritty";
  };
}

settings.extraConfig

Escape hatch string option added to the config file for options that might not be representable otherwise

Type: string

Default: ""

settings.layer-rules

List of layer rules

Type: list of (attribute set)

Default: [ ]

Example:

[
  {
    block-out-from = "screen-capture";
    matches = [
      {
        namespace = "^notifications$";
      }
    ];
    opacity = 0.8;
  }
]

settings.layout

Layout definitions

Type: attribute set

Default: { }

Example:

{
  border = {
    active-color = "#f5c2e7";
    inactive-color = "#313244";
    width = 3;
  };
  focus-ring = {
    off = null;
  };
}

settings.outputs

Output configuration

Type: attribute set

Default: { }

Example:

{
  DP-3 = {
    background-color = "#003300";
    hot-corners = {
      off = null;
    };
    position = {
      _attrs = {
        x = 0;
        y = 0;
      };
    };
  };
}

settings.spawn-at-startup

List of commands to run at startup. The first element in a passed list will be run with the following elements as arguments

Type: list of (string or list of string)

Default: [ ]

Example:

[
  "hello"
  [
    "nix"
    "build"
  ]
]

settings.window-rules

List of window rules

Type: list of (attribute set)

Default: [ ]

Example:

[
  {
    excludes = [
      {
        app-id = "org.keepassxc.KeePassXC";
      }
    ];
    matches = [
      {
        app-id = ".*";
      }
    ];
    open-floating = false;
    open-focused = false;
  }
]

settings.workspaces

Named workspace definitons

Type: attribute set of (null or anything)

Default: { }

Example:

{
  bar = null;
  foo = {
    open-on-output = "DP-3";
  };
}

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

configFile

This option has no description.

Type: submodule

Default:

{
  path = "/nix/store/rvl2f91wxz2h2ws42y7v42hgzxs44xq0-notmuch.ini";
}

configFile.content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

configFile.path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

settings

This option has no description.

Type: attribute set of section of an INI file (attrs of INI atom (null, bool, int, float or string))

Default:

{
  database = {
    mail_root = "Maildir";
    path = "Maildir";
  };
}

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

"config.nu"

This option has no description.

Type: submodule

Default:

{
  content = "";
}

"config.nu".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"config.nu".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

"env.nu"

This option has no description.

Type: submodule

Default:

{
  content = "";
}

"env.nu".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"env.nu".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

"config.rasi"

This option has no description.

Type: submodule

"config.rasi".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"config.rasi".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

plugins

List of rofi plugins to be installed

Type: list of package

Default: [ ]

settings

Configuration settings for rofi.

Type: (attribute set of (string or signed integer or boolean or (Rasi literal string) or list of (string or signed integer or boolean or (Rasi literal string)))) or string

Default:

{
  location = 0;
  xoffset = 0;
  yoffset = 0;
}

theme

This option has no description.

Type: null or string or absolute path or attribute set of ((attribute set of (string or signed integer or boolean or (Rasi literal string) or list of (string or signed integer or boolean or (Rasi literal string)))) or string)

Default: null

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

configFile

The starship configuration file.

Type: submodule

Default:

{
  path = "/nix/store/nxwdf660gjsjhr1d5kwaf9i286iclwx5-starship.toml";
}

configFile.content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

configFile.path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

settings

Starship configuration as a Nix attribute set. See https://starship.rs/config/

Type: TOML value

Default: { }

Example:

{
  add_newline = false;
  character = {
    error_symbol = "[x](bold red)";
    success_symbol = "[>](bold green)";
  };
  directory = {
    truncation_length = 3;
  };
}

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

configFile

Sway window manager configuration.

Type: submodule

Default:

{
  content = "";
}

configFile.content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

configFile.path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

configFile

Generated swaylock configuration file.

Type: submodule

Default:

{
  content = "";
}

configFile.content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

configFile.path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

settings

Swaylock configuration options. See swaylock(1) for available options.

Type: attribute set of (string or signed integer or boolean)

Default: { }

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

"config.toml"

Generated SwayOSD configuration file.

Type: submodule

Default:

{
  path = <derivation config.toml>;
}

"config.toml".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"config.toml".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

settings

SwayOSD server configuration. See https://github.com/ErikReider/SwayOSD for available options.

Type: TOML value

Default: { }

Example:

{
  server = {
    max_volume = 150;
    min_brightness = 5;
    top_margin = 0.85;
    show_percentage = true;
  };
}

style

CSS stylesheet for SwayOSD appearance. See the SwayOSD repository for styling examples.

Type: submodule

Default:

{
  content = "";
}

style.content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

style.path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

"config.yml"

Configuration file for udiskie.

Type: submodule

Default:

{
  path = <derivation udiskie-config>;
}

"config.yml".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"config.yml".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

settings

Udiskie settings See https://github.com/coldfix/udiskie/wiki/Usage#configuration

Type: YAML 1.1 value

Default: { }

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

configFile

way-edges config file see https://github.com/way-edges/way-edges/tree/master/doc/config

Type: submodule

Default:

{
  path = <derivation way-edges-config>;
}

configFile.content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

configFile.path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

settings

way-edges settings see https://github.com/way-edges/way-edges/tree/master/doc/config

Type: JSON value

Default: { }

Example:

{
  widgets = [
    {
      active-increase = 0;
      default-color = "#1e1e2e";
      edge = "left";
      focus-color = "#f5c2e7";
      hover-color = "#f5c2e7";
      layer = "top";
      length = 200;
      monitor = "*";
      namespace = "workspaces";
      position = "top";
      preset = {
        type = "niri";
      };
      thickness = 8;
      type = "workspace";
    }
  ];
}

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

configFile

Waybar configuration settings file. See https://github.com/Alexays/Waybar/wiki/Configuration

Type: submodule

Default:

{
  path = <derivation waybar-config>;
}

Example:

{
  content = ''
    {
      "height": 30,
      "layer": "top",
      "modules-center": [],
      "modules-left": [
        "sway/workspaces",
        "niri/workspaces"
      ]
    }
  '';
}

configFile.content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

configFile.path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

settings

Waybar configuration settings. See https://github.com/Alexays/Waybar/wiki/Configuration

Type: JSON value

Default: { }

Example:

{
  height = 30;
  layer = "top";
  modules-center = [ ];
  modules-left = [
    "niri/workspaces"
    "sway/workspaces"
  ];
  position = "top";
}

"style.css"

CSS style for Waybar.

Type: submodule

Default:

{
  content = "";
}

"style.css".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"style.css".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

"config.kdl"

Settings in KDL format See https://zellij.dev/documentation/configuration.html

Type: submodule

"config.kdl".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

"config.kdl".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>

".zshenv"

This option has no description.

Type: submodule

Default:

{
  content = "EXAMPLE=TRUE";
}

".zshenv".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

".zshenv".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

".zshrc"

This option has no description.

Type: submodule

Default:

{
  content = ''
    # KeyMap
    bindkey -e
    
    # Aliases
    
    # Completion
    
    
    
    
    #Autosuggestions
    
    # Integrations
    
    
    
    
    
    
    # History
    HISTSIZE=10000
    HISTSAVE=10000
    setopt appendhistory
    
    
    
    
    
    
    
    # Extra Content
  '';
}

".zshrc".content

Content of the file. This can be a multi-line string that will be written to the Nix store and made available via the path option.

Type: strings concatenated with “\n”

".zshrc".path

The path to the file. By default, this is automatically generated using pkgs.writeText with the attribute name and content. You can override this to provide:

A custom Nix path (e.g., ./config.txt or pkgs.writeText “name” “content”)
An absolute path string outside the store (e.g., “/etc/config.txt”)
A path with environment variables (e.g., “$HOME/.config/app.conf”)

Type: absolute path or string

Default: "pkgs.writeText name <content>"

_module.args

Additional arguments passed to each module in addition to ones like lib, config, and pkgs, modulesPath.

Some arguments are already passed by default, of which the following cannot be changed with this option:

lib: The nixpkgs library.
config: The results of all options after merging the values from all modules together.
options: The options declared in all modules.
specialArgs: The specialArgs argument passed to evalModules.
All attributes of specialArgs

Whereas option values can generally depend on other option values thanks to laziness, this does not apply to imports, which must be computed statically before anything else.

For this reason, callers of the module system can provide specialArgs which are available during import resolution.

For NixOS, specialArgs includes modulesPath, which allows you to import extra modules from the nixpkgs package tree without having to somehow make the module aware of the location of the nixpkgs or NixOS directories.
```
{ modulesPath, ... }: {
  imports = [
    (modulesPath + "/profiles/minimal.nix")
  ];
}
```

For NixOS, the default value for this option includes at least this argument:

pkgs: The nixpkgs package set according to the nixpkgs.pkgs option.

Type: lazy attribute set of raw value

Declared by:

<nixpkgs/lib/modules.nix>

apply

Function to extend the current configuration with additional modules. Re-evaluates the configuration with the original settings plus the new module.

Type: function that evaluates to a(n) raw value (read only)

Default: <function>

extend

Function to extend the current configuration with additional settings. Re-evaluates the configuration with the original modules plus the new settings.

Type: function that evaluates to a(n) raw value

Default: <function>