{
  description = "Using Markdown Files to organize your life as a @Tag-Stream";

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

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

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

    git-hooks = {
      url = "github:cachix/git-hooks.nix";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };

  outputs =
    {
      self,
      nixpkgs,
      rust-overlay,
      crane,
      git-hooks,
      ...
    }:
    let
      inherit (nixpkgs) lib;
      forAllSystems = lib.genAttrs lib.systems.flakeExposed;

      # Read version from Cargo.toml as single source of truth
      version = (builtins.fromTOML (builtins.readFile ./Cargo.toml)).package.version;

      mkPkgs =
        system:
        import nixpkgs {
          inherit system;
          overlays = [ rust-overlay.overlays.default ];
        };

      mkCraneLib =
        system:
        let
          pkgs = mkPkgs system;
          toolchain = pkgs.rust-bin.stable.latest.default.override {
            extensions = [
              "rust-src"
              "rust-analyzer"
            ];
          };
        in
        (crane.mkLib pkgs).overrideToolchain toolchain;

      mkStreamd =
        system:
        let
          craneLib = mkCraneLib system;

          commonArgs = {
            src = craneLib.path ./.;
            pname = "streamd";
            inherit version;
            strictDeps = true;
          };

          cargoArtifacts = craneLib.buildDepsOnly commonArgs;
        in
        craneLib.buildPackage (
          commonArgs
          // {
            inherit cargoArtifacts;

            passthru = {
              inherit cargoArtifacts;
              tests = {
                clippy = craneLib.cargoClippy (
                  commonArgs
                  // {
                    inherit cargoArtifacts;
                    cargoClippyExtraArgs = "--all-targets -- -D warnings";
                  }
                );
                fmt = craneLib.cargoFmt { src = commonArgs.src; };
                test = craneLib.cargoTest (commonArgs // { inherit cargoArtifacts; });
              };
            };
          }
        );

      mkGitHooksCheck =
        system:
        let
          pkgs = mkPkgs system;
          toolchain = pkgs.rust-bin.stable.latest.default;
        in
        git-hooks.lib.${system}.run {
          src = ./.;
          hooks = {
            rustfmt = {
              enable = true;
              package = toolchain;
            };
            commitizen.enable = true;
          };
        };

      mkMuslCraneLib =
        system:
        let
          pkgs = mkPkgs system;
          toolchain = pkgs.rust-bin.stable.latest.default.override {
            targets = [ "x86_64-unknown-linux-musl" ];
          };
        in
        (crane.mkLib pkgs).overrideToolchain toolchain;

      mkStreamdMusl =
        system:
        let
          craneLib = mkMuslCraneLib system;
          commonArgs = {
            src = craneLib.path ./.;
            pname = "streamd";
            inherit version;
            strictDeps = true;
            CARGO_BUILD_TARGET = "x86_64-unknown-linux-musl";
            CARGO_BUILD_RUSTFLAGS = "-C target-feature=+crt-static";
          };
          cargoArtifacts = craneLib.buildDepsOnly commonArgs;
        in
        craneLib.buildPackage (commonArgs // { inherit cargoArtifacts; });

      mkWindowsCraneLib =
        system:
        let
          pkgs = mkPkgs system;
          toolchain = pkgs.rust-bin.stable.latest.default.override {
            targets = [ "x86_64-pc-windows-gnu" ];
          };
        in
        (crane.mkLib pkgs).overrideToolchain toolchain;

      mkStreamdWindows =
        system:
        let
          pkgs = mkPkgs system;
          pkgsCross = pkgs.pkgsCross.mingwW64;
          craneLib = mkWindowsCraneLib system;
          commonArgs = {
            src = craneLib.path ./.;
            pname = "streamd";
            inherit version;
            strictDeps = true;
            CARGO_BUILD_TARGET = "x86_64-pc-windows-gnu";
            CC_x86_64_pc_windows_gnu = "${pkgsCross.stdenv.cc}/bin/x86_64-w64-mingw32-gcc";
            CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER = "${pkgsCross.stdenv.cc}/bin/x86_64-w64-mingw32-gcc";
            nativeBuildInputs = [ pkgsCross.stdenv.cc ];
            buildInputs = [ pkgsCross.windows.pthreads ];
            doCheck = false;
          };
          cargoArtifacts = craneLib.buildDepsOnly commonArgs;
        in
        craneLib.buildPackage (commonArgs // { inherit cargoArtifacts; });

      mkStreamdDeb =
        system:
        let
          pkgs = mkPkgs system;
          streamd-musl = mkStreamdMusl system;
        in
        pkgs.runCommand "streamd_${version}_amd64.deb" {
          nativeBuildInputs = [ pkgs.nfpm ];
        } ''
          # Generate shell completions
          mkdir -p completions
          ${streamd-musl}/bin/streamd completions bash > completions/streamd.bash
          ${streamd-musl}/bin/streamd completions zsh > completions/_streamd
          ${streamd-musl}/bin/streamd completions fish > completions/streamd.fish

          cat > nfpm.yaml <<EOF
          name: streamd
          arch: amd64
          platform: linux
          version: "${version}"
          maintainer: Konstantin Fickel
          description: Personal knowledge management and time-tracking CLI using @Tag annotations
          license: AGPL-3.0-only
          homepage: https://git.konstantinfickel.de/kfickel/streamd
          contents:
            - src: ${streamd-musl}/bin/streamd
              dst: /usr/bin/streamd
              file_info:
                mode: 0755
            - src: completions/streamd.bash
              dst: /usr/share/bash-completion/completions/streamd
            - src: completions/_streamd
              dst: /usr/share/zsh/vendor-completions/_streamd
            - src: completions/streamd.fish
              dst: /usr/share/fish/vendor_completions.d/streamd.fish
          deb:
            compression: gzip
          EOF

          nfpm package --config nfpm.yaml --packager deb --target $out
        '';
    in
    {
      packages = forAllSystems (
        system:
        let
          streamd = mkStreamd system;
          streamd-musl = mkStreamdMusl system;
          streamd-deb = mkStreamdDeb system;
          streamd-windows = mkStreamdWindows system;
        in
        {
          inherit streamd streamd-musl streamd-deb streamd-windows;
          default = streamd;
        }
      );

      homeManagerModules.default =
        {
          lib,
          config,
          pkgs,
          ...
        }:
        let
          cfg = config.programs.streamd;
        in
        {
          options.programs.streamd = {
            enable = lib.mkEnableOption "streamd";

            base-folder = lib.mkOption {
              type = lib.types.str;
              description = "Base Folder of streamd";
            };

            package = lib.mkOption {
              type = lib.types.package;
              default = self.packages.${pkgs.stdenv.hostPlatform.system}.streamd;
              defaultText = lib.literalExpression "inputs.streamd.packages.\${pkgs.stdenv.hostPlatform.system}.streamd";
              description = "The package to use for the streamd binary.";
            };
          };

          config = lib.mkIf cfg.enable {
            assertions = [
              (lib.hm.assertions.assertPlatform "programs.streamd" pkgs lib.platforms.linux)
            ];

            home.packages = [ cfg.package ];

            xdg.configFile."streamd/config.toml".source =
              (pkgs.formats.toml { }).generate "streamd-configuration"
                {
                  base_folder = cfg.base-folder;
                };

            home.shellAliases.s = "streamd";

            programs.bash.initExtra = ''
              eval "$(${cfg.package}/bin/streamd completions bash)"
            '';

            programs.zsh.initExtra = ''
              eval "$(${cfg.package}/bin/streamd completions zsh)"
            '';
          };
        };

      checks = forAllSystems (
        system:
        let
          streamd = mkStreamd system;
        in
        {
          inherit (streamd.passthru.tests) clippy fmt test;
          pre-commit = mkGitHooksCheck system;
        }
      );

      devShells = forAllSystems (
        system:
        let
          pkgs = mkPkgs system;
          toolchain = pkgs.rust-bin.stable.latest.default.override {
            extensions = [
              "rust-src"
              "rust-analyzer"
            ];
          };
        in
        {
          default = pkgs.mkShell {
            packages = [
              toolchain
              pkgs.commitizen
            ];

            shellHook = ''
              ${(mkGitHooksCheck system).shellHook}
            '';
          };
        }
      );
    };
}