nixos/Droidnix

Droidnix: A Dendritic NixOS + Home Manager Configuration NixOS Configuration Structure

• Shortcuts
• Introduction
  • What is Droidnix
    • Installed components:
      • Core
      • Hyprland
      • Mangowc
    • Goals, project Structure, import hierarchy
• Root Level
• Generated Structure
  • First Setup
• The Assets Folder
• The Actual Code
  • flake.nix
  • debug-modules.nix
• Let's define the core of the system
  • generated/parked/system/networking.nix
  • generated/todo/system/services.nix
  • generated/modules/users/henrov.nix
  • generated/todo/system/homebase.nix
  • generated/todo/system/homebax.nix
  • generated/hosts/traveldroid/boot.nix
• First the nix-files that flake really needs and that do not fit wel in the hierarchical structure
  • generated/hosts/traveldroid/traveldroid.nix
  • generated/hosts/traveldroid/hardware-configuration.nix
  • generated/parked/system/dbus.nix
  • generated/todo/system/bluetooth.nix
  • generated/todo/desktop/xdg.nix
  • generated/parked/desktop/stylix.nix
  • generated/parked/system/terminal.nix
  • generated/parked/desktop/rotating_wallpaper.nix
  • generated/parked/desktop/hyprland.nix
  • generated/parked/apps/zenbrowser.nix
  • generated/parked/apps/flatpaks.nix
  • generated/todo/desktop/gtk.nix
  • generated/parked/desktop/fonts.nix
  • generated/parked/desktop/waybar.nix
  • generated/todo/system/login-tuigreeter.nix
  • generated/parked/desktop/wayland.nix
  • generated/parked/apps/thunar.nix
  • generated/parked/terminals/kitty.nix
  • generated/parked/terminals/starship.nix
  • generated/parked/terminals/zsh.nix
  • generated/parked/apps/emacs/emacs.nix
  • generated/parked/apps/emacs/early-init.el
  • generated/parked/apps/emacs/init.el
  • generated/parked/apps/wofi.nix

Shortcuts

Introduction The Assets Folder The Actual Code

—

Introduction   intro

What is Droidnix

Droidnix is a modular, declarative NixOS + Home Manager configuration system. It allows users to choose between Hyprland and Mangowc as their window manager, with shared and WM-specific configurations managed via Emacs Org and Nix Flakes. The project is designed for reproducibility, maintainability, and cross-machine compatibility.

Installed components:

Core

Hyprland

Mangowc

Goals, project Structure, import hierarchy

This project uses a modular NixOS configuration with Hyprland and MangoWC support, designed for literate programming and cross-device reusability. The Droidnix repository is organized into two main parts:

1. .assets/: Static, non-generated files (e.g., configs, scripts, themes).
2. Generated folders (system, hyprland, mangowc): NixOS and Home Manager configurations, generated from Org files.

Root Level

• flake.nix is the entry point and imports:

  • generated/system/
  • generated/parked/desktop/
  • Machine-specific configurations from assets/machines/

Generated Structure

The generated/ directory contains all generated configurations, divided into three main groups: system, hyprland, and mangowc.

First Setup

1. Clone this repository.
2. Run the setup script: ./setup_droid.
3. Edit .assets/system/conf/base.conf to choose your window manager (wm = "hyprland" or wm = "mangowc").
4. Tangle this Org file to generate Nix configurations: C-c C-v t in Emacs or use this: emacs README.org --batch -f org-babel-tangle && emacs --batch --eval "(setq org-html-htmlize-output-type nil)" README.org -f org-html-export-to-html
5. Build and switch: sudo nixos-rebuild switch --flake .#<hostname>.

—

The Assets Folder   assets

The .assets/ folder contains all static files, such as configs, scripts, and themes. These files are not generated and can be edited directly.

The Actual Code   code

This section contains the Org blocks for tangling Nix code into the generated folders.

flake.nix

The Nix flake definition for Droidnix.

