{
  description = "Alternate, a pager for your pagers";

  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
    flake-utils.url = "github:numtide/flake-utils";
    flake-parts.url = "github:hercules-ci/flake-parts";
    rust-overlay = {
      url = "github:oxalica/rust-overlay";
      inputs.nixpkgs.follows = "nixpkgs";
      inputs.flake-utils.follows = "flake-utils";
    };
    crane = {
      url = "github:ipetkov/crane";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };

  outputs = {
    self,
    flake-parts,
    ...
  } @ inputs:
    flake-parts.lib.mkFlake {inherit inputs;} {
      systems = [
        # "aarch64-linux"
        # "aarch64-darwin"
        # "x86_64-darwin"
        "x86_64-linux"
      ];
      perSystem = {system, ...}: let
        overlays = [(import inputs.rust-overlay)];
        pkgs = import inputs.nixpkgs {inherit system overlays;};
        stdenv =
          if pkgs.stdenv.isLinux
          then pkgs.stdenvAdapters.useMoldLinker pkgs.stdenv
          else pkgs.stdenv;

        root = self;

        ignoreSource = [".git" "target" "example"];

        src = pkgs.nix-gitignore.gitignoreSource ignoreSource root;

        cargoToml = builtins.fromTOML (builtins.readFile (src + "/Cargo.toml"));
        inherit (cargoToml.package) version name;
        rustToolchainToml = pkgs.rust-bin.fromRustupToolchainFile (src + "/rust-toolchain.toml");
        gitDate = self.lastModifiedDate;
        gitRev = self.shortRev or "Not committed yet.";

        postInstall = ''
          # generate and install the manpage
          export OUT_DIR=./.
          $out/bin/${name} setup --generate-manpage
          installManPage ./${name}.1

          # explicit behavior
          $out/bin/${name} setup --generate-completion bash > ./completions.bash
          installShellCompletion --bash --name ${name}.bash ./completions.bash
          $out/bin/${name} setup --generate-completion fish > ./completions.fish
          installShellCompletion --fish --name ${name}.fish ./completions.fish
          $out/bin/${name} setup --generate-completion zsh > ./completions.zsh
          installShellCompletion --zsh --name _${name} ./completions.zsh
        '';

        cargoLock = {
          lockFile = builtins.path {
            path = src + "/Cargo.lock";
            name = "Cargo.lock";
          };
        };
        cargo = rustToolchainToml;
        rustc = rustToolchainToml;

        buildInputs = [
        ];
        nativeBuildInputs = [
          pkgs.installShellFiles
          pkgs.llvmPackages.bintools
        ];
        devInputs = [
          rustToolchainToml

          pkgs.rust-analyzer

          pkgs.just

          pkgs.lychee

          pkgs.cargo-flamegraph
          pkgs.cargo-watch
          pkgs.cargo-diet
          pkgs.cargo-nextest
          pkgs.cargo-tarpaulin

          (pkgs.symlinkJoin {
            name = "cargo-udeps-wrapped";
            paths = [pkgs.cargo-udeps];
            nativeBuildInputs = [pkgs.makeWrapper];
            postBuild = ''
              wrapProgram $out/bin/cargo-udeps \
                --prefix PATH : ${pkgs.lib.makeBinPath [
                (pkgs.rust-bin.selectLatestNightlyWith
                  (toolchain: toolchain.default))
              ]}
            '';
          })
        ];
        nightlyShellInputs = [
          (pkgs.rust-bin.selectLatestNightlyWith
            (toolchain: toolchain.default))
          pkgs.cargo-udeps
        ];
        fmtInputs = [
          pkgs.alejandra
          pkgs.treefmt
        ];
        ciInputs = [
          pkgs.typos
          pkgs.reuse
          pkgs.cargo-deny
        ];
        editorConfigInputs = [
          pkgs.editorconfig-checker
        ];
        # Compatibility testing for alternate
        testInputs = [
          pkgs.diff-so-fancy
          pkgs.delta
          pkgs.difftastic
        ];

        meta = with pkgs.lib; {
          homepage = "https://github.com/a-kenji/alternate/";
          description = "A pager for your pagers";
          license = [licenses.mit];
        };
      in {
        packages.default = (pkgs.makeRustPlatform {inherit cargo rustc;}).buildRustPackage {
          inherit
            buildInputs
            nativeBuildInputs
            cargoLock
            meta
            name
            src
            stdenv
            version
            ;
          GIT_REV = gitRev;
          GIT_DATE = gitDate;
        };
        # apps.default = flake-utils.lib.mkApp {drv = packages.default;};
        devShells = {
          default = (pkgs.mkShell.override {inherit stdenv;}) {
            inherit name buildInputs;
            ### Environment Variables
            RUST_BACKTRACE = 1;
            ALTER_LOG = "debug";
            nativeBuildInputs =
              nativeBuildInputs
              ++ devInputs
              ++ fmtInputs
              ++ ciInputs
              ++ testInputs
              ++ editorConfigInputs;
            GIT_REV = gitRev;
            GIT_DATE = gitDate;
          };
          fmtShell = pkgs.mkShell {
            name = "fmt-shell";
            nativeBuildInputs = fmtInputs;
          };
          nightlyShell =
            pkgs.mkShell
            {
              name = "nightly-shell";
              nativeBuildInputs = nightlyShellInputs;
            };
          ciShell = pkgs.mkShell {
            name = "ci";
            nativeBuildInputs = ciInputs;
          };
          editorConfigShell = pkgs.mkShell {
            name = "editor-config";
            nativeBuildInputs = editorConfigInputs;
          };
        };
        formatter = pkgs.alejandra;
      };
    };
}