monolith

{

  inputs = {

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

    crane.url = "github:ipetkov/crane";

  };

  outputs =

    {

      self,

      nixpkgs,

      crane,

    }:

    let

      lib = nixpkgs.lib;

      systems = [

        "x86_64-linux"

        "aarch64-linux"

      ];

      forAllSystems = f: lib.genAttrs systems (system: f nixpkgs.legacyPackages.${system});

      mkProject =

        pkgs:

        let

          craneLib = crane.mkLib pkgs;

          src = lib.cleanSourceWith {

            src = ./.;

            filter =

              path: type:

              (craneLib.filterCargoSources path type) || lib.hasInfix "/shaders" path || lib.hasInfix "/res" path;

            name = "source";

          };

          lavapipeIcd = "${pkgs.mesa}/share/vulkan/icd.d/lvp_icd.${pkgs.stdenv.hostPlatform.parsed.cpu.name}.json";

          commonArgs = {

            inherit src;

            pname = "monolith";

            version = "0.0.0";

            strictDeps = true;

            nativeBuildInputs = [

              pkgs.pkg-config

              pkgs.glslang

            ];

            buildInputs = with pkgs; [

              libxkbcommon

              vulkan-loader

              libinput

              seatd

              libgbm

              libdrm

              udev

            ];

          };

          cargoArtifacts = craneLib.buildDepsOnly commonArgs;

        in

        {

          inherit craneLib lavapipeIcd commonArgs;

          package = craneLib.buildPackage (

            commonArgs

            // {

              inherit cargoArtifacts;

              doCheck = false;

              postInstall = ''

                install -Dm644 res/monolith-portals.conf -t $out/share/xdg-desktop-portal

                install -Dm644 res/monolith.desktop -t $out/share/wayland-sessions

              '';

              # ash opens libvulkan at runtime, so it is not in the linked rpath.

              postFixup = ''

                patchelf --add-rpath ${lib.makeLibraryPath [ pkgs.vulkan-loader ]} $out/bin/monolith

              '';

              passthru.providedSessions = [ "monolith" ];

              meta = {

                description = "A tiling Wayland compositor";

                license = lib.licenses.eupl12;

                platforms = lib.platforms.linux;

                mainProgram = "monolith";

              };

            }

          );

          checks = {

            clippy = craneLib.cargoClippy (

              commonArgs

              // {

                inherit cargoArtifacts;

                cargoClippyExtraArgs = "--all-targets -- --deny warnings";

              }

            );

            fmt = craneLib.cargoFmt {

              inherit src;

              pname = "monolith";

              version = "0.0.0";

            };

            test = craneLib.cargoTest (

              commonArgs

              // {

                inherit cargoArtifacts;

                VK_DRIVER_FILES = lavapipeIcd;

                LD_LIBRARY_PATH = lib.makeLibraryPath [ pkgs.vulkan-loader ];

              }

            );

          };

        };

      nixosModule =

        {

          config,

          lib,

          pkgs,

          ...

        }:

        let

          inherit (lib)

            getExe

            literalExpression

            mkDefault

            mkEnableOption

            mkIf

            mkOption

            optional

            types

            ;

          cfg = config.programs.monolith;

        in

        {

          options.programs.monolith = {

            enable = mkEnableOption "monolith, a tiling Wayland compositor";

            package = mkOption {

              type = types.package;

              default = (mkProject pkgs).package;

              defaultText = literalExpression "monolith.packages.\${system}.default";

              description = "The monolith package to use.";

            };

            realtime-scheduling = mkOption {

              type = types.bool;

              default = true;

              description = ''

                Wrap the monolith binary with CAP_SYS_NICE so its compositor thread runs

                SCHED_RR and its Vulkan queue gets realtime global priority. monolith clears

                the capability from everything it launches.

              '';

            };

            xwayland.enable = mkEnableOption "Xwayland, started on the first X11 client" // {

              default = true;

            };

          };

          config = mkIf cfg.enable {

            environment.systemPackages = optional (!cfg.realtime-scheduling) cfg.package;

            programs = {

              dconf.enable = mkDefault true;

              xwayland.enable = mkIf cfg.xwayland.enable (mkDefault true);

            };

            security = {

              polkit.enable = true;

              pam.services.swaylock = { };

              wrappers = mkIf cfg.realtime-scheduling {

                monolith = {

                  owner = "root";

                  group = "root";

                  permissions = "a+rx";

                  source = getExe cfg.package;

                  capabilities = "cap_sys_nice+p";

                };

              };

            };

            xdg.portal = {

              enable = mkDefault true;

              configPackages = mkDefault [ cfg.package ];

              extraPortals = [

                pkgs.xdg-desktop-portal-gtk

                pkgs.xdg-desktop-portal-wlr

              ];

            };

            services.displayManager.sessionPackages = [ cfg.package ];

          };

        };

    in

    {

      packages = forAllSystems (pkgs: {

        default = (mkProject pkgs).package;

      });

      overlays.default = final: _: { monolith = (mkProject final).package; };

      nixosModules.default = nixosModule;

      checks = forAllSystems (pkgs: (mkProject pkgs).checks);

      devShells = forAllSystems (

        pkgs:

        let

          project = mkProject pkgs;

        in

        {

          default = project.craneLib.devShell {

            inputsFrom = [ project.package ];

            packages = with pkgs; [

              rust-analyzer

              vulkan-tools

              vulkan-validation-layers

              tracy

            ];

            LD_LIBRARY_PATH = lib.makeLibraryPath [ pkgs.vulkan-loader ];

            LAVAPIPE_ICD = project.lavapipeIcd;

          };

        }

      );

      formatter = forAllSystems (pkgs: pkgs.nixfmt);

    };

}