{
  description = "WezTerm with vertical (side) tab bar support — fork of wezterm/wezterm (#3537 / PR #7574)";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
    flake-utils.url = "github:numtide/flake-utils";
    rust-overlay = {
      url = "github:oxalica/rust-overlay";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    # Submodules aren't available via flake inputs for path/github refs reliably,
    # so pin them here and link into the tree at build time (same approach as upstream nix/).
    freetype2 = {
      url = "github:freetype/freetype/VER-2-13-3";
      flake = false;
    };
    harfbuzz = {
      url = "github:harfbuzz/harfbuzz/11.2.1";
      flake = false;
    };
    libpng = {
      url = "github:pnggroup/libpng/v1.6.44";
      flake = false;
    };
    zlib = {
      url = "github:madler/zlib/v1.3.1";
      flake = false;
    };
  };

  outputs =
    inputs@{ self, ... }:
    let
      perSystemOutputs = inputs.flake-utils.lib.eachDefaultSystem (
        system:
        let
          overlays = [ (import inputs.rust-overlay) ];
          pkgs = import inputs.nixpkgs { inherit system overlays; };

          inherit (inputs.nixpkgs) lib;
          inherit (pkgs) stdenv;

          nativeBuildInputs =
            with pkgs;
            [
              installShellFiles
              ncurses # tic for terminfo
              pkg-config
              python3
            ]
            ++ lib.optional stdenv.isDarwin perl;

          buildInputs =
            with pkgs;
            [
              fontconfig
              openssl
              zlib
            ]
            ++ lib.optionals stdenv.isLinux [
              libxkbcommon
              wayland

              libx11
              libxcb
              libxcb-util
              libxcb-image
              libxcb-keysyms
              libxcb-wm # contains xcb-ewmh among others
            ]
            ++ lib.optionals stdenv.isDarwin ([
              libiconv
            ]);

          libPath = lib.makeLibraryPath (
            with pkgs;
            [
              libxcb-image
              libGL
              vulkan-loader
            ]
          );

          rustPlatform = pkgs.makeRustPlatform {
            cargo = pkgs.rust-bin.stable.latest.minimal;
            rustc = pkgs.rust-bin.stable.latest.minimal;
          };
        in
        {
          packages.default = rustPlatform.buildRustPackage (finalAttrs: {
            inherit buildInputs nativeBuildInputs;

            pname = "wezterm";
            src = ./.;

            # Version: `<date>-<time>-<shorthash>` (+ `-dirty` if uncommitted)
            version = (
              builtins.concatStringsSep "-" (
                builtins.match "(.{8})(.{6})" self.lastModifiedDate
                ++ [ (builtins.substring 0 8 self.rev or self.dirtyRev) ]
                ++ lib.lists.optional (self ? dirtyRev) "dirty"
              )
            );

            cargoLock = {
              lockFile = ./Cargo.lock;
              allowBuiltinFetchGit = true;
            };

            prePatch = ''
              rm -rf deps/freetype/{freetype2,libpng,zlib} deps/harfbuzz/harfbuzz

              ln -s ${inputs.freetype2} deps/freetype/freetype2
              ln -s ${inputs.libpng} deps/freetype/libpng
              ln -s ${inputs.zlib} deps/freetype/zlib
              ln -s ${inputs.harfbuzz} deps/harfbuzz/harfbuzz
            '';

            postPatch = ''
              echo ${finalAttrs.version} > .tag

              # tests are failing with: Unable to exchange encryption keys
              rm -r wezterm-ssh/tests

              # hash does not work well with NixOS
              substituteInPlace assets/shell-integration/wezterm.sh \
                --replace-fail 'hash wezterm 2>/dev/null' 'command type -P wezterm &>/dev/null' \
                --replace-fail 'hash base64 2>/dev/null' 'command type -P base64 &>/dev/null' \
                --replace-fail 'hash hostname 2>/dev/null' 'command type -P hostname &>/dev/null' \
                --replace-fail 'hash hostnamectl 2>/dev/null' 'command type -P hostnamectl &>/dev/null'
            '';

            # Disable cargo-auditable until https://github.com/rust-secure-code/cargo-auditable/issues/124 is fixed
            auditable = false;

            preFixup =
              lib.optionalString stdenv.isLinux /* bash */ ''
                patchelf \
                  --add-needed "${pkgs.libGL}/lib/libEGL.so.1" \
                  --add-needed "${pkgs.vulkan-loader}/lib/libvulkan.so.1" \
                  $out/bin/wezterm-gui
              ''
              + lib.optionalString stdenv.isDarwin /* bash */ ''
                mkdir -p "$out/Applications"
                OUT_APP="$out/Applications/WezTerm.app"
                cp -r assets/macos/WezTerm.app "$OUT_APP"
                rm $OUT_APP/*.dylib
                cp -r assets/shell-integration/* "$OUT_APP/Contents/Resources"
                mkdir -p "$OUT_APP/Contents/MacOS"
                mv $out/bin/{wezterm,wezterm-mux-server,wezterm-gui,strip-ansi-escapes} "$OUT_APP/Contents/MacOS"
                ln -s "$OUT_APP/Contents/MacOS"/{wezterm,wezterm-mux-server,wezterm-gui,strip-ansi-escapes} "$out/bin"
              '';

            preBuild = ''
              echo "Building Wezterm ${finalAttrs.version}..."
            '';

            postInstall = ''
              mkdir -p $out/nix-support
              echo "${finalAttrs.passthru.terminfo}" >> $out/nix-support/propagated-user-env-packages

              install -Dm644 assets/icon/terminal.png $out/share/icons/hicolor/128x128/apps/org.wezfurlong.wezterm.png
              install -Dm644 assets/wezterm.desktop $out/share/applications/org.wezfurlong.wezterm.desktop
              install -Dm644 assets/wezterm.appdata.xml $out/share/metainfo/org.wezfurlong.wezterm.appdata.xml

              install -Dm644 assets/shell-integration/wezterm.sh -t $out/etc/profile.d
              installShellCompletion --cmd wezterm \
                --bash assets/shell-completion/bash \
                --fish assets/shell-completion/fish \
                --zsh assets/shell-completion/zsh

              install -Dm644 assets/wezterm-nautilus.py -t $out/share/nautilus-python/extensions
            '';

            passthru = {
              headless = rustPlatform.buildRustPackage {
                pname = "wezterm-headless";
                inherit (finalAttrs)
                  version
                  src
                  postPatch
                  cargoDeps
                  meta
                  ;

                nativeBuildInputs = [ pkgs.pkg-config ];

                buildInputs = [ pkgs.openssl ];

                cargoBuildFlags = [
                  "--package"
                  "wezterm"
                  "--package"
                  "wezterm-mux-server"
                ];

                doCheck = false;

                postInstall = ''
                  install -Dm644 assets/shell-integration/wezterm.sh -t $out/etc/profile.d
                  install -Dm644 ${finalAttrs.passthru.terminfo}/share/terminfo/w/wezterm -t $out/share/terminfo/w
                '';
              };

              terminfo =
                pkgs.runCommand "wezterm-terminfo-${finalAttrs.version}"
                  {
                    nativeBuildInputs = [ pkgs.ncurses ];
                  }
                  ''
                    mkdir -p $out/share/terminfo $out/nix-support
                    tic -x -o $out/share/terminfo ${finalAttrs.src}/termwiz/data/wezterm.terminfo
                  '';
            };

            meta = {
              description = "GPU-accelerated terminal emulator with vertical tab bar support";
              homepage = "https://tangled.org/nandi.uk/wezterm";
              mainProgram = "wezterm";
            };
          });

          packages.wezterm = self.packages.${system}.default;

          devShells.default = pkgs.mkShell {
            name = "wezterm-shell";
            inherit nativeBuildInputs;

            buildInputs =
              buildInputs
              ++ (with pkgs.rust-bin; [
                (stable.latest.minimal.override {
                  extensions = [
                    "clippy"
                    "rust-src"
                  ];
                })

                nightly.latest.rustfmt
                nightly.latest.rust-analyzer
              ]);

            LD_LIBRARY_PATH = libPath;
          };

          formatter = pkgs.nixfmt-tree;
        }
      );

      testingSystem = "x86_64-linux";
      globalOutputs = {
        # Upstream VM harness (unchanged paths under nix/vm)
        nixosConfigurations.testing-on-gnome = import ./nix/vm {
          inherit (inputs) nixpkgs;
          system = testingSystem;
          desktopModule = ./nix/vm/desktop-gnome.nix;
        };
        nixosConfigurations.testing-on-plasma = import ./nix/vm {
          inherit (inputs) nixpkgs;
          system = testingSystem;
          desktopModule = ./nix/vm/desktop-plasma.nix;
        };
      };
    in
    perSystemOutputs // globalOutputs;
}