{
  description = "Droidnix: A dendritic NixOS + Home Manager configuration";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";

    home-manager = {
      url = "github:nix-community/home-manager";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    hyprland.url = "github:hyprwm/Hyprland";
    flake-parts.url = "github:hercules-ci/flake-parts";
    import-tree.url = "github:vic/import-tree";

    stylix = {
      url = "github:nix-community/stylix";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    emacs-overlay = {
      url = "github:nix-community/emacs-overlay";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    zen-browser = {
      url = "github:youwen5/zen-browser-flake";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };

  outputs = inputs@{ flake-parts, nixpkgs, ... }:
     flake-parts.lib.mkFlake { inherit inputs; } {

       systems = [ "x86_64-linux" ];

       flake = {
         nixosConfigurations.traveldroid = nixpkgs.lib.nixosSystem {
           system = "x86_64-linux";

           specialArgs = { inherit inputs; };

           modules =
             [
               # ./generated/system/mysystem.nix
             ]
             # ++ (inputs.import-tree ./generated/parked).imports # moved to traveldroid
             ++ [
               ./generated/hosts/traveldroid/traveldroid.nix
               ./generated/hosts/traveldroid/boot.nix
               ./generated/hosts/traveldroid/hardware-configuration.nix

               inputs.stylix.nixosModules.default
               inputs.home-manager.nixosModules.home-manager
             ];
          };
       };
     };
 }

debug-modules.nix

The Nix flake definition for Droidnix.

{ lib, inputs }:

let
  modulesPath = ./generated/parked;
  importedModules = inputs.import-tree modulesPath;
  moduleSwitches = import ./assets/system/modules.conf;

  enabledModules =
    lib.filterAttrs (name: _: moduleSwitches.${name} or false)
      importedModules.imports;

  moduleList = builtins.attrValues enabledModules;

  debugFragment = module:
    let
      frag =
        if builtins.hasAttr "homeManagerExtraUserFragment" module
        then module.homeManagerExtraUserFragment
        else {};
      evaluated =
        if builtins.isFunction frag then frag {} else frag;
      isAttrs = builtins.isAttrs evaluated;
      isList  = builtins.isList evaluated;
      isThunk = builtins.isFunction frag;
    in
      {
        name = if builtins.hasAttr "name" module then module.name else "unknown";
        isAttrs = isAttrs;
        isList = isList;
        isThunk = isThunk;
      };

  debugList = map debugFragment moduleList;
in
  debugList

Let's define the core of the system

generated/parked/system/networking.nix

This sets the networking.

{ lib, config, pkgs,... }:

let
  coreEnabled = config.mySystem.system.core.enable or false;
in
{
  options.mySystem.system.locale.enable =
    lib.mkEnableOption "Network settings";

  config = lib.mkIf (coreEnabled || config.mySystem.system.locale.enable) {

  networking = {
    useDHCP = lib.mkDefault true;
    networkmanager.enable = true;
    networkmanager.wifi.backend = "iwd";
    wireless.iwd.enable = true;
    wireless.userControlled.enable = true;
    firewall = {
      enable = true;
      # KDE Connect: discovery + encrypted connections
      allowedTCPPortRanges = [
        {
          from = 1714;
          to = 1764;
        }
      ];
      allowedUDPPortRanges = [
        {
          from = 1714;
          to = 1764;
        }
      ];
    };
  };

  # Install NetworkManager
  environment.systemPackages = with pkgs; [
    networkmanager
  ];
};
}

generated/todo/system/services.nix

This sets the networking.

{ lib, config, ... }:

let
  coreEnabled = config.mySystem.system.core.enable or false;
in
{
  options.mySystem.system.locale.enable =
    lib.mkEnableOption "Services settings (printing / audio)";

  config = lib.mkIf (coreEnabled || config.mySystem.system.locale.enable) {

    # --- Services (Printing & Audio) ---
    services.printing.enable = true;
    services.pulseaudio.enable = false;
    security.rtkit.enable = true;
    services.pipewire = {
      enable = true;
      alsa.enable = true;
      alsa.support32Bit = true;
      pulse.enable = true;
    };
  };
}

generated/modules/users/henrov.nix

This is the default user, just search and replace henrov another name if you want to change

{ lib, config, pkgs, ... }:

let
  username = "henrov";
in
{
  # NixOS system user
  users.users.${username} = {
    isNormalUser = true;
    home = "/home/${username}";
    hashedPassword = "$6$S7iShgBxB.77CwmP$i0njK.2r3OL5UEvgZbmwZ0rnpZ4QyJcv8p9uCmJ4AiVPSMXkQkIwMLzyAOnJ0q8.tPLIp/7EquEIZeK8qbmgw/";
    extraGroups = [ "wheel" "networkmanager" ];
  };

  # Home Manager user definition
  _module.args.hmUsers = {
    ${username} = {
      home.stateVersion = "26.05";
      home.username = username;
      home.homeDirectory = "/home/${username}";
    };
  };
}

generated/todo/system/homebase.nix

{ lib, config, ... }:

let
  coreEnabled = config.mySystem.system.core.enable or false;
in
{
  options.mySystem.system.locale.enable =
    lib.mkEnableOption "Home-Manager settings";

  config = lib.mkIf (coreEnabled || config.mySystem.system.locale.enable) {

    # --- Home Manager Base ---
    home-manager = {
      backupFileExtension = "backup";

      users.henrov = {
	  home.sessionVariables = {
	    TERMINAL = "kitty";
	    EDITOR = "emacs";
	    BROWSER = "zen";
	  };

        home.stateVersion = "26.05";
      };
    };

  };
}

generated/todo/system/homebax.nix

{ lib, config, ... }:

let
  coreEnabled = config.mySystem.system.core.enable or false;
in
{
  # Top-level option for this module
  options.mySystem.system.locale.enable =
    lib.mkEnableOption "Enable Nix & Flake specific settings";

  # Top-level container for all custom program configs (your myPrograms idea)
  options.myPrograms = lib.mkOption {
    type = lib.types.attrsOf lib.types.any;
    default = {};
    description = "Container for all custom program configurations";
  };

  # Apply the configuration only if core or locale is enabled
  config = lib.mkIf (coreEnabled || config.mySystem.system.locale.enable) {
    nix.settings = {
      experimental-features = [ "nix-command" "flakes" ];
      download-buffer-size = 536870912; # 512 MB
      cores = 2;
      max-jobs = 1;
    };
  };
}

generated/hosts/traveldroid/boot.nix

{ inputs, config, lib, pkgs, ... }:
{

  boot.loader.grub = {
    enable = true;
    efiSupport = true;
    device = "nodev";
    useOSProber = true;
  };
  #boot.efi.canTouchEfiVariables = true;

  boot.kernelParams = [
    "systemd.mask=dev-tpm0.device"
    "systemd.mask=dev-tpmrm0.device"
  ];
}

First the nix-files that flake really needs and that do not fit wel in the hierarchical structure

generated/hosts/traveldroid/traveldroid.nix

{ lib, config, pkgs, inputs, ... }:

let
  username = config.defaultUser or "henrov";
  modulesPath = ./generated/modules;

  # Import all modules recursively
  importedModules = inputs.import-tree modulesPath;

  # Evaluate all modules
  evaluatedModules =
    map (m:
      if builtins.isFunction m then m { inherit lib config pkgs; } else m
    ) importedModules.imports;

  # Attach names
  modulesWithNames =
    map (m: {
      name = if m ? _file then lib.removeSuffix ".nix" (builtins.baseNameOf m._file) else "unknown";
      value = m;
    }) evaluatedModules;

  # Filter enabled modules from config file (optional)
  moduleSwitches = import ../../../assets/system/conf/modules.conf;
  enabledModules =
    builtins.filter (m: moduleSwitches.${m.name} or false) modulesWithNames;

  # Collect Home Manager user attrsets
  hmUsersList = map (m: m.value._module.args.hmUsers or {}) enabledModules;

in {
  networking.hostName = "traveldroid";
  system.stateVersion = "26.05";

  imports = [
    ./boot.nix
    ./hardware-configuration.nix
  ];

  # Merge Home Manager user configurations
  home-manager.users = lib.mkMerge hmUsersList;
}

generated/hosts/traveldroid/hardware-configuration.nix

1. Boot into NixOS Live ISO or your installed system.
2. Open a terminal.
3. Run: <code>sudo nixos-generate-config –root /mnt</code> (Omit –root /mnt if already running NixOS.)

{
  hostname,
  pkgs,
  lib,
  modulesPath,
  user,
  config,
  ...
}:
{
  imports = [
    # (modulesPath + "/installer/scan/not-detected.nix")
    #../../hardware/hardware.nix
  ];

  boot.initrd.availableKernelModules = [
    "xhci_pci"
    "nvme"
    "usb_storage"
    "sd_mod"
    "rtsx_usb_sdmmc"
  ];
  boot.initrd.kernelModules = [ ];
  boot.kernelModules = [ "kvm-intel" ];
  boot.extraModulePackages = [ ];

  fileSystems."/" = {
    device = "/dev/disk/by-uuid/69433a14-fbaf-401b-af85-cd1bbf02b4e2";
    fsType = "ext4";
  };

  fileSystems."/boot" = {
    device = "/dev/disk/by-uuid/811D-0676";
    fsType = "vfat";
    options = [
      "fmask=0077"
      "dmask=0077"
    ];
  };

  swapDevices = [
    { device = "/dev/disk/by-uuid/b6c557c2-7682-460b-a5e7-8f6f2f429a3a"; }
  ];

  nixpkgs.hostPlatform = lib.mkDefault "x86_64-linux";
  hardware.cpu.intel.updateMicrocode = lib.mkDefault config.hardware.enableRedistributableFirmware;
}

generated/parked/system/dbus.nix

This sets the dbus implementation

{ config, pkgs, lib, ... }:
{
  services.dbus = lib.mkForce {
    enable = true; # Force this to be true
  };

  # Configure dbus-broker via its configuration file
  environment.etc."dbus-broker/launch.conf".text = ''
    [General]
    LogLevel=warning
    MaxConnectionsPerUser=2048
  '';
}

generated/todo/system/bluetooth.nix

This sets the bluetooth implementation

{ config, pkgs, ... }:
{
  # Enable Bluetooth hardware and daemon
  hardware.bluetooth = {
    enable = true;
    powerOnBoot = true;
    packages = with pkgs; [ bluez ];
  };

  # Enable Bluetooth audio support in PipeWire
  services.pipewire = {
    config.pulse = {
      bluez5.enable = true;
    };
  };

  # Optional: Additional Bluetooth settings
  hardware.bluetooth.extraConfig = ''
    AutoEnable=true
    DiscoverableTimeout=0
    PairableTimeout=0
  '';

  # Install a graphical Bluetooth manager (optional)
  environment.systemPackages = with pkgs; [
    blueman
  ];
}

generated/todo/desktop/xdg.nix

This sets the XDG implementation

{ config, pkgs, ... }:
{
  xdg.portal = {
    enable = true;
    config.system.default = [ "hyprland" "gtk" ];
  };
}

generated/parked/desktop/stylix.nix

This sets the stylix implementation

{ lib, config, ... }:

let
  # --- Module variables ---
  moduleName = "stylix";
  username   = config.defaultUser or "henrov";

  # Assets directory for Stylix config
  assetPath = ../../../assets/system/conf/${moduleName};

  # Read all config files
  programFiles = builtins.readDir assetPath;

  files = lib.genAttrs (builtins.attrNames programFiles) (name: {
    src = "${assetPath}/${name}";
  });

  # Top-level toggle for this module
  enableProgram = config.enableStylix or false;

  # Read the main stylix.conf
  stylixConfFile = "${assetPath}/stylix.conf";
  stylixConf     = if builtins.pathExists stylixConfFile
                    then builtins.readFile stylixConfFile
                    else "";

  # Default cursor values
  cursorName = "phinger-cursors-light";
  cursorSize = 24;

in
{
  # --- Top-level toggle ---
  options.enableStylix = lib.mkEnableOption "Enable Stylix system theming";

  # --- Only apply configuration if enabled ---
  config = lib.mkIf enableProgram {

    # Deploy Stylix configuration files to user's XDG config
    home-manager.users.${username}.xdg.configFile =
      lib.mapAttrs' (name: value: {
        name  = "${moduleName}/${name}";
        value.source = value.src;
      }) files;

    # Merge all session variables into a single map
    home-manager.users.${username}.home.sessionVariables = lib.mkMerge [
      {
        STYLIX_CONF = stylixConf;
      }
      {
        XCURSOR_THEME    = cursorName;
        XCURSOR_SIZE     = toString cursorSize;
        HYPRCURSOR_THEME = cursorName;
        HYPRCURSOR_SIZE  = toString cursorSize;
      }
    ];

    # Optional wallpaper helper packages (symbolic, install manually or via packages)
    environment.systemPackages = [
      "feh"
      "st"
    ];
  };
}

generated/parked/system/terminal.nix

Sets theming for the terminal

{ config, pkgs, ... }:

{
  # (NVF = Neovim/terminal flavor)
  stylix.targets.nvf.enable = true;
  # feh wallpaper integration
  stylix.targets.feh.enable = true;
}

generated/parked/desktop/rotating_wallpaper.nix

rotating_wallpaper.nix installs wpaperd and deploys your wallpaper files from the repo (./assets/hyprland/wallpaperstuff/) into ~/Droidnix/wallpaperstuff/. You can edit assets/hyprland/wallpaperstuff/wallpaper.toml to change settings Finally, it creates a systemd user service (wpaperd.service) that automatically starts wpaperd at login and keeps it running, using your override config so wallpapers rotate according to your settings.

{ lib, … }:

{ flake.nixosModules.rotating-wallpaper = { config, pkgs, lib, … }:

let wallpaperConf = ../../../assets/hyprland/wallpaperstuff/wallpaper.toml; in { options.mySystem.desktop.wallpaper.enable = lib.mkEnableOption "Enable rotating wallpaper via wpaperd";

config = lib.mkIf (config.mySystem.desktop.wallpaper.enable or false) {

home-manager.users.henrov = {

home.packages = [ pkgs.wpaperd ];

home.file.".config/wpaperd/wallpaper.toml".source = wallpaperConf;

systemd.user.services.wpaperd = { description = "wpaperd wallpaper daemon"; wantedBy = [ "default.target" ];

serviceConfig = { Type = "simple"; ExecStart = "${pkgs.wpaperd}/bin/wpaperd –config ~/.config/wpaperd/wallpaper.toml"; Restart = "on-failure"; RestartSec = 1; }; }; }; }; }; }

generated/parked/desktop/hyprland.nix

Setting up Hyprland

{ lib, config, pkgs, ... }:

let
  username = config.defaultUser or "henrov";
  assetPath = ../../../assets/hyprland/conf/hypr;
  mainConfig = "${assetPath}/hyprland.conf";
in
{
  # Home Manager user settings
  _module.args.hmUsers = {
    ${username} = {
      home.packages = [ pkgs.hyprland ];

      # Set config files under ~/.config/hypr
      home.file.".config/hypr/hyprland.conf".source = mainConfig;

      # Example additional settings (can extend per module)
      settings.general."col.active_border" = "0xff97cbcd 0xff89b4fa";
    };
  };
}

generated/parked/apps/zenbrowser.nix

This is top file of this level which contains just an import statement for all relevant files and/or the subfolder in this folder

{ lib, config, pkgs, ... }:

let
  # --- Program definition ---
  programName = "zenbrowser";

  # Assets (optional, empty if no config)
  assetPath =
    if builtins.pathExists ../../../assets/system/conf/${programName}
    then ../../../assets/system/conf/${programName}
    else null;

  programFiles =
    if assetPath != null then builtins.readDir assetPath else {};

  files = lib.genAttrs (builtins.attrNames programFiles) (name: {
    src = "${assetPath}/${name}";
  });

  # Top-level toggle for this module
  enableProgram = config.enableZenBrowser or false;

  # Default user fallback
  username = config.defaultUser or "henrov";
in
{
  # --- Option ---
  options.enableZenBrowser = lib.mkEnableOption "Install Zen Browser";

  # --- Config ---
  config = lib.mkIf enableProgram {

    # --- Deploy assets (if any) ---
    environment.etc."${programName}".source = assetPath;

    # --- System packages ---
    environment.systemPackages = [ pkgs.zen-browser ];

    # --- Example systemd service to sync assets ---
    systemd.services."${programName}-sync" = {
      description = "Sync ${programName} configuration files";
      wantedBy    = [ "multi-user.target" ];
      wants       = [ "network-online.target" ];
      after       = [ "network-online.target" ];

      serviceConfig = {
        Type = "oneshot";
        ExecStart = ''
          set -euo pipefail
          if [ -d "${assetPath}" ]; then
            for f in ${lib.concatStringsSep " " (builtins.attrNames files)}; do
              cp -u "${assetPath}/$f" "/home/${username}/.config/${programName}/$f"
            done
          fi
        '';
      };

      restartTriggers = [ assetPath ];
      path = [];
    };
  };
}

generated/parked/apps/flatpaks.nix

This will import all packages listed in ../../assets/system/apps/flatpaks.conf

{ lib, pkgs, config, ... }:

let
  # Module name
  moduleName = "flatpaks";

  # Top-level toggle for this module
  enableProgram = config.enableFlatpaks or false;

  # Path to your Flatpak list
  assetPath = ../../../assets/system/apps/flatpaks.conf;

  # Resolve user safely
  username = config.defaultUser or "henrov";
in
{
  # --- Top-level toggle option ---
  options.enableFlatpaks = lib.mkEnableOption "Enable automatic Flatpak installation";

  # --- Config only applied if enabled ---
  config = lib.mkIf enableProgram {

    # Deploy the Flatpak conf file
    environment.etc."flatpak/flatpaks.conf".source = assetPath;

    # Enable system Flatpak service
    services.flatpak.enable = true;
    xdg.portal.enable = true;

    # Systemd service to install Flatpaks from the list
    systemd.services."${moduleName}-sync" = {
      description = "Install Flatpak apps listed in flatpaks.conf";
      wantedBy    = [ "multi-user.target" ];
      wants       = [ "network-online.target" ];
      after       = [ "network-online.target" ];

      serviceConfig = {
        Type = "oneshot";
        ExecStart = ''
          set -euo pipefail
          CONF="${assetPath}"

          # Add Flathub if not present
          if ! flatpak remotes --system --columns=name | grep -qx flathub; then
            flatpak remote-add --system --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo
          fi

          # Install every Flatpak listed in the conf file
          while IFS= read -r app || [ -n "$app" ]; do
            app=$(echo "$app" | sed 's/#.*//;s/^[[:space:]]*//;s/[[:space:]]*$//')
            if [ -n "$app" ]; then
              if ! flatpak info --system "$app" >/dev/null 2>&1; then
                flatpak install --system -y --noninteractive flathub "$app"
              fi
            fi
          done < "$CONF"
        '';
      };

      restartTriggers = [ assetPath ];

      # Include only the packages needed for this service
      path = [ pkgs.flatpak pkgs.coreutils pkgs.gnugrep pkgs.gnused ];
    };
  };
}

generated/todo/desktop/gtk.nix

Setting up GTK

{ pkgs, user, ... }:
{
  environment.systemPackages = with pkgs; [
      gtk3     # GTK target
      gtk4     # GTK target
    ];
  # Stylix GTK target
  stylix.targets.gtk.enable = true;

  home-manager.users.${user.username} = {
    gtk = {
      enable = true;
      theme = {
        name = "Catppuccin-Mocha-Standard-Blue-Dark";
        package = pkgs.magnetic-catppuccin-gtk;
      };
      iconTheme = {
        name = "Papirus-Dark";
        package = pkgs.papirus-icon-theme;
      };
      gtk3.extraConfig = {
        gtk-application-prefer-dark-theme = 1;
      };
      gtk4.extraConfig = {
        gtk-application-prefer-dark-theme = 1;
      };
    };

  };
}

generated/parked/desktop/fonts.nix

This file installs and configures fonts

{ lib, pkgs, config, ... }:

{
  options.enableFonts = lib.mkEnableOption "Enable nerd fonts";

  config = lib.mkIf (config.enableFonts or false) {
    fonts.packages = with pkgs; [
      nerd-fonts.iosevka
      nerd-fonts.fira-code
    ];
  };
}

generated/parked/desktop/waybar.nix

This file installs and configures waybar

{ lib, config, ... }:

let
  # --- Module variables ---
  moduleName = "waybar";
  username   = config.defaultUser or "henrov";

  # Assets directory (self-contained)
  assetPath = ../../../assets/system/conf/${moduleName};

  # Read required config files
  waybarConfig = "${assetPath}/waybar.conf";
  waybarStyle  = "${assetPath}/style.css";

  # Top-level toggle
  enableProgram = config.enableWaybar or false;
in
{
  # --- Option ---
  options.enableWaybar =
    lib.mkEnableOption "Enable Waybar status bar";

  # --- Config ---
  config = lib.mkIf enableProgram {

    # Install Waybar (symbolic reference expected to be resolved elsewhere)
    environment.systemPackages = [
      "waybar"
    ];

    # Deploy only required files to ~/.config/waybar
    home-manager.users.${username}.xdg.configFile = {

      "waybar/config".source =
        if builtins.pathExists waybarConfig
        then waybarConfig
        else null;

      "waybar/style.css".source =
        if builtins.pathExists waybarStyle
        then waybarStyle
        else null;
    };
  };
}

generated/todo/system/login-tuigreeter.nix

This is top file of this level which contains just an import statement for all relevant files and/or the subfolder in this folder

{ pkgs, user, ... } :
{
environment.systemPackages = with pkgs; [
tuigreet
];
services.greetd = {
enable = true;
settings = {
  default_session = {
  command = pkgs.lib.mkForce "${pkgs.tuigreet}/bin/tuigreet --remember --time --time-format '%I:%M %p | %a • %h | %F'";
  };
};
};
}

generated/parked/desktop/wayland.nix

This file sets up wayland

{ lib, config, ... }:

let
  # --- Module variables ---
  moduleName = "wayland";
  username   = config.defaultUser or "henrov";

  # Top-level toggle
  enableProgram = config.enableWayland or false;
in
{
  # --- Option ---
  options.enableWayland =
    lib.mkEnableOption "Enable Wayland support";

  # --- Config ---
  config = lib.mkIf enableProgram {

    # Enable Hyprland in Wayland
    wayland.windowManager.hyprland = {
      enable = true;

    # Enable XDG portals (required for Wayland apps)
    xdg.portal.enable = true;

    # Home Manager configuration
    home-manager.users.${username} = {

      xdg.portal = {
        enable = true;

        # Only unavoidable pkgs reference
        extraPortals = [
          config.pkgs.xdg-desktop-portal-hyprland
        ];

        config.hyprland = {
          "org.freedesktop.impl.portal.Screencast" = [ "hyprland" ];
        };
      };

      # Wayland-related user package
      home.packages = [
        config.pkgs.uwsm
      ];
    };
  };
}

generated/parked/apps/thunar.nix

This is top file of this level which contains just an import statement for all relevant files and/or the subfolder in this folder

{ lib, pkgs, config, ... }:

let
  enableProgram = config.enableThunar or false;
  username = config.defaultUser or "henrov";
in
{
  # Top-level toggle
  options.enableThunar = lib.mkEnableOption "Enable Thunar file manager";

  # Only apply config if enabled
  config = lib.mkIf enableProgram {
    # Install Thunar and related packages system-wide
    environment.systemPackages = [
      pkgs.thunar
      pkgs.thunar-plugins
      pkgs.xarchiver
    ];

    # Remove invalid top-level 'home' reference
    # If you want sessionVariables, define them in Home Manager instead
    # Example for Home Manager:
    # home-manager.users.${username}.sessionVariables = {
    #   FILE_MANAGER = "thunar";
    #   USERNAME = username;
    # };
  };
}

generated/parked/terminals/kitty.nix

This file sets up Kitty terminal

{ lib, pkgs, config, ... }:

let
  moduleName   = "kitty";
  username     = config.defaultUser or "henrov";

  assetPath    = ../../../assets/system/conf/${moduleName};
  programFiles = builtins.readDir assetPath;
  files        = lib.genAttrs (builtins.attrNames programFiles) (name: {
    src = "${assetPath}/${name}";
  });

  enableProgram = config.enableKitty or true;
in
{
  options.enableKitty = lib.mkEnableOption "Enable Kitty terminal integration";

  config = lib.mkIf enableProgram {

    # Install kitty system-wide
    environment.systemPackages = [ pkgs.kitty ];

    # Home Manager user-specific configuration
    home-manager.users.${username} = {
      programs.kitty.enable = true;

      programs.kitty.extraConfig = ''
        # Include the Catppuccin-Mocha theme
        include themes/Catppuccin-Mocha.conf
      '';

      xdg.configFile =
        lib.mapAttrs' (name: value: {
          name  = "${moduleName}/${name}";
          value.source = value.src;
        }) files;
    };
  };
}

