{
    description = "Project Tool";

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

    outputs = { nixpkgs, rust-overlay, ... }:
    let
        lib = nixpkgs.lib;
        systems = ["x86_64-linux"];

        forEachSystem = fn: lib.genAttrs systems (system:
        let
            overlays = [ (import rust-overlay) ];
            pkgs = import nixpkgs { inherit system overlays; };
        in fn { inherit pkgs; } );

        cargoManifest = lib.importTOML ./Cargo.toml;
        packageName = cargoManifest.package.name;

        mkRustToolchain = pkgs: pkgs.rust-bin.fromRustupToolchainFile ./rust-toolchain.toml;

        mkRustPackage = pkgs:
        let
            rustToolchain = mkRustToolchain pkgs;
            rustPlatform = pkgs.makeRustPlatform {
                cargo = rustToolchain;
                rustc = rustToolchain;
            };

            packageVersion = cargoManifest.package.version;
        in rustPlatform.buildRustPackage {
                nativeBuildInputs = [ rustToolchain ];

                pname = packageName;
                version = packageVersion;
                src = lib.cleanSource ./.;

                verbose = true;

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

                meta = {
                    mainProgram = packageName;
                };
            };
    in {
        packages = forEachSystem ({ pkgs }:
        let
            package = mkRustPackage pkgs;
        in {
            default = package;
            ${packageName} = package;
        });

        homeManagerModules.default = { config, pkgs, ... }:
        let
            inherit (lib) mkIf mkOption mkEnableOption types;
            selfConfig = config.programs.${packageName};
            package = mkRustPackage pkgs;
        in {
            options = {
                programs.${packageName} = {
                    enable = mkEnableOption packageName;
                    package = mkOption {
                        type = types.package;
                        default = package;
                    };

                    enableNushellIntegration = mkOption {
                        default = config.programs.nushell.enable;
                        type = types.bool;
                        description = "Whether to enable Nushell integration";
                    };
                };
            };

            config = mkIf selfConfig.enable {
                home.packages = [ selfConfig.package ];
                programs.nushell = let
                    cacheHome = "${config.xdg.cacheHome}/valeth/${packageName}";
                    initFile = "${cacheHome}/init.nu";
                in mkIf selfConfig.enableNushellIntegration {
                    extraEnv = ''
                        if not ("${cacheHome}" | path exists) {
                            mkdir "${cacheHome}"
                        }
                        ${selfConfig.package}/bin/${packageName} init nu | save --force ${initFile}
                    '';
                    extraConfig = "source ${initFile}";
                };
            };
        };

        devShells = forEachSystem ({ pkgs }: let
            rustToolchain = mkRustToolchain pkgs;
            rustNightlyToolchain = pkgs.rust-bin.selectLatestNightlyWith (t: t.minimal.override {
                extensions = [ "rustfmt" ];
            });
        in {
            default = pkgs.mkShell {
                name = "projtool";

                nativeBuildInputs = [
                    rustToolchain
                    rustNightlyToolchain
                ];
            };
        });
    };
}