Static aspects are just attribute sets#

# An aspect is a collection of many
# Nix configuration modules, each having
# a different `class`.
den.aspects.my-laptop = {
  nixos  = { };
  darwin = { };
  homeManager = { };
  nixVim = { };
  nixDroid = { };

  # aspects can be nested via `provides`
  # forming a tree structure.
  provides.gaming = {
    nixos = { };
    nixDroid = { };

    # aspects can also `include` others
    # forming a graph of dependencies
    includes = [
      # gaming.nixos module will mixin
      # nvidia-gpu.nixos module if any.
      den.aspects.nvidia-gpu
    ];
  };

};

TIP _ is an alias for provides. In many examples you will see foo._.bar._.baz instead of foo.provides.bar.provides.baz.

Parametric aspects are just functions.#

# The convention is to always use named args.
# These required args is the **context** the
# aspect needs to provide configuration.
hostParametric = { host }: {
  nixos.networking.hostName = host.hostName;

  # A parametric aspect can also ask other
  # aspects for context-aware configurations.
  # Here, we ask two other parametric aspects
  # given the `{ host, gaming }` context.
  includes = let 
    context.host = host;
    context.gaming.emulators = [ "nes" ];
  in map (f: f context) [
    den.default
    den.aspects.gaming-platform
  ];
};

Important context variants in den.#

Den uses the following contexts by default.

The aspect system is not limited to these,
but these are used to describe dependencies
between hosts/users, homes and default configs.

• { host } - For host OS level configs.
• { user, host } - For user Home level configs.
• { home } - For standalone Home configs.

Registering defaults values#

{
  # you can assign static values directly.
  den.default.nixos = {
    system.stateVersion = "25.11";
  };

  # you can also include other aspects
  den.default.includes = [
    { darwin.system.stateVersion = 6; }
  ]
}

It is possible to also register context-aware parametric aspects in den.defaults. This is how you can provide a default to all hosts or users that match a condition.

# This example is split to aid reading.
let
  hasOneUser = host:
    length (attrNames host.users) == 1;
  hasUser = host: user:
    hasAttr user.name host.users;
  makeAdmin = user: {
    nixos.users.users.${user.name} = {
      extraGroups = [ "wheel" ]; 
    };
  };

  # IFF host has ONE user, make it admin
  single-user-is-admin = { host, user }: 
    if hasOneUser host && hasUser host user
    then makeAdmin user else { };
in
{
  den.default.includes = [
    # will be called *ONLY* on when the
    # `{ host, user }` context is used.
    single-user-is-admin
  ];
}

Custom parametric providers.#

The following is the code for how den.default is defined.

{ den, ... }: {
  den.default.__functor = den.lib.parametric true;
}

You can do the very same for other aspects of you that can have context-aware aspects in their .includes.

{ den, ...}: {
  den.aspects.gaming.__functor = den.lib.parametric true;

  # any other file can register gaming aspects
  den.aspects.gaming.include = [
    ({ emulation }: {
      nixos = ...;
      includes = [ den.aspects.steam ];
    })

    { nixos = ...; } # always included
    ({ gpu }: { }) # non-match on my-laptop
  ];

  # then you can depend on the gaming aspect:
  den.aspects.my-laptop.includes = [ 
    (den.aspects.gaming { emulation = "neogeo"; })
  ];

}

For more examples on parametric aspects explore our batteries.

Use the source, Luke!

Aspect dependencies#

Accessing an aspect module causes flake-aspects to resolve it by including the aspect's own class module and the same-class module of all its transitive includes.

Aditional to this, den registers some special dependencies designed to aid on Den particular use case: Host/Users, Homes.

Host dependencies#

Host also include den.aspects.<host> { inherit host; } meaning all included parametric aspects have an opportunity to produce aditional configurations for the host.

Also for each user, den.aspects.<user> { inherit host user; } is called. So den.aspects.alice.nixos can provide config to all hosts where alice lives. And also has the opportunity to register parametric aspects on alice.provides that inspect the host attribute to contionally produce other aspects.

User dependencies#

User modules are read from os-home configurations.

It basically invokes den.aspects.<user> { inherit host user; } but this time the host also contributes back generic configs to the users. If you are wondering how this is not recursive, the answer is by using our contexts, user-to-host dependencies start with a { host } context, while host-to-user dependencies start with a { user, host } context, and even when both are given to den.aspects.<user> ctx the results are non recursive.

A user also depends on den.default { inherit host user; }.

Home dependencies#

Home just uses its own module, its includes, and invokes den.default { inherit home; }.

# modules/namespace.nix
{ config, ... }:
{
  den.aspects.vix.provides = { };
  _module.args.vix = # up to provides
    config.den.aspects.vix.provides;
}

# modules/my-laptop.nix
{ vix, ... }:
{
  vix.gaming = {
    _.steam.includes = [ 
      vix.gpu 
      vix.performance-profile 
    ];
  };
}

See real-life example from vic/vix

# modules/routes.nix
{ den, ... }:
let
  noop = _: { };

  by-platform-config = { host }:
    vix.${host.system} or noop;

  user-provides-host-config = { user, host }:
    vix.${user.aspect}._.${host.aspect} or noop;

  host-provides-user-config = { user, host }:
    vix.${host.aspect}._.${user.aspect} or noop;

  route = locator: { user, host }@ctx: 
    (locator ctx) ctx;
in 
{
  den.aspects.routes.__functor = 
    den.lib.parametric true;
  den.aspects.routes.includes = 
    map route [
      user-provides-host-config
      host-provides-user-config
      by-platform-config
    ];
}

{
  # for all darwin hardware
  vix.aarch64-darwin = { host }: {
    darwin = ...; 
  };

  # config bound to vic user 
  # on my-laptop host.
  vix.vic.provides.my-laptop = 
    { host, user }: {
      nixos = ...;
    };
}

Use your imagination, come up with an awesome Dendritic setup that suits you.