generated/parked/terminals/starship.nix

This file sets up starship prompt

{ lib, ... }:

let
  # Path to your Starship config inside the flake
  starshipAssets = ../../../assets/system/conf/starship.toml;

  # Read and parse the TOML file as a symbolic value
  starshipConfig = lib.importTOML starshipAssets;

  # Toggle on/off
  enableStarship = true;
in
{
  # Declare a top-level module option
  options.starship = {
    enable = lib.mkEnableOption "Enable Starship prompt";
    configFiles = lib.mkOption {
      type = lib.types.attrsOf lib.types.any;
      default = {};
      description = "Symbolic Starship configuration files";
    };
  };

  # Populate the option safely
  config = lib.mkIf enableStarship {
    starship.enable = true;
    starship.configFiles = {
      "starship.toml" = starshipConfig;
      assetsDir = ../../../assets/system/conf;
    };
  };
}

generated/parked/terminals/zsh.nix

This sets up the zsh in the terminal

{ lib, pkgs, config, ... }:

let
  programName   = "zsh";
  programAssets = ../../../assets/system/conf/${programName};

  # Read the config file that will be injected into Zsh
  zshInitFile  = "${programAssets}/zsh.conf";

  # Toggle for this module
  enableProgram = config.enableZsh or false;

  # User reference
  username = config.defaultUser or "henrov";
