{
  username,
  hostname,
  config,
  lib,
  mylib,
  pkgs,
  ...
}: let
  inherit (config.modules) neovim color;
in {
  options.modules.neovim = import ./options.nix {inherit lib mylib;};

  config = lib.mkIf neovim.enable {
    home = {
      file.".config/neovide/config.toml".source = ./neovide_config.ini;
      file.".config/vale/.vale.ini".source = ./vale_config.ini;

      sessionVariables = {
        EDITOR = "nvim";
        VISUAL = "nvim";
      };

      packages = with pkgs;
        builtins.concatLists [
          (lib.optionals neovim.neovide [neovide])

          [
            (pkgs.ripgrep.override {withPCRE2 = true;})

            # Dependencies
            lua51Packages.lua-curl # For rest
            lua51Packages.xml2lua # For rest
            lua51Packages.mimetypes # For rest
            lua51Packages.jsregexp # For tree-sitter
            nodejs

            # Language servers
            clang-tools_18
            clojure-lsp
            cmake-language-server
            haskell-language-server
            ltex-ls
            lua-language-server
            nil
            nixd
            pyright
            rust-analyzer
            texlab
            typescript

            # Linters
            checkstyle # java
            clippy # rust
            clj-kondo # clojure
            eslint_d # javascript
            python311Packages.flake8
            lua51Packages.luacheck
            vale # text
            statix # nix

            # Formatters
            alejandra # nix
            python311Packages.black
            google-java-format
            html-tidy
            jq # json
            prettierd # html/css/js
            rustfmt
            stylua
          ]
        ];
    };

    programs.nixvim = {
      enable = true;
      defaultEditor = true;
      enableMan = false; # Nixvim man pages
      luaLoader.enable = true; # NOTE: Experimental
      viAlias = neovim.alias;
      vimAlias = neovim.alias;

      # Configured using plugin
      # colorschemes.catppuccin = {
      #   enable = true;
      #   settings = {
      #     flavour = "mocha"; # latte, frappe, macchiato, mocha
      #     background = {
      #       light = "latte";
      #       dark = "mocha";
      #     };
      #   };
      # };

      performance.byteCompileLua = {
        enable = true;
        configs = true;
        initLua = true; # When debugging init.lua turn this off
        nvimRuntime = true;
        plugins = true;
      };

      globals = {
        mapleader = " ";
        maplocalleader = ",";
      };

      opts = import ./vim_opts.nix {inherit lib mylib;};
      extraConfigLuaPost = builtins.readFile ./extraConfigLuaPost.lua;
      extraConfigLua = builtins.readFile ./extraConfigLua.lua;

      # Those files will be added to the nvim runtimpath
      extraFiles = {
        # For this its probably important to set the default filetype to tex (see extraConfigLua)
        "ftplugin/tex/mappings.lua".text = mylib.generators.toLuaKeymap (import ./mappings_latex.nix {});
        "ftplugin/markdown/mappings.lua".text = mylib.generators.toLuaKeymap (import ./mappings_markdown.nix {});

        # Luasnip searches the luasnippets folder in the runtimepath
        "luasnippets/tex.lua".text = builtins.readFile ./snippets_latex.lua;
      };

      # extraLuaPackages = with pkgs.lua51Packages; [];
      # extraPython3Packages = p: [];

      autoCmd = [
        {
          desc = "Lint the file if autolint is enabled";
          event = ["BufWritePost"];
          callback.__raw = ''
            function()
              if not vim.g.disable_autolint then
                require("lint").try_lint()
              end
            end
          '';
        }

        {
          desc = "Highlight yanked regions";
          event = ["TextYankPost"];
          callback.__raw = "function() vim.highlight.on_yank() end";
        }

        {
          desc = "Resize splits when Neovim is resized by the WM";
          event = ["VimResized"];
          callback.__raw = ''
            function()
              local current_tab = vim.fn.tabpagenr()
              vim.cmd("tabdo wincmd =")
              vim.cmd("tabnext " .. current_tab)
            end
          '';
        }

        {
          desc = "Disable conceal in JSON files";
          event = ["FileType"];
          pattern = ["json" "jsonc" "json5"]; # Disable conceal for these filetypes
          callback.__raw = "function() vim.opt_local.conceallevel = 0 end";
        }

        {
          desc = "Attach JDTLS to Java files";
          event = ["FileType"];
          pattern = ["Java" "java"];
          callback.__raw = ''
            function()
              local workspace = vim.fs.dirname(vim.fs.find({'gradlew', '.git', 'mvnw'}, { upward = true })[1])

              local opts = {
                root_dir = workspace,
                cmd = {
                  "jdtls",
                  "-data",
                  "/home/christoph/.local/share/eclipse/" .. vim.fn.fnamemodify(workspace, ":p:h:t"),
                },
              }

              require('jdtls').start_or_attach(opts)
            end
          '';
        }

        {
          # TODO: This breaks if the preview buffer does not refer to a file,
          #       e.g. when showing previous notifications
          desc = "Enable line wrapping in telescope preview";
          event = ["User"];
          pattern = ["TelescopePreviewerLoaded"];
          callback.__raw = ''
            function(args)
              if args.data.bufname:match("*.csv") then
                vim.wo.wrap = false
              else
                vim.wo.wrap = true
              end
            end
          '';
        }
      ];

      keymaps = import ./mappings.nix {inherit lib mylib;};

      plugins.lazy = let
        mkDefaultConfig = name: ''
          function(_, opts)
            require("${name}").setup(opts)
          end
        '';
      in {
        enable = true;

        plugins = let
          autopairs = rec {
            name = "nvim-autopairs";
            pkg = pkgs.vimPlugins.nvim-autopairs;
            lazy = true;
            event = ["InsertEnter"];
            config = mkDefaultConfig name;
            opts = {
              check_ts = true;
            };
          };

          bbye = {
            name = "vim-bbye";
            pkg = pkgs.vimPlugins.vim-bbye;
            lazy = true;
            cmd = ["Bdelete" "Bwipeout"];
          };

          better-escape = rec {
            name = "better_escape";
            pkg = pkgs.vimPlugins.better-escape-nvim;
            lazy = true;
            event = ["InsertEnter"];
            config = mkDefaultConfig name;
            opts = {
              # mapping = ["jk"]; # NOTE: Deprecated
              default_mappings = true;
              timeout = 200; # In ms
            };
          };

          catppuccin = {
            name = "catppuccin";
            pkg = pkgs.vimPlugins.catppuccin-nvim;
            lazy = false;
            priority = 1000;
            config = ''
              function(_, opts)
                require("catppuccin").setup(opts)

                vim.cmd([[
                  let $BAT_THEME = "catppuccin"
                  colorscheme catppuccin
                ]])
              end
            '';
            opts = {
              flavour = "mocha"; # latte, frappe, macchiato, mocha
              background = {
                light = "latte";
                dark = "mocha";
              };
              default_integrations = false;
              integrations = {
                cmp = true;
                dashboard = true;
                diffview = true;
                flash = true;
                gitsigns = true;
                mini.enabled = true;
                neotree = true;
                noice = true;
                native_lsp = {
                  enabled = true;
                  virtual_text = {
                    errors = ["italic"];
                    hints = ["italic"];
                    warnings = ["italic"];
                    information = ["italic"];
                    ok = ["italic"];
                  };
                  underlines = {
                    errors = ["underline"];
                    hints = ["underline"];
                    warnings = ["underline"];
                    information = ["underline"];
                    ok = ["underline"];
                  };
                  inlay_hints = {
                    background = true;
                  };
                };
                navic = {
                  enabled = true;
                  # custom_bg = "crust";
                };
                notify = true;
                treesitter = true;
                ufo = true;
                rainbow_delimiters = true;
                telescope.enabled = true;
                lsp_trouble = true;
                illuminate = {
                  enabled = true;
                  lsp = true;
                };
                which_key = true;
              };
            };
          };

          cellular-automaton = {
            name = "cellular-automaton";
            pkg = pkgs.vimPlugins.cellular-automaton-nvim;
            lazy = true;
            cmd = ["CellularAutomaton"];
          };

          # NOTE: In LazyVim require("clang_extensions").setup(opts) is called where opts is the server definition from lspconfig...
          clangd-extensions = rec {
            name = "clangd_extensions";
            pkg = pkgs.vimPlugins.clangd_extensions-nvim;
            lazy = true;
            config = mkDefaultConfig name;
            opts = {
              inlay_hints = {
                inline = false;
              };
            };
          };

          _cmp-async-path = {
            name = "cmp-async-path";
            pkg = pkgs.vimPlugins.cmp-async-path;
            lazy = true;
          };

          _cmp-buffer = {
            name = "cmp-buffer";
            pkg = pkgs.vimPlugins.cmp-buffer;
            lazy = true;
            enabled = false; # Spams the completion window
          };

          _cmp-cmdline = {
            name = "cmp-cmdline";
            pkg = pkgs.vimPlugins.cmp-cmdline;
            lazy = true;
            enabled = false; # Using nui as : completion backend, not cmp
          };

          _cmp-emoji = {
            name = "cmp-emoji";
            pkg = pkgs.vimPlugins.cmp-emoji;
            lazy = true;
          };

          _cmp-nvim-lsp = {
            name = "cmp-nvim-lsp";
            pkg = pkgs.vimPlugins.cmp-nvim-lsp;
            lazy = true;
          };

          # _cmp-nvim-lsp-signature-help = {
          #   name = "cmp-nvim-lsp-signature-help";
          #   pkg = pkgs.vimPlugins.cmp-nvim-lsp-signature-help;
          #   lazy = true;
          # };

          _cmp-luasnip = {
            name = "cmp_luasnip";
            pkg = pkgs.vimPlugins.cmp_luasnip;
            lazy = true;
          };

          _lspkind = {
            name = "lspkind";
            pkg = pkgs.vimPlugins.lspkind-nvim;
            lazy = true;
          };

          cmp = rec {
            name = "cmp";
            pkg = pkgs.vimPlugins.nvim-cmp;
            lazy = true;
            event = ["InsertEnter"];
            dependencies = [
              _cmp-async-path
              _cmp-buffer
              _cmp-cmdline
              _cmp-emoji
              _cmp-nvim-lsp
              # _cmp-nvim-lsp-signature-help
              _cmp-luasnip
              _lspkind # Type symbols in completion
            ];
            config = mkDefaultConfig name;
            opts.__raw = let
              sources = mylib.generators.toLuaObject [
                {name = "async_path";}
                {name = "emoji";}
                {name = "nvim_lsp";}
                {name = "luasnip";}

                # {name = "nvim_lsp_signature_help";} # Already provided by something else (noice?)
                # {name = "buffer";} # Too much noise
                # {name = "cmdline";} # Using nui as cmdline completion backend
              ];

              mapping = mylib.generators.toLuaObject {
                "<Down>".__raw = "cmp.mapping.select_next_item({ behavior = cmp.SelectBehavior.Select })";
                "<Up>".__raw = "cmp.mapping.select_prev_item({ behavior = cmp.SelectBehavior.Select })";
                "<C-e>".__raw = "cmp.mapping.abort()";
                "<Esc>".__raw = "cmp.mapping.abort()";
                "<C-Up>".__raw = "cmp.mapping.scroll_docs(-4)";
                "<C-Down>".__raw = "cmp.mapping.scroll_docs(4)";
                "<C-Space>".__raw = "cmp.mapping.complete({})";
                "<CR>".__raw = ''
                  cmp.mapping(function(fallback)
                    if cmp.visible() then
                      if luasnip.expandable() then
                        luasnip.expand()
                      else
                        cmp.confirm({select = true})
                      end
                    else
                      fallback()
                    end
                  end)
                '';
                "<Tab>".__raw = ''
                  cmp.mapping(function(fallback)
                    if cmp.visible() then
                      cmp.select_next_item()
                    elseif luasnip.locally_jumpable(1) then
                      luasnip.jump(1)
                    else
                      fallback() -- This will call the intellitab <Tab> binding
                    end
                  end, { "i", "s" })
                '';
                "<S-Tab>".__raw = ''
                  cmp.mapping(function(fallback)
                    if cmp.visible() then
                      cmp.select_prev_item()
                    elseif luasnip.locally_jumpable(-1) then
                      luasnip.jump(-1)
                    else
                      fallback()
                    end
                  end, { "i", "s" })
                '';
              };
            in ''
              function()
                local cmp = require("${name}")
                local luasnip = require("luasnip")
                local lspkind = require("lspkind")

                local has_words_before = function()
                  unpack = unpack or table.unpack
                  local line, col = unpack(vim.api.nvim_win_get_cursor(0))
                  return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
                end

                return {
                  sources = cmp.config.sources(${sources}),

                  snippet = {
                    expand = function(args)
                      require("luasnip").lsp_expand(args.body)
                    end,
                  },

                  window = {
                    completion = cmp.config.window.bordered(),
                    documentation = cmp.config.window.bordered(),
                    -- completion.border = "rounded",
                    -- documentation.border = "rounded",
                  },

                  formatting = {
                    format = lspkind.cmp_format({
                      mode = "symbol", -- Show only symbol annotations
                      maxwidth = 50,
                      ellipsis_char = "...",
                      show_labelDetails = true, -- show labelDetails in menu. Disabled by default

                      -- The function below will be called before any actual modifications from lspkind
                      before = function (entry, vim_item)
                        return vim_item
                      end
                    })
                  },

                  mapping = cmp.mapping.preset.insert(${mapping}),
                }
              end
            '';
          };

          # colorizer = rec {
          #   name = "colorizer";
          #   pkg = pkgs.vimPlugins.nvim-colorizer-lua;
          #   lazy = true;
          #   event = ["BufReadPost" "BufNewFile"];
          #   config = (mkDefaultConfig name);
          #   opts = {
          #     filtetypes = null;
          #     user_default_options = null;
          #     buftypes = null;
          #   };
          # };

          _ts-context-commentstring = rec {
            name = "ts_context_commentstring";
            pkg = pkgs.vimPlugins.nvim-ts-context-commentstring;
            lazy = true;
            # NOTE: Init is run before the plugin loads, e.g. for legacy vim.g settings
            init = ''
              function()
                -- Skip compatibility checks
                vim.g.skip_ts_context_commentstring_module = true
              end
            '';
            # NOTE: Config is run after the plugin was loaded
            config = mkDefaultConfig name;
          };

          comment = rec {
            name = "Comment";
            pkg = pkgs.vimPlugins.comment-nvim;
            lazy = false;
            # keys = ["<C-c>" "<C-b>"]; # NOTE: This list only works in normal mode
            dependencies = [
              _ts-context-commentstring
            ];
            config = mkDefaultConfig name;
            opts = {
              pre_hook = {__raw = "function() require('ts_context_commentstring.integrations.comment_nvim').create_pre_hook() end";};

              mappings.basic = true; # Apparently required for opleader/toggler config
              mappings.extra = false;
              opleader.line = "<C-c>";
              toggler.line = "<C-c>";
              opleader.block = "<C-b>";
              toggler.block = "<C-b>";
            };
          };

          # Code formatting
          conform = rec {
            name = "conform";
            pkg = pkgs.vimPlugins.conform-nvim;
            lazy = true;
            event = ["BufReadPost" "BufNewFile"];
            config = mkDefaultConfig name;
            opts = {
              formatters_by_ft = {
                c = ["clang-format"];
                h = ["clang-format"];
                cpp = ["clang-format"];
                hpp = ["clang-format"];
                css = ["prettierd" "prettier"];
                html = ["prettierd" "prettier"];
                java = ["google-java-format"];
                javascript = ["prettierd" "prettier"];
                lua = ["stylua"];
                markdown = ["prettierd" "prettier"];
                nix = ["alejandra"];
                python = ["black"];
                rust = ["rustfmt"];
              };

              default_format_opts = {
                lsp_format = "fallback";
                stop_after_first = true;
              };

              format_on_save.__raw = ''
                function(bufnr)
                  -- Disable with a global or buffer-local variable
                  if vim.g.disable_autoformat then
                    return
                  end
                  return { timeout_ms = 500, lsp_format = "fallback", }
                end
              '';
            };
          };

          # TODO: Don't autosave, but if a session exists, update it (using should_autosave)
          _persisted = {
            name = "persisted";
            pkg = pkgs.vimPlugins.persisted-nvim;
            dependencies = [telescope];
            lazy = true;
            cmd = ["SessionSave" "SessionDelete" "Telescope persisted"];
            config = ''
              function(_, opts)
                require("persisted").setup(opts)

                require("telescope").load_extension("persisted")
              end
            '';
            opts = {
              silent = false;
              use_git_branch = false;
              autosave = false;
              autoload = false;
              follow_cwd = true;
              ignored_dirs = [
                "/"
                "~/"
                "~/Projects/"
              ];
            };
          };

          direnv = {
            name = "direnv";
            pkg = pkgs.vimPlugins.direnv-vim;
            lazy = false;
          };

          dashboard = rec {
            name = "dashboard";
            pkg = pkgs.vimPlugins.dashboard-nvim;
            dependencies = [
              web-devicons
              _persisted
            ];
            lazy = false;
            config = mkDefaultConfig name;
            opts = {
              theme = "doom";
              disable_move = true;
              shortcut_type = "number";

              config = {
                center = [
                  {
                    action = "Telescope persisted";
                    desc = " Restore Session";
                    icon = " ";
                    key = "s";
                  }
                  {
                    action = "Telescope find_files";
                    desc = " Find File";
                    icon = " ";
                    key = "f";
                  }
                  {
                    action = "Telescope oldfiles";
                    desc = " Recent Files";
                    icon = " ";
                    key = "r";
                  }
                  {
                    action = "ObsidianSearch";
                    desc = " Obsidian Note";
                    icon = " ";
                    key = "o";
                  }
                  {
                    action = "ene | startinsert";
                    desc = " New File";
                    icon = " ";
                    key = "n";
                  }
                  {
                    action = "Telescope live_grep";
                    desc = " Find Text";
                    icon = " ";
                    key = "g";
                  }
                  {
                    action = "Lazy";
                    desc = " Lazy";
                    icon = "󰒲 ";
                    key = "l";
                  }
                  {
                    action = "quitall";
                    desc = " Quit";
                    icon = " ";
                    key = "q";
                  }
                ];

                footer.__raw = ''
                  function()
                    local stats = require("lazy").stats()
                    local ms = (math.floor(stats.startuptime * 100 + 0.5) / 100)
                    return { "⚡ Neovim loaded " .. stats.loaded .. "/" .. stats.count .. " plugins in " .. ms .. "ms" }
                  end,
                '';
              };
            };
          };

          diffview = {
            name = "diffview";
            pkg = pkgs.vimPlugins.diffview-nvim;
            lazy = true;
            cmd = ["DiffviewOpen"];
          };

          flash = rec {
            name = "flash";
            pkg = pkgs.vimPlugins.flash-nvim;
            lazy = true;
            keys = ["f" "F"];
            config = mkDefaultConfig name;
          };

          gitmessenger = {
            name = "gitmessenger";
            pkg = pkgs.vimPlugins.git-messenger-vim;
            lazy = true;
            cmd = ["GitMessenger"];
            init = let
              mappings = mylib.generators.toLuaObject {
                git_messenger_no_default_mappings = true;
                git_messenger_floating_win_opts = {
                  border = "rounded";
                };
              };
            in ''
              function()
                for k, v in pairs(${mappings}) do
                  vim.g[k] = v
                end
              end
            '';
          };

          gitsigns = rec {
            name = "gitsigns";
            pkg = pkgs.vimPlugins.gitsigns-nvim;
            lazy = true;
            event = ["BufReadPost" "BufNewFile"];
            config = mkDefaultConfig name;
            opts = {
              current_line_blame = false;
            };
          };

          haskell-tools = {
            name = "haskell-tools";
            pkg = pkgs.vimPlugins.haskell-tools-nvim;
            lazy = false; # Recommended by author
            # Don't call setup!
          };

          illuminate = rec {
            name = "illuminate";
            pkg = pkgs.vimPlugins.vim-illuminate;
            lazy = true;
            event = ["BufreadPost" "BufNewFile"];
            config = ''
              function(_, opts)
                require("${name}").configure(opts)
              end
            '';
            opts = {
              filetypesDenylist = [
                "DressingSelect"
                "Outline"
                "TelescopePrompt"
                "alpha"
                "harpoon"
                "toggleterm"
                "neo-tree"
                "Spectre"
                "reason"
              ];
            };
          };

          _navic = {
            name = "navic";
            pkg = pkgs.vimPlugins.nvim-navic;
            lazy = true;
            config = ''
              function(_, opts)
                navic = require("nvim-navic")
                navic.setup(opts)

                -- NOTE: Use incline, because the default winbar isn't floating and disappears
                --       when leavin the split, which makes the buffer jump
                -- Register navic with lualine's winbar
                -- TODO: The setup function should only be ran once
                -- require("lualine").setup({
                --   winbar = {
                --     lualine_c = {
                --       {
                --         function()
                --           return navic.get_location()
                --         end,
                --         cond = function()
                --           return navic.is_available()
                --         end
                --       }
                --     }
                --   }
                -- })
              end
            '';
            opts = {
              lsp.auto_attach = true;
              click = true;
              highlight = true;
              depth_limit = 5;
            };
          };

          intellitab = {
            name = "intellitab";
            # pkg = pkgs.vimPlugins.intellitab-nvim; # Prints at each indent :(
            pkg = pkgs.vimUtils.buildVimPlugin {
              name = "intellitab-nvim";
              src = pkgs.fetchFromGitHub {
                owner = "ChUrl";
                repo = "intellitab.nvim";
                rev = "6d644b7d92198477f2920d0c3b3b22dad470ef10"; # Disable print
                sha256 = "sha256-MwBcsYpyrjoXa7nxcwaci3h0NIWyMoF1NyYfEbFzo0E=";
              };
            };
            lazy = true;
            event = ["InsertEnter"];
          };

          jdtls = {
            name = "jdtls";
            pkg = pkgs.vimPlugins.nvim-jdtls;
            lazy = false; # Is only ever loaded in Java buffers anyway

            # Additional configuration is done in autoCmd
          };

          lastplace = rec {
            name = "nvim-lastplace";
            pkg = pkgs.vimPlugins.nvim-lastplace;
            lazy = false;
            config = mkDefaultConfig name;
          };

          lazygit = {
            name = "lazygit";
            pkg = pkgs.vimPlugins.lazygit-nvim;
            dependencies = [_plenary];
            lazy = true;
            cmd = ["LazyGit" "LazyGitConfig" "LazyGitCurrentFile" "LazyGitFilter" "LazyGitFilterCurrentFile"];
          };

          # leetcode = rec {
          #   name = "leetcode";
          #   pkg = pkgs.vimUtils.buildVimPlugin {
          #     name = "leetcode";
          #     src = pkgs.fetchFromGitHub {
          #       owner = "kawre";
          #       repo = "leetcode.nvim";
          #       rev = "02fb2c855658ad6b60e43671f6b040c812181a1d";
          #       sha256 = "sha256-YoFRd9Uf+Yv4YM6/l7MVLMjfRqhroSS3RCmZvNowIAo=";
          #     };
          #   };
          #   lazy = true;
          #   cmd = ["Leet"];
          #   dependencies = [_notify _nui _plenary telescope treesitter web-devicons];
          #   config = mkDefaultConfig name;
          #   opts = {
          #     lang = "python";
          #   };
          # };

          lint = {
            name = "lint";
            pkg = pkgs.vimPlugins.nvim-lint;
            lazy = true;
            event = ["BufReadPost" "BufNewFile"];
            config = ''
              function(_, opts)
                local lint = require("lint")

                for k, v in pairs(opts) do
                  lint[k] = v
                end

                local chktex = lint.linters.chktex
                chktex.args = {
                  '-v0',
                  '-I0',
                  '-n3', -- Enclose previous parenthesis with {}
                  -- '-n8', -- Wrong length of dash may have been used
                  -- '-n24', -- Delete this space to maintain correct page references
                  '-s',
                  ':',
                  '-f',
                  '%l%b%c%b%d%b%k%b%n%b%m%b%b%b'
                }
              end
            '';
            opts = {
              linters_by_ft = {
                c = ["clangtidy"];
                h = ["clangtidy"];
                cpp = ["clangtidy"];
                hpp = ["clangtidy"];
                clojure = ["clj-kondo"];
                java = ["checkstyle"];
                javascript = ["eslint_d"];
                lua = ["luacheck"];
                markdown = ["vale"];
                nix = ["statix"];
                python = ["flake8"];
                tex = ["chktex"];
                # rust = ["clippy"]; # Not supported, but integrated through rustaceanvim
                text = ["vale"];
              };
            };
          };

          # Newer alternative to neodev
          _lazydev = rec {
            name = "lazydev";
            pkg = pkgs.vimPlugins.lazydev-nvim;
            lazy = true;
            ft = ["lua"];
            config = mkDefaultConfig name;
            # opts = {
            #   library = [
            #     "~/NixFlake/config/neovim/store"
            #   ];
            # };
          };

          # NOTE: This entire thing is rough, I should rewrite...
          lspconfig = {
            name = "lspconfig";
            pkg = pkgs.vimPlugins.nvim-lspconfig;
            lazy = true;
            cmd = ["LspInfo"];
            event = ["BufReadPost" "BufNewFile"];
            dependencies = [_lazydev];
            config = let
              servers = mylib.generators.toLuaObject [
                {
                  name = "clangd";
                  extraOptions = {
                    root_dir.__raw = ''
                      function(fname)
                        return require("lspconfig.util").root_pattern(
                          "Makefile",
                          "CMakeLists.txt",
                          ".clang-format",
                          ".clang-tidy"
                        )(fname) or require("lspconfig.util").root_pattern(
                          "compile_commands.json"
                        )(fname) or require("lspconfig.util").find_git_ancestor(fname)
                      end
                    '';

                    cmd = [
                      "clangd"
                      "--background-index"
                      "--clang-tidy"
                      "--header-insertion=iwyu"
                      "--completion-style=detailed"
                      "--function-arg-placeholders"
                      "--fallback-style=llvm"
                    ];

                    capabilities = {
                      offsetEncoding = ["utf-16"];
                    };

                    init_options = {
                      usePlaceholders = true;
                      completeUnimported = true;
                      clangdFileStatus = true;
                    };
                  };
                }
                {name = "clojure_lsp";}
                {name = "cmake";}
                {name = "lua_ls";}
                {
                  name = "ltex";
                  extraOptions.settings = {
                    ltex = {
                      checkFrequency = "save";
                    };
                  };
                }
                # {name = "nil_ls";} # Conflicts with nixd's hover
                {
                  name = "nixd";
                  extraOptions.settings = {
                    nixd = {
                      nixpkgs = {
                        expr = "import <nixpkgs> { }";
                      };
                      formatting = {
                        command = ["alejandra"];
                      };
                      options = {
                        nixos = {
                          expr = "(builtins.getFlake \"/home/${username}/NixFlake\").nixosConfigurations.${hostname}.options";
                        };
                        # When using HM as a NixOS module, nixd's HM option completion doesn't work.
                        # home_manager = {
                        #   expr = "(builtins.getFlake \"/home/${username}/NixFlake\").homeConfigurations.\"${username}@${hostname}\".options";
                        # };
                      };
                      diagnostic = {
                        suppress = [
                          "sema-escaping-with"
                          "var-bind-to-this"
                          "escaping-this-with"
                        ];
                      };
                    };
                  };
                }
                {name = "pyright";}
                {name = "texlab";}

                # {name = "jdtls";} # Don't set up when using nvim-jdtls
                # {name = "rust_analyzer";} # Don't set up when using rustaceanvim
                # {name = "hls";} # Don't set up when using haskell-tools
              ];
            in ''
              function(_, opts)
                -- Make LspInfo window border rounded
                require("lspconfig.ui.windows").default_options.border = "rounded"

                local __lspOnAttach = function(client, bufnr)
                  -- NOTE: The ltex-extra package needs to be loaded in ltex's onAttach.
                  --       I don't know how to do this more declaratively with the current structure.
                  if client.name == "ltex" then
                    require("ltex_extra").setup({})
                  end
                end

                local __lspCapabilities = function()
                  capabilities = vim.lsp.protocol.make_client_capabilities()
                  capabilities = vim.tbl_deep_extend("force", capabilities, require("cmp_nvim_lsp").default_capabilities())
                  return capabilities
                end

                local __setup = {
                  on_attach = __lspOnAttach,
                  capabilities = __lspCapabilities(),
                }

                for i, server in ipairs(${servers}) do
                  if type(server) == "string" then
                    require("lspconfig")[server].setup(__setup)
                  else
                    local options = server.extraOptions

                    if options == nil then
                      options = __setup
                    else
                      options = vim.tbl_extend("keep", options, __setup)
                    end

                    require("lspconfig")[server.name].setup(options)
                  end
                end
              end
            '';
          };

          lualine = {
            name = "lualine";
            pkg = pkgs.vimPlugins.lualine-nvim;
            lazy = true;
            event = ["BufReadPost" "BufNewFile"];
            config = ''
              function(_, opts)
                local lualine = require("lualine")

                lualine.setup(opts)

                -- Disable tabline/winbar sections
                lualine.hide({
                  place = {'tabline', 'winbar'},
                  unhide = false,
                })
              end
            '';
            opts = let
              bubbles = ''
                {
                  normal = {
                    a = { fg = "#${color.dark.base}", bg = "#${color.dark.lavender}", gui = "bold" },
                    b = { fg = "#${color.dark.text}", bg = "#${color.dark.crust}" },
                    c = { fg = "#${color.dark.text}", bg = "NONE" },
                  },

                  insert = {
                    a = { fg = "#${color.dark.base}", bg = "#${color.dark.green}", gui = "bold" },
                    b = { fg = "#${color.dark.green}", bg = "#${color.dark.crust}" },
                  },

                  visual = {
                    a = { fg = "#${color.dark.base}", bg = "#${color.dark.mauve}", gui = "bold" },
                    b = { fg = "#${color.dark.mauve}", bg = "#${color.dark.crust}" },
                  },

                  replace = {
                    a = { fg = "#${color.dark.base}", bg = "#${color.dark.red}", gui = "bold" },
                    b = { fg = "#${color.dark.red}", bg = "#${color.dark.crust}" },
                  },

                  -- terminal = {
                  --   a = { fg = "#${color.dark.base}", bg = "#${color.dark.green}", gui = "bold" },
                  --   b = { fg = "#${color.dark.green}", bg = "#${color.dark.crust}" },
                  -- },

                  command = {
                    a = { fg = "#${color.dark.base}", bg = "#${color.dark.peach}", gui = "bold" },
                    b = { fg = "#${color.dark.peach}", bg = "#${color.dark.crust}" },
                  },

                  inactive = {
                    a = { fg = "#${color.dark.text}", bg = "#${color.dark.base}" },
                    b = { fg = "#${color.dark.text}", bg = "#${color.dark.base}" },
                    c = { fg = "#${color.dark.text}", bg = "NONE" },
                  },
                }
              '';
            in {
              extensions = ["fzf" "lazy" "neo-tree" "oil" "quickfix" "toggleterm" "trouble"];

              options = {
                # theme = "catppuccin";
                theme.__raw = bubbles;
                always_divide_middle = true;
                globalstatus = true;
                ignore_focus = ["neo-tree"];
                section_separators = {
                  left = "";
                  right = "";
                };
                component_separators = {
                  left = "";
                  right = "";
                };
              };

              sections = {
                # These often use mixed lists/attrSets, so we have to use __raw alot
                lualine_a.__raw = ''{ { "mode", separator = {}, } }'';
                lualine_b.__raw = ''
                  {
                    {
                      "branch",
                      on_click = function() vim.cmd("LazyGit") end,
                    },
                    {
                      "diff",
                      on_click = function() vim.cmd("DiffviewOpen") end,
                    },
                    {
                      "diagnostics",
                      on_click = function() vim.cmd("Trouble diagnostics toggle") end,
                    },
                    {
                      "filename",
                      path = 1,
                    },
                  }
                '';
                lualine_c.__raw = ''{}''; # Use __raw: Nixvim does nothing with "[]", so the default config would be used

                lualine_x.__raw = ''{}'';
                lualine_y = ["filetype" "encoding" "fileformat"];
                lualine_z.__raw = ''{ { "location", separator = {}, } }'';
              };

              inactive_sections = {
                lualine_a = [];
                lualine_b = ["filename"];
                lualine_c = [];
                lualine_x = [];
                lualine_y = [];
                lualine_z = ["location"];
              };

              # Using tabby for this
              # tabline = {
              #   lualine_a = ["hostname"];
              #   lualine_b = ["tabs"]; # buffers
              #   lualine_x = ["windows"];
              # };
            };
          };

          luasnip = {
            name = "luasnip";
            pkg = pkgs.vimPlugins.luasnip;
            lazy = true;
            event = ["InsertEnter"];
            config = ''
              function(_, opts)
                require("luasnip").config.set_config(opts)

                -- Load snippets. Because we don't set "path", the nvim runtimepath is searched.
                -- Snippet files are added through nixvim's extraFiles (see at the top).
                require("luasnip.loaders.from_lua").lazy_load({})
              end
            '';
            opts = {
              enable_autosnippets = false;
            };
          };

          ltex-extra = {
            name = "ltex_extra";
            pkg = pkgs.vimPlugins.ltex_extra-nvim;
            lazy = true;
            ft = ["markdown" "tex"];
            dependencies = [lspconfig];
            config = ''
              -- Do nothing, as we call require("ltex_extra") in ltex's onAttach
              function(_, opts) end
            '';
          };

          markview = {
            name = "markview";
            pkg = pkgs.vimPlugins.markview-nvim;
            lazy = true;
            ft = ["markdown"];
            dependencies = [
              treesitter
              web-devicons
            ];
          };

          navbuddy = {
            name = "navbuddy";
            pkg = pkgs.vimPlugins.nvim-navbuddy;
            dependencies = [_navic];
            lazy = true;
            cmd = ["Navbuddy"];
            config = ''
              function(_, opts)
                local actions = require("nvim-navbuddy.actions") -- ?
                require("nvim-navbuddy").setup(opts)
              end
            '';
            opts = {
              lsp.auto_attach = true;
              window.border = "rounded";
            };
          };

          neo-tree = rec {
            name = "neo-tree";
            pkg = pkgs.vimPlugins.neo-tree-nvim;
            dependencies = [
              _plenary
              web-devicons
              _nui
            ];
            lazy = true;
            cmd = ["Neotree"];
            config = mkDefaultConfig name;
            opts = {
              use_default_mappings = false;
              popup_border_style = "rounded";
              enable_git_status = true;
              enable_diagnostics = false;
              open_files_do_not_replace_types = ["terminal" "trouble" "qf"];

              default_component_configs = {
                container = {
                  enable_character_fade = true;
                };
              };

              filesystem = {
                bind_to_cwd = true;
                cwd_target.sidebar = "global";

                filtered_items = {
                  visible = false; # Toggle with "H"
                };

                follow_current_file = {
                  enabled = true;
                  leave_dirs_open = false;
                };
              };

              buffers = {
                follow_current_file = {
                  enabled = true;
                  leave_dirs_open = false;
                };
              };

              window = {
                position = "left";

                mappings = {
                  "<CR>" = "open";
                  "c" = "close_node";
                  "R" = "refresh";
                  "q" = "close_window";
                  "i" = "show_file_details";
                  "r" = "rename";
                  "d" = "delete";
                  "x" = "cut_to_clipboard";
                  "y" = "copy_to_clipboard";
                  "p" = "paste_from_clipboard";
                  "a" = "add";
                  "." = "set_root";
                  ">" = "navigate_up";
                  "H" = "toggle_hidden";
                  "<Esc>" = "cancel";
                  "/" = "fuzzy_finder";
                  "?" = "show_help";
                };
              };
            };
          };

          neogen = rec {
            name = "neogen";
            pkg = pkgs.vimPlugins.neogen;
            lazy = true;
            cmd = ["Neogen"];
            config = mkDefaultConfig name;
            opts = {
              snippet_engine = "luasnip";
            };
          };

          _notify = {
            name = "notify";
            pkg = pkgs.vimPlugins.nvim-notify;
            lazy = true;
            config = ''
              function(_, opts)
                local notify = require("notify")

                notify.setup(opts)
                vim.notify = notify -- Make vim use notify by default
              end
            '';
            opts = {
              render = "wrapped-compact";
              max_width = 45; # In columns
              top_down = false;
            };
          };

          _nui = {
            name = "nui"; # For noice
            pkg = pkgs.vimPlugins.nui-nvim;
            lazy = true;
          };

          noice = rec {
            name = "noice";
            pkg = pkgs.vimPlugins.noice-nvim;
            lazy = false;
            dependencies = [
              _notify
              _nui
            ];
            config = mkDefaultConfig name;
            opts = {
              presets = {
                bottom_search = false;
                command_palette = true;
                long_message_to_split = true;
                inc_rename = true;
                lsp_doc_border = true;
              };

              lsp = {
                documentation = {
                  opts = {
                    lang = "markdown";
                    replace = true;
                    render = "plain";
                    border = "rounded"; # single or rounded
                    format = ["{message}"];
                    win_options = {
                      concealcursor = "n";
                      conceallevel = 3;
                    };
                  };
                  view = "hover";
                };

                override = {
                  "vim.lsp.util.convert_input_to_markdown_lines" = true;
                  "vim.lsp.util.stylize_markdown" = true;
                  "cmp.entry.get_documentation" = true;
                };
              };

              notify = {
                enabled = true;
              };

              popupmenu = {
                enabled = true;
                backend = "nui"; # cmp completion is broken
              };

              # cmdline.enabled = false;
              # messages.enabled = false;

              routes = [
                # Hide inline search count info
                {
                  filter = {
                    event = "msg_show";
                    kind = "search_count";
                  };
                  opts = {skip = true;};
                }
              ];
            };
          };

          obsidian = rec {
            name = "obsidian";
            pkg = pkgs.vimPlugins.obsidian-nvim;
            lazy = true;
            cmd = ["ObsidianSearch" "ObsidianNew"];
            ft = ["markdown"];
            dependencies = [
              _plenary
            ];
            config = mkDefaultConfig name;
            opts = {
              workspaces = [
                {
                  name = "Chriphost";
                  path = "~/Notes/Obsidian/Chriphost";
                }
              ];
            };
          };

          oil = rec {
            name = "oil";
            pkg = pkgs.vimPlugins.oil-nvim;
            lazy = false;
            config = mkDefaultConfig name;
            opts = {
              default_file_explorer = true;
            };
          };

          presence = rec {
            name = "presence";
            pkg = pkgs.vimPlugins.presence-nvim;
            lazy = true;
            event = ["BufReadPost" "BufNewFile"];
            config = mkDefaultConfig name;
            opts = {
              auto_update = true;
              show_time = false;
            };
          };

          quickfix-reflector = {
            name = "quickfix-reflector";
            pkg = pkgs.vimPlugins.quickfix-reflector-vim;
            lazy = false;
          };

          rainbow-delimiters = {
            name = "rainbow-delimiters";
            pkg = pkgs.vimPlugins.rainbow-delimiters-nvim;
            lazy = false;
          };

          rustaceanvim = {
            name = "rustaceanvim";
            pkg = pkgs.vimPlugins.rustaceanvim;
            lazy = false; # Recommended by author

            # Don't call setup!

            init = ''
              function()
                vim.g.rustaceanvim = {
                  tools = {
                    enable_clippy = true,
                    float_win_config = {
                      border = "rounded",
                    },
                  },

                  server = {
                    default_settings = {
                      ["rust-analyzer"] = {
                        cargo = {
                          allFeatures = true,
                          -- features = "all",
                          -- loadOutDirsFromCheck = true,
                          -- runBuildScripts = true,
                        },

                        -- lint-nvim doesn't support clippy
                        checkOnSave = {
                          allFeatures = true,
                          allTargets = true,
                          command = "clippy",
                          extraArgs = {
                            "--",
                            "--no-deps",
                            "-Dclippy::pedantic",
                            "-Dclippy::nursery",
                            "-Dclippy::unwrap_used",
                            "-Dclippy::enum_glob_use",
                            "-Dclippy::complexity",
                            "-Dclippy::perf",
                          },
                        },
                      },
                    },
                  },
                };
              end
            '';
          };

          scope = rec {
            name = "scope";
            pkg = pkgs.vimPlugins.scope-nvim;
            lazy = false;
            config = mkDefaultConfig name;
          };

          sleuth = {
            name = "sleuth";
            pkg = pkgs.vimPlugins.vim-sleuth;
            lazy = false;
          };

          tabby = rec {
            name = "tabby";
            pkg = pkgs.vimPlugins.tabby-nvim;
            lazy = true;
            event = ["BufReadPost" "BufNewFile"];
            dependencies = [web-devicons];
            config = mkDefaultConfig name;
            opts = {
              line.__raw = ''
                function(line)
                  local base = { fg = "#${color.dark.base}", bg = "#${color.dark.base}" }
                  local crust = { fg = "#${color.dark.crust}", bg = "#${color.dark.crust}" }
                  local text = { fg = "#${color.dark.text}", bg = "#${color.dark.crust}" }
                  local lavender = { fg = "#${color.dark.lavender}", bg = "#${color.dark.lavender}" }

                  local numtabs = vim.call("tabpagenr", "$")

                  return {
                    -- Head
                    {
                        { " NEOVIM ", hl = { fg = "#${color.dark.base}", bg = "#${color.dark.lavender}", style = "bold" } },

                        -- The separator gets a foreground and background fill (each have fg + bg).
                        -- line.sep("", lavender, lavender),
                    },

                    -- Tabs
                    line.tabs().foreach(function(tab)
                      -- Switch out the start separator instead of the ending one because the last separator is different
                      local hl = tab.is_current() and { fg = "#${color.dark.lavender}", bg = "#${color.dark.crust}", style = "bold" } or text
                      local sep_start = tab.number() == 1 and "" or ""
                      local sep_end = tab.number() == numtabs and "" or ""

                      return {
                        line.sep(sep_start, lavender, crust),
                        tab.number(),
                        tab.name(),
                        line.sep(sep_end, crust, base),
                        hl = hl,
                        margin = " ",
                      }
                    end),

                    -- Background
                    hl = base,
                  }
                end
              '';
            };
          };

          _plenary = {
            name = "plenary"; # For telescope
            pkg = pkgs.vimPlugins.plenary-nvim;
            lazy = true;
          };

          _telescope-fzf-native = {
            name = "telescope-fzf-native";
            pkg = pkgs.vimPlugins.telescope-fzf-native-nvim;
            lazy = true;
          };

          _telescope-tabs = {
            name = "telescope-tabs";
            pkg = pkgs.vimUtils.buildVimPlugin {
              name = "telescope-tabs";
              src = pkgs.fetchFromGitHub {
                owner = "LukasPietzschmann";
                repo = "telescope-tabs";
                rev = "0a678eefcb71ebe5cb0876aa71dd2e2583d27fd3";
                sha256 = "sha256-IvxZVHPtApnzUXIQzklT2C2kAxgtAkBUq3GNxwgPdPY=";
              };
            };
            lazy = true;
          };

          _telescope-undo = {
            name = "telescope-undo";
            pkg = pkgs.vimPlugins.telescope-undo-nvim;
            lazy = true;
          };

          _telescope-ui-select = {
            name = "telescope-ui-select";
            pkg = pkgs.vimPlugins.telescope-ui-select-nvim;
            lazy = true;
          };

          telescope = {
            name = "telescope";
            pkg = pkgs.vimPlugins.telescope-nvim;
            lazy = true;
            cmd = ["Telescope"];
            dependencies = [
              _plenary
              _telescope-fzf-native
              _telescope-tabs
              _telescope-undo
              _telescope-ui-select
            ];
            config = let
              extensions = mylib.generators.toLuaObject [
                "undo"
                "ui-select"
                "fzf"
                "telescope-tabs"
              ];
            in ''
              function(_, opts)
                local telescope = require("telescope")
                telescope.setup(opts)

                for i, extension in ipairs(${extensions}) do
                    telescope.load_extension(extension)
                end
              end
            '';
            opts = {
              defaults = {
                wrap_results = false; # Do wrapping in the preview instead, see autoCmd
                preview = {
                  treesitter = true;
                };
                mappings = {
                  i = {
                    # TODO: This mappings throws an error.
                    #       Doesn't matter if defined as function or like "<C-h"> = "which_key";.
                    "<C-h>" = {__raw = ''function(...) return require("telescope.actions").which_key(...) end'';};
                    "<Esc>" = {__raw = ''function(...) return require("telescope.actions").close(...) end'';};
                  };
                };
              };
              pickers = {
                buffers = {
                  # See :h telescope.builtin.buffers() for opts
                  ignore_current_buffer = true;
                  sort_mru = true;
                };
              };
            };
          };

          todo-comments = rec {
            name = "todo-comments";
            pkg = pkgs.vimPlugins.todo-comments-nvim;
            lazy = true;
            event = ["BufReadPost" "BufNewFile"];
            dependencies = [
              _plenary
            ];
            config = mkDefaultConfig name;
            opts = {
              signs = true;

              keywords = {
                FIX = {
                  icon = " ";
                  color = "error";
                  alt = [
                    "FIXME"
                    "BUG"
                    "FIXIT"
                    "ISSUE"
                  ];
                  # signs = false; # Configure signs for some keywords individually
                };
                TODO = {
                  icon = " ";
                  color = "info";
                  alt = [
                  ];
                };
                HACK = {
                  icon = " ";
                  color = "warning";
                  alt = [
                  ];
                };
                WARN = {
                  icon = " ";
                  color = "warning";
                  alt = [
                    "WARNING"
                    "XXX"
                  ];
                };
                PERF = {
                  icon = " ";
                  alt = [
                    "OPTIM"
                    "PERFORMANCE"
                    "OPTIMIZE"
                  ];
                };
                NOTE = {
                  icon = " ";
                  color = "hint";
                  alt = [
                    "INFO"
                  ];
                };
                TEST = {
                  icon = "⏲ ";
                  color = "test";
                  alt = [
                    "TESTING"
                    "PASSED"
                    "FAILED"
                  ];
                };
              };
            };
          };

          toggleterm = rec {
            name = "toggleterm";
            pkg = pkgs.vimPlugins.toggleterm-nvim;
            lazy = true;
            cmd = ["ToggleTerm"];
            keys = ["<C-/>"];
            config = mkDefaultConfig name;
            opts = {
              open_mapping.__raw = "[[<C-/>]]";
              autochdir = true;
              hide_numbers = true;
              shade_terminals = false;
              shading_factor = 30; # Default is -30 to darken the terminal
              start_in_insert = true;
              terminal_mappings = true;
              persist_mode = true;
              insert_mappings = true;
              close_on_exit = true;
              shell = "fish";
              direction = "horizontal"; # 'vertical' | 'horizontal' | 'window' | 'float'
              auto_scroll = true;
              float_opts = {
                border = "curved"; # 'single' | 'double' | 'shadow' | 'curved'
                width = 80;
                height = 45;
                winblend = 0;
              };

              # Hack to make toggleterm respect neotree:
              # Open + close neotree once toggleterm is opened.
              # Toggleterm will "glitch" when opening, also neotree will scroll downwards.
              # on_open.__raw = ''
              #   function(...)
              #     local name = vim.fn.bufname("neo-tree")
              #     local winnr = vim.fn.bufwinnr(name)
              #
              #     if winnr ~= -1 then
              #       vim.defer_fn(function()
              #         local cmd = string.format("Neotree toggle")
              #         vim.cmd(cmd)
              #         vim.cmd(cmd)
              #         vim.cmd("wincmd p")
              #       end, 100)
              #     end
              #   end
              # '';
            };
          };

          # _treesitter-context = {
          #   name = "treesitter-context";
          #   pkg = pkgs.vimPlugins.nvim-treesitter-context;
          #   lazy = true;
          #   config = ''
          #     function(_, opts)
          #       require("treesitter-context").setup(opts)
          #     end
          #   '';
          #   opts = {
          #     max_lines = 3;
          #     line_numbers = false;
          #   };
          # };

          # _treesitter-refactor = {
          #   name = "treesitter-refactor";
          #   pkg = pkgs.vimPlugins.nvim-treesitter-refactor;
          #   lazy = true;
          # };

          treesitter = let
            nvim-plugintree = pkgs.vimPlugins.nvim-treesitter.withAllGrammars;
            treesitter-parsers = pkgs.symlinkJoin {
              name = "treesitter-parsers";
              paths = nvim-plugintree.dependencies;
            };
          in {
            name = "treesitter";
            pkg = pkgs.vimPlugins.nvim-treesitter;
            dependencies = [
              # _treesitter-context # Ugly
              # _treesitter-refactor # Ugly
            ];
            lazy = true;
            cmd = ["TSModuleInfo"];
            event = ["BufReadPost" "BufNewFile"];
            init = ''
              function()
                -- Fix treesitter grammars/parsers on nix
                vim.opt.runtimepath:append("${nvim-plugintree}")
                vim.opt.runtimepath:append("${treesitter-parsers}")
              end
            '';
            config = ''
              function(_, opts)
                require("nvim-treesitter.configs").setup(opts)
              end
            '';
            opts = {
              auto_install = false;
              ensure_installed = [];
              parser_install_dir = "${treesitter-parsers}";

              indent = {
                enable = true;
                # disable = ["python" "yaml"]; # NOTE: Check how bad it is
              };

              highlight = {
                enable = true;
                # disable = ["yaml"];
                additional_vim_regex_highlighting = false;
              };

              # refactor = {
              #   highlight_definitions.enable = true;
              #   highlight_current_scope.enable = false; # Ugly
              # };

              incremental_selection = {
                enable = false;
                keymaps = {
                  "init_selection" = "gnn";
                  "node_decremental" = "grm";
                  "node_incremental" = "grn";
                  "scope_incremental" = "grc";
                };
              };
            };
          };

          trim = rec {
            name = "trim";
            pkg = pkgs.vimPlugins.trim-nvim;
            lazy = false;
            config = mkDefaultConfig name;
          };

          trouble = rec {
            name = "trouble";
            pkg = pkgs.vimPlugins.trouble-nvim;
            lazy = true;
            cmd = ["Trouble" "TroubleToggle"];
            config = mkDefaultConfig name;
          };

          typescript-tools = rec {
            name = "typescript-tools";
            pkg = pkgs.vimPlugins.typescript-tools-nvim;
            lazy = true;
            ft = ["javascript" "typescript"];
            dependencies = [_plenary lspconfig];
            config = mkDefaultConfig name;
          };

          _promise = {
            name = "promise";
            pkg = pkgs.vimPlugins.promise-async;
            lazy = true;
          };

          ufo = rec {
            name = "ufo";
            pkg = pkgs.vimPlugins.nvim-ufo;
            lazy = true;
            event = ["BufReadPost" "BufNewFile"];
            dependencies = [
              _promise
            ];
            config = mkDefaultConfig name;
          };

          vimtex = {
            name = "vimtex";
            pkg = pkgs.vimPlugins.vimtex;
            init = ''
              function()
                vim.g.vimtex_mappings_enabled = false
                vim.g.vimtex_view_method = "zathura"
                vim.g.vimtex_compiler_latexmk = {
                  options = {
                    "-shell-escape",
                    "-file-line-error",
                    "-synctex=1",
                    "-interaction=nonstopmode",
                  },
                  aux_dir = ".aux",
                  out_dir = ".out",
                }
              end
            '';
          };

          wakatime = {
            name = "wakatime";
            pkg = pkgs.vimPlugins.vim-wakatime;
            lazy = true;
            event = ["BufReadPost" "BufNewFile"];
          };

          web-devicons = rec {
            name = "nvim-web-devicons";
            pkg = pkgs.vimPlugins.nvim-web-devicons;
            lazy = true;
            config = mkDefaultConfig name;
          };

          _mini = {
            name = "mini";
            pkg = pkgs.vimPlugins.mini-nvim;
            lazy = true;
          };

          which-key = rec {
            name = "which-key";
            pkg = pkgs.vimPlugins.which-key-nvim;
            lazy = false;
            dependencies = [
              _mini
            ];
            priority = 500;
            config = mkDefaultConfig name;
            opts = {
              preset = "helix"; # or "modern"
            };
          };

          winshift = rec {
            name = "winshift";
            pkg = pkgs.vimPlugins.winshift-nvim;
            lazy = true;
            cmd = ["WinShift"];
            config = mkDefaultConfig name;
            opts = {
              highlight_moving_win = true;

              keymaps = {
                disable_defaults = true;

                win_move_mode = {
                  h = "left";
                  j = "down";
                  k = "up";
                  l = "right";
                };
              };
            };
          };

          yanky = rec {
            name = "yanky";
            pkg = pkgs.vimPlugins.yanky-nvim;
            lazy = true;
            cmd = [
              "YankyClearHistory"
              "YankyRingHistory"
            ];
            config = mkDefaultConfig name;
          };
        in [
          autopairs # Automatic closing brackets/parens
          bbye # Delete buffer without closing the window or split
          better-escape # Escape to normal mode using "jk"
          catppuccin # Colortheme (also add this here to access palettes)
          cellular-automaton # Procrastinate better by watching animations
          clangd-extensions

          # blink-cmp # Auto completion popups # TODO: Try this instead of cmp

          cmp # Auto completion popups

          # colorizer # Colorize color strings # TODO: Only colorize html/css/scss/sass/js

          comment # Toggle line- or block-comments
          conform # Auto formatting on save
          dashboard # Dashboard when starting nvim

          diffview # Git diff # TODO: Check the keybindings

          direnv # Automatically load local environments
          flash # Highlight f/F search results
          gitmessenger # Show last git commit for the current line
          gitsigns # Show git line additions/deletions/changes in the gutter
          haskell-tools # Haskell integration
          illuminate # Highlight usages of word under cursor
          intellitab # Indent to the correct level on blanklines
          jdtls # Eclipse JDT language server integration for Java
          lastplace # Reopen a file at the last editing position
          lazygit # Git frontend
          # leetcode # Solve leetcode problems
          lint # Lint documents on save
          lspconfig # Language server configurations for different languages
          lualine # Status line
          luasnip # Snippets
          ltex-extra # Additional ltex lsp support, e.g. for add-to-dictionary action

          markview # Markdown support # TODO: Disable in help buffers (?) + confiure a bit more

          navbuddy # Structural file view
          neo-tree # File tree sidebar
          neogen # Generate doc comments
          noice # Modern UI overhaul, e.g. floating cmdline
          obsidian # Integration with Obsidian.md
          oil # File manager
          presence # Discord rich presence
          quickfix-reflector # Make the quickfix list editable and saveable to apply changes
          rainbow-delimiters # Bracket/Paren colorization
          rustaceanvim # Rust integration
          scope # Buffers scoped to tabpages
          sleuth # Heuristically set indent depth
          tabby # Nicer tabline (only showing tabpages)
          telescope # Option picker frontend
          todo-comments # Highlight TODOs
          toggleterm # Integrated terminal
          treesitter # AST based syntax highlighting + indentation
          trim # Trim whitespace
          trouble # Diagnostics window
          typescript-tools # Typescript tsserver LSP
          ufo # Code folding
          vimtex # LaTeX support
          wakatime # Time tracking
          web-devicons
          which-key # Live keybinding help
          winshift # Move windows around
          yanky # Clipboard history
        ];
      };
    };
  };
}