in
{
  # Top-level toggle
  options.enableZsh = lib.mkEnableOption "Enable Zsh terminal with Oh-My-Zsh";

  # Only apply configuration if enabled
  config = lib.mkIf enableProgram {

    # Install Zsh system-wide
    environment.systemPackages = [ pkgs.zsh ];

    # Enable Zsh + Oh-My-Zsh
    programs.zsh.enable = true;
    programs.zsh.ohMyZsh.enable = true;
    programs.zsh.ohMyZsh.theme = "catppuccin-mocha";
    programs.zsh.ohMyZsh.plugins = [
      "git"
      "docker"
      "direnv"
      "zsh-autosuggestions"
      "zsh-completions"
      "zsh-history-substring-search"
    ];

    # Use the contents of zsh.conf as shellInit
    programs.zsh.shellInit = builtins.readFile zshInitFile;
  };
}

generated/parked/apps/emacs/emacs.nix

This sets up the emacs terminal

{ lib, pkgs, config, ... }:

let
  moduleName   = "emacs";
  username     = config.defaultUser or "henrov";

  # Paths to your init files (relative to this module)
  emacsAssets  = ../../../assets/system/conf/emacs;
  initFile     = "${emacsAssets}/init.el";
  earlyInitFile = "${emacsAssets}/early-init.el";

  # Toggle for this module
  enableProgram = config.enableEmacs or false;
in
{
  # Top-level toggle option
  options.enableEmacs = lib.mkEnableOption "Enable Emacs configuration";

  config = lib.mkIf enableProgram {

    # Minimal system-wide Emacs package
    environment.systemPackages = [
      pkgs.emacs-pgtk.override { withTreeSitter = true; }
    ];

    # Home Manager Emacs config
    home-manager.users.${username} = {
      programs.emacs = {
        enable = true;
        package = pkgs.emacs-pgtk.override { withTreeSitter = true; };

        extraPackages = epkgs: with epkgs; [
          # Core dev and language support
          manualPackages.treesit-grammars.with-all-grammars
          rust-mode
          rustic
          nix-mode
          hcl-mode

          # UI & workflow
          nerd-icons
          doom-modeline
          diminish
          eldoc
          eldoc-box
          pulsar
          which-key
          avy
          consult
          vertico
          marginalia
          crux
          shell-pop

          # Completion/snippets
          nerd-icons-corfu
          corfu
          cape
          orderless
          yasnippet
          yasnippet-snippets

          # Utilities
          rg
          exec-path-from-shell
          eat
          f
          gptel
          nixpkgs-fmt
          envrc

          # Theming
          catppuccin-theme

          # Git
          magit

          # Editing/workflow
          expreg
          vundo
          puni

          # Error/side panels
          sideline
          sideline-flymake
          sideline-eglot
        ];

        # Load your init files from assets
        initFile       = initFile;
        earlyInitFile  = earlyInitFile;
      };

      # Useful session variables
      home.sessionVariables = {
        EDITOR = "emacs";
        XDG_SCREENSHOTS_DIR = "~/screenshots";
      };
    };
  };
}

generated/parked/apps/emacs/early-init.el

This helps set up the emacs terminal

;;; package --- early init -*- lexical-binding: t -*-
 ;;; Commentary:
 ;;; Prevents white flash and better Emacs defaults
 ;;; Code:
 (set-language-environment "UTF-8")
 (setq-default
default-frame-alist
'((background-color . "#1e1e2e")
  (bottom-divider-width . 1)    ; Thin horizontal window divider
  (foreground-color . "#bac2de")    ; Default foreground color
  (fullscreen . maximized)      ; Maximize the window by default
  (horizontal-scroll-bars . nil)    ; No horizontal scroll-bars
  (left-fringe . 8)       ; Thin left fringe
  (menu-bar-lines . 0)      ; No menu bar
  (right-divider-width . 1)     ; Thin vertical window divider
  (right-fringe . 8)        ; Thin right fringe
  (tool-bar-lines . 0)      ; No tool bar
  (undecorated . t)       ; Remove extraneous X decorations
  (vertical-scroll-bars . nil))   ; No vertical scroll-bars
user-full-name "Henrov henrov"      ; ME!
;; memory configuration
;; Higher garbage collection threshold, prevents frequent gc locks, reset later
gc-cons-threshold most-positive-fixnum
;; Ignore warnings for (obsolete) elisp compilations
byte-compile-warnings '(not obsolete)
;; And other log types completely
warning-suppress-log-types '((comp) (bytecomp))
;; Large files are okay in the new millenium.
large-file-warning-threshold 100000000
;; dont show garbage collection messages at startup, will reset later
garbage-collection-messages nil
;; native compilation
package-native-compile t
native-comp-warning-on-missing-source nil
native-comp-async-report-warnings-errors 'silent
;; Read more based on system pipe capacity
read-process-output-max (max (* 10240 10240) read-process-output-max)
;; scroll configuration
scroll-margin 0           ; Lets scroll to the end of the margin
scroll-conservatively 100000        ; Never recenter the window
scroll-preserve-screen-position 1     ; Scrolling back and forth
;; frame config
;; Improve emacs startup time by not resizing to adjust for custom settings
frame-inhibit-implied-resize t
;; Dont resize based on character height / width but to exact pixels
frame-resize-pixelwise t
;; backups & files
backup-directory-alist '(("." . "~/.backups/")) ; Don't clutter
backup-by-copying t           ; Don't clobber symlinks
create-lockfiles nil          ; Don't have temp files
delete-old-versions t         ; Cleanup automatically
kept-new-versions 6           ; Update every few times
kept-old-versions 2           ; And cleanup even more
version-control t           ; Version them backups
delete-by-moving-to-trash t       ; Dont delete, send to trash instead
;; startup
inhibit-startup-screen t        ; I have already done the tutorial. Twice
inhibit-startup-message t         ; I know I am ready
inhibit-startup-echo-area-message t     ; Yep, still know it
initial-scratch-message nil       ; I know it is the scratch buffer!
initial-buffer-choice nil
inhibit-startup-buffer-menu t
inhibit-x-resources t
initial-major-mode 'fundamental-mode
pgtk-wait-for-event-timeout 0.001     ; faster child frames
ad-redefinition-action 'accept      ; dont care about legacy things being redefined
inhibit-compacting-font-caches t
;; tabs
tab-width 4             ; Always tab 4 spaces.
indent-tabs-mode nil          ; Never use actual tabs.
;; rendering
cursor-in-non-selected-windows nil      ; dont render cursors other windows
;; packages
use-package-always-defer t
load-prefer-newer t
default-input-method nil
use-dialog-box nil
use-file-dialog nil
use-package-expand-minimally t
package-enable-at-startup nil
use-package-enable-imenu-support t
auto-mode-case-fold nil  ; No second pass of case-insensitive search over auto-mode-alist.
package-archives '(("melpa"    . "https://melpa.org/packages/")
        ("gnu"    . "https://elpa.gnu.org/packages/")
        ("nongnu"   . "https://elpa.nongnu.org/nongnu/")
        ("melpa-stable" . "https://stable.melpa.org/packages/"))
package-archive-priorities '(("gnu"  . 99)
            ("nongnu" . 80)
            ("melpa"  . 70)
            ("melpa-stable" . 50))
)
;;; early-init.el ends here

generated/parked/apps/emacs/init.el

This helps set up the emacs terminal

;;; package --- Summary - My minimal Emacs init file -*- lexical-binding: t -*-

;;; Commentary:
;;; Simple Emacs setup I carry everywhere

;;; Code:
(setq custom-file (locate-user-emacs-file "custom.el"))
(load custom-file 'noerror)    ;; no error on missing custom file

(require 'package)
(package-initialize)

(defun reset-custom-vars ()
"Resets the custom variables that were set to crazy numbers"
(setopt gc-cons-threshold (* 1024 1024 100))
(setopt garbage-collection-messages t))

(use-package emacs
:custom
(native-comp-async-query-on-exit t)
(read-answer-short t)
(use-short-answers t)
(enable-recursive-minibuffers t)
(which-func-update-delay 1.0)
(visible-bell nil)
(custom-buffer-done-kill t)
(whitespace-line-column nil)
(x-underline-at-descent-line t)
(imenu-auto-rescan t)
(uniquify-buffer-name-style 'forward)
(confirm-nonexistent-file-or-buffer nil)
(create-lockfiles nil)
(make-backup-files nil)
(kill-do-not-save-duplicates t)
(sentence-end-double-space nil)
(treesit-enabled-modes t)
:init
;; base visual
(menu-bar-mode -1)       ;; no menu bar
(toggle-scroll-bar -1)     ;; no scroll bar
(tool-bar-mode -1)       ;; no tool bar either
(blink-cursor-mode -1)     ;; stop blinking

;; font of the century
(set-frame-font "Aporetic Sans Mono 12" nil t)

:bind
(("C-<wheel-up>" . pixel-scroll-precision) ; dont zoom in please, just scroll
 ("C-<wheel-down>" . pixel-scroll-precision) ; dont zoom in either, just scroll
 ("C-x k"    . kill-current-buffer)) ; kill the buffer, dont ask
:hook
(text-mode . delete-trailing-whitespace-mode)
(prog-mode . delete-trailing-whitespace-mode)
(after-init . global-display-line-numbers-mode) ;; always show line numbers
(after-init . column-number-mode)     ;; column number in the mode line
(after-init . size-indication-mode)     ;; file size in the mode line
(after-init . pixel-scroll-precision-mode)  ;; smooth mouse scroll
(after-init . electric-pair-mode)     ;; i mean ... parens should auto create
(after-init . reset-custom-vars)
)

(use-package autorevert
:ensure nil
:custom
(auto-revert-interval 3)
(auto-revert-remote-files nil)
(auto-revert-use-notify t)
(auto-revert-avoid-polling nil)
(auto-revert-verbose t)
:hook
(after-init . global-auto-revert-mode))

(use-package recentf
:ensure nil
:commands (recentf-mode recentf-cleanup)
:hook
(after-init . recentf-mode)
:custom
(recentf-auto-cleanup 'never)
(recentf-exclude
 (list "\\.tar$" "\\.tbz2$" "\\.tbz$" "\\.tgz$" "\\.bz2$"
   "\\.bz$" "\\.gz$" "\\.gzip$" "\\.xz$" "\\.zip$"
   "\\.7z$" "\\.rar$"
   "COMMIT_EDITMSG\\'"
   "\\.\\(?:gz\\|gif\\|svg\\|png\\|jpe?g\\|bmp\\|xpm\\)$"
   "-autoloads\\.el$" "autoload\\.el$"))

:config
;; A cleanup depth of -90 ensures that `recentf-cleanup' runs before
;; `recentf-save-list', allowing stale entries to be removed before the list
;; is saved by `recentf-save-list', which is automatically added to
;; `kill-emacs-hook' by `recentf-mode'.
(add-hook 'kill-emacs-hook #'recentf-cleanup -90))

(use-package savehist
:ensure nil
:commands (savehist-mode savehist-save)
:hook
(after-init . savehist-mode)
:custom
(savehist-autosave-interval 600)
(savehist-additional-variables
 '(kill-ring        ; clipboard
 register-alist       ; macros
 mark-ring global-mark-ring   ; marks
 search-ring regexp-search-ring)))

(use-package hl-line
:ensure nil
:custom
(hl-line-sticky-flag nil)
(global-hl-line-sticky-flag nil)
:hook
(after-init . global-hl-line-mode))

(use-package saveplace
:ensure nil
:commands (save-place-mode save-place-local-mode)
:hook
(after-init . save-place-mode)
:custom
(save-place-limit 400))

(use-package nerd-icons
:custom
;; disable bright icon colors
(nerd-icons-color-icons nil))hells.nix

(use-package doom-modeline
:custom
(inhibit-compacting-font-caches t)  ;; speed
(doom-modeline-buffer-file-name-style 'relative-from-project)
(doom-modeline-major-mode-icon nil) ;; distracting icons, no thank you
(doom-modeline-buffer-encoding nil) ;; everything is utf-8 anyway
(doom-modeline-buffer-state-icon nil) ;; the filename already shows me
(doom-modeline-lsp nil)     ;; lsp state is too distracting, too often
:hook (after-init . doom-modeline-mode))

(load-theme 'catppuccin :no-confirm)

(use-package diminish :demand t)   ;; declutter the modeline
(use-package eldoc
:diminish eldoc-mode
:custom
(eldoc-echo-area-use-multiline-p nil)) ;; docs for everything

(use-package eldoc-box
:defer t
:config
(set-face-background 'eldoc-box-border (catppuccin-color 'green))
(set-face-background 'eldoc-box-body (catppuccin-color 'base))
:bind
(("M-h" . eldoc-box-help-at-point)))

(use-package pulsar
:commands pulsar-global-mode pulsar-recenter-top pulsar-reveal-entry
:init
(defface pulsar-catppuccin
`((default :extend t)
  (((class color) (min-colors 88) (background light))
 :background ,(catppuccin-color 'sapphire))
  (((class color) (min-colors 88) (background dark))
 :background ,(catppuccin-color 'sapphire))
  (t :inverse-video t))
"Alternative nord face for `pulsar-face'."
:group 'pulsar-faces)
:custom
(pulsar-face 'pulsar-catppuccin)
:hook
(after-init . pulsar-global-mode))

(use-package which-key
:commands which-key-mode
:diminish which-key-mode
:hook
(after-init . which-key-mode))

(use-package expreg
:bind ("M-m" . expreg-expand))

(use-package vundo) ;; undo tree

;; better structured editing
(use-package puni
:commands puni-global-mode
:hook
(after-init . puni-global-mode))

(use-package avy
:bind
("M-i" . avy-goto-char-2)
:custom
(avy-background t))

(use-package consult
:bind
("C-x b" . consult-buffer)   ;; orig. switch-to-buffer
("M-y"   . consult-yank-pop) ;; orig. yank-pop
("M-g M-g" . consult-goto-line)  ;; orig. goto-line
("M-g i" . consult-imenu)  ;; consult version is interactive
("M-g r" . consult-ripgrep)  ;; find in project also works
:custom
(consult-narrow-key "<"))

(use-package vertico
:commands vertico-mode
:custom
(read-file-name-completion-ignore-case t)
(read-buffer-completion-ignore-case t)
(completion-ignore-case t)
(enable-recursive-minibuffers t)
(minibuffer-prompt-properties '(read-only t cursor-intangible t face minibuffer-prompt))
:init
(vertico-mode)
:hook
(minibuffer-setup-hook . cursor-intangible-mode))

(use-package marginalia
:commands marginalia-mode
:hook (after-init . marginalia-mode))

(use-package crux
:bind
("C-c M-e" . crux-find-user-init-file)
("C-c C-w" . crux-transpose-windows)
("C-c M-d" . crux-find-current-directory-dir-locals-file)
("C-a"   . crux-move-beginning-of-line))

(use-package magit
:bind (("C-M-g" . magit-status)))

(use-package nerd-icons-corfu
:commands nerd-icons-corfu-formatter
:defines corfu-margin-formatters)

(use-package corfu
:commands global-corfu-mode
:custom
(corfu-cycle t)
(corfu-auto t)
(corfu-auto-delay  1)
(corfu-auto-prefix 3)
(corfu-separator ?_)
:hook
(after-init . global-corfu-mode)
:config
(add-to-list 'corfu-margin-formatters #'nerd-icons-corfu-formatter))

(use-package cape)

(use-package orderless
:custom
(completion-styles '(orderless partial-completion basic))
(completion-category-defaults nil)
(completion-category-overrides nil))

(use-package yasnippet
:commands yas-global-mode
:diminish yas-minor-mode
:hook
(after-init . yas-global-mode))

(use-package yasnippet-snippets :after yasnippet)

(use-package exec-path-from-shell
:commands exec-path-from-shell-initialize
:custom
(exec-path-from-shell-arguments nil)
:hook
(after-init . exec-path-from-shell-initialize))

(use-package nixpkgs-fmt
:custom
(nixpkgs-fmt-command "nixfmt"))

(use-package eat
:bind
(("C-c e p" . eat-project)
 ("C-c e t" . eat)))

(use-package f :demand t)

(use-package envrc
:commands envrc-global-mode
:hook
(after-init . envrc-global-mode))

(use-package gptel
:commands gptel-make-anthropic f-read-text
:config
(gptel-make-anthropic "Claude"
:stream t :key (f-read-text "/run/secrets/claude_key")))

(use-package sideline-flymake)
(use-package sideline-eglot)
(use-package sideline
:custom
(sideline-backends-right '(sideline-flymake sideline-eglot))
:hook
(eglot-managed-mode . sideline-mode)
(flymake-mode . sideline-mode))

(use-package eglot
:custom
(eglot-extend-to-xref t)
(eglot-ignored-server-capabilities '(:inlayHintProvider))
(jsonrpc-event-hook nil)
:hook
(eglot-managed-mode . eldoc-box-hover-mode)
(before-save . eldoc-format-buffer)
:bind
(:map eglot-mode-map
  ("C-c l a" . eglot-code-actions)
  ("C-c l r" . eglot-rename)
  ("C-c l h" . eldoc)
  ("C-c l g" . xref-find-references)
  ("C-c l w" . eglot-reconnect)))

(use-package proced
:custom
(proced-auto-update-flag t)
(proced-auto-update-interval 3)
(proced-enable-color-flag t)
(proced-show-remote-processes t))

(use-package org
:ensure t
:defer t
:commands (org-mode org-capture org-agenda)
:init
(defvar org-journal-file "~/nextcloud/org/journal.org")
(defvar org-archive-file "~/nextcloud/org/archive.org")
(defvar org-notes-file "~/nextcloud/org/notes.org")
(defvar org-inbox-file "~/nextcloud/org/inbox.org")
(defvar org-work-file "~/nextcloud/org/work.org")
(defun my/org-capture-project-target-heading ()
"Determine Org target headings from the current file's project path.

This function assumes a directory structure like '~/projects/COMPANY/PROJECT/'.
It extracts 'COMPANY' and 'PROJECT' to use as nested headlines
for an Org capture template.

If the current buffer is not visi
ting a file within such a
project structure, it returns nil, causing capture to default to
the top of the file."
(when-let* ((path (buffer-file-name))) ; Ensure we are in a file-visiting buffer
  (let ((path-parts (split-string path "/" t " ")))
  (when-let* ((projects-pos (cl-position "projects" path-parts :test #'string=))
      (company  (nth (+ 1 projects-pos) path-parts))
      (project  (nth (+ 2 projects-pos) path-parts)))
  ;; Return a list of headlines for Org to find or create.
  (list company project)))))
:bind
(("C-c c" . org-capture)
 ("C-c i" . org-store-link)
 ("C-c a" . org-agenda)
 :map org-mode-map
 ("C-c t" . org-toggle-inline-images)
 ("C-c l" . org-toggle-link-display))
:custom
(org-agenda-files (list org-inbox-file org-journal-file))
(org-directory "~/nextcloud/org")
(org-default-notes-file org-inbox-file)
(org-archive-location (concat org-archive-file "::* From %s"))
(org-log-done 'time)
(org-log-into-drawer t)
(org-hide-emphasis-markers t)
(org-src-fontify-natively t)
(org-src-tab-acts-natively t)
(org-capture-templates '(("t" "todo" entry (file org-inbox-file)
        "* todo %?\n:PROPERTIES:\n:CREATED: %U\n:END:\n\n%a\n\n)")
         ("j" "Journal" entry (file+olp+datetree org-journal-file)
        "* %?\n:PROPERTIES:\n:CREATED: %U\n:END:\n\n%a\n\n")
         ("n" "Note" entry (file org-notes-file)
        "* %?\n:PROPERTIES:\n:CREATED: %U\n:END:\n\n%a\n\n")
         ("p" "Project Task" item
        (file+function org-work-file my/org-capture-project-target-heading)
        "* todo %? \n  CLOCK: %U"
        ))
       )
:config
;; Enable syntax highlighting in code blocks
(add-hook 'org-mode-hook 'turn-on-font-lock)
(add-hook 'org-mode-hook 'org-indent-mode))

;; extras
(use-package comp-run
:ensure nil
:config
(push "tramp-loaddefs.el.gz" native-comp-jit-compilation-deny-list)
(push "cl-loaddefs.el.gz" native-comp-jit-compilation-deny-list))

(use-package rustic
:custom
(rustic-lsp-client 'eglot))

(provide 'init)

;;; init.el ends here

generated/parked/apps/wofi.nix

This is top file of this level which contains just an import statement for all relevant files and/or the subfolder in this folder

{ lib, config, ... }:

let
  # --- Program definition ---
  programName = "wofi";

  # Path to assets
  assetPath = ../../../assets/system/conf/${programName};

  # Generate file mappings
  programFiles =
    if builtins.pathExists assetPath then builtins.readDir assetPath else {};
  files = lib.genAttrs (builtins.attrNames programFiles) (name: {
    src = "${assetPath}/${name}";
  });

  # Top-level toggle for this module
  enableProgram = config.enableWofi or false;

  # Default user
  username = config.defaultUser or "henrov";
in
{
  # --- Module option ---
  options.enableWofi = lib.mkEnableOption "Enable Wofi terminal launcher";

  # --- Config ---
  config = lib.mkIf enableProgram {

    # --- Deploy assets to ~/.config/wofi ---
    environment.etc."${programName}".source = assetPath;

    # --- Optional systemd service to sync config ---
    systemd.services."${programName}-sync" = {
      description = "Sync ${programName} configuration files";
      wantedBy    = [ "multi-user.target" ];
      wants       = [ "network-online.target" ];
      after       = [ "network-online.target" ];

      serviceConfig = {
        Type = "oneshot";
        ExecStart = ''
          set -euo pipefail
          if [ -d "${assetPath}" ]; then
            for f in ${lib.concatStringsSep " " (builtins.attrNames files)}; do
              mkdir -p "/home/${username}/.config/${programName}"
              cp -u "${assetPath}/$f" "/home/${username}/.config/${programName}/$f"
            done
          fi
        '';
      };

      restartTriggers = [ assetPath ];
      path = [];
    };
  };
}