diff --git a/home-manager/common/software/cli/neovim.nix b/home-manager/common/software/cli/neovim.nix
index bd7834d5..f3d1db9a 100644
--- a/home-manager/common/software/cli/neovim.nix
+++ b/home-manager/common/software/cli/neovim.nix
@@ -10,7 +10,1662 @@
       nvchad-ui
     ];
   };
+
+  # Files for nvchad:
+  # I know there are better ways to do this.  Don't judge me.
+  home.files.".config/nvim/" = {
+    "init.lua".text = ''
+      require "core"
+
+      local custom_init_path = vim.api.nvim_get_runtime_file("lua/custom/init.lua", false)[1]
+
+      if custom_init_path then
+        dofile(custom_init_path)
+      end
+
+      require("core.utils").load_mappings()
+
+      local lazypath = vim.fn.stdpath "data" .. "/lazy/lazy.nvim"
+
+      -- bootstrap lazy.nvim!
+      if not vim.loop.fs_stat(lazypath) then
+        require("core.bootstrap").gen_chadrc_template()
+        require("core.bootstrap").lazy(lazypath)
+      end
+
+      dofile(vim.g.base46_cache .. "defaults")
+      vim.opt.rtp:prepend(lazypath)
+      require "plugins"
+    '';
+    "lua/" = {
+      "core/" = {
+        "bootstrap.lua".text = ''
+          local M = {}
+
+          M.echo = function(str)
+            vim.cmd "redraw"
+            vim.api.nvim_echo({ { str, "Bold" } }, true, {})
+          end
+
+          local function shell_call(args)
+            local output = vim.fn.system(args)
+            assert(vim.v.shell_error == 0, "External call failed with error code: " .. vim.v.shell_error .. "\n" .. output)
+          end
+
+          M.lazy = function(install_path)
+            ------------- base46 ---------------
+            local lazy_path = vim.fn.stdpath "data" .. "/lazy/base46"
+
+            M.echo "  Compiling base46 theme to bytecode ..."
+
+            local base46_repo = "https://github.com/NvChad/base46"
+            shell_call { "git", "clone", "--depth", "1", "-b", "v2.0", base46_repo, lazy_path }
+            vim.opt.rtp:prepend(lazy_path)
+
+            require("base46").compile()
+
+            --------- lazy.nvim ---------------
+            M.echo "  Installing lazy.nvim & plugins ..."
+            local repo = "https://github.com/folke/lazy.nvim.git"
+            shell_call { "git", "clone", "--filter=blob:none", "--branch=stable", repo, install_path }
+            vim.opt.rtp:prepend(install_path)
+
+            -- install plugins
+            require "plugins"
+
+            -- mason packages & show post_boostrap screen
+            require "nvchad.post_install"()
+          end
+
+          M.gen_chadrc_template = function()
+            if not vim.api.nvim_get_runtime_file("lua/custom/chadrc.lua", false)[1] then
+              local path = vim.fn.stdpath "config" .. "/lua/custom/"
+              local input = "N"
+
+              if next(vim.api.nvim_list_uis()) then
+                input = vim.fn.input "Do you want to install example custom config? (y/N) : "
+              end
+
+              -- clone example_config repo
+              if input == "y" then
+                M.echo "cloning example custom config repo ..."
+                shell_call { "git", "clone", "--depth", "1", "https://github.com/NvChad/example_config", path }
+                vim.fn.delete(path .. ".git", "rf")
+              else
+                -- use very minimal chadrc
+                vim.fn.mkdir(path, "p")
+
+                local file = io.open(path .. "chadrc.lua", "w")
+                file:write "---@type ChadrcConfig \n local M = {}\n M.ui = {theme = 'onedark'}\n return M"
+                file:close()
+              end
+            end
+          end
+
+          return M
+        '';
+        "default_config.lua".text = ''
+          local M = {}
+
+          M.options = {
+            nvchad_branch = "v2.0",
+          }
+
+          M.ui = {
+            ------------------------------- base46 -------------------------------------
+            -- hl = highlights
+            hl_add = {},
+            hl_override = {},
+            changed_themes = {},
+            theme_toggle = { "onedark", "one_light" },
+            theme = "onedark", -- default theme
+            transparency = false,
+            lsp_semantic_tokens = false, -- needs nvim v0.9, just adds highlight groups for lsp semantic tokens
+
+            -- https://github.com/NvChad/base46/tree/v2.0/lua/base46/extended_integrations
+            extended_integrations = {}, -- these aren't compiled by default, ex: "alpha", "notify"
+
+            -- cmp themeing
+            cmp = {
+              icons = true,
+              lspkind_text = true,
+              style = "default", -- default/flat_light/flat_dark/atom/atom_colored
+              border_color = "grey_fg", -- only applicable for "default" style, use color names from base30 variables
+              selected_item_bg = "colored", -- colored / simple
+            },
+
+            telescope = { style = "borderless" }, -- borderless / bordered
+
+            ------------------------------- nvchad_ui modules -----------------------------
+            statusline = {
+              theme = "default", -- default/vscode/vscode_colored/minimal
+              -- default/round/block/arrow separators work only for default statusline theme
+              -- round and block will work for minimal theme only
+              separator_style = "default",
+              overriden_modules = nil,
+            },
+
+            -- lazyload it when there are 1+ buffers
+            tabufline = {
+              show_numbers = false,
+              enabled = true,
+              lazyload = true,
+              overriden_modules = nil,
+            },
+
+            -- nvdash (dashboard)
+            nvdash = {
+              load_on_startup = false,
+
+              header = {
+                "           ▄ ▄                   ",
+                "       ▄   ▄▄▄     ▄ ▄▄▄ ▄ ▄     ",
+                "       █ ▄ █▄█ ▄▄▄ █ █▄█ █ █     ",
+                "    ▄▄ █▄█▄▄▄█ █▄█▄█▄▄█▄▄█ █     ",
+                "  ▄ █▄▄█ ▄ ▄▄ ▄█ ▄▄▄▄▄▄▄▄▄▄▄▄▄▄  ",
+                "  █▄▄▄▄ ▄▄▄ █ ▄ ▄▄▄ ▄ ▄▄▄ ▄ ▄ █ ▄",
+                "▄ █ █▄█ █▄█ █ █ █▄█ █ █▄█ ▄▄▄ █ █",
+                "█▄█ ▄ █▄▄█▄▄█ █ ▄▄█ █ ▄ █ █▄█▄█ █",
+                "    █▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█ █▄█▄▄▄█    ",
+              },
+
+              buttons = {
+                { "  Find File", "Spc f f", "Telescope find_files" },
+                { "󰈚  Recent Files", "Spc f o", "Telescope oldfiles" },
+                { "󰈭  Find Word", "Spc f w", "Telescope live_grep" },
+                { "  Bookmarks", "Spc m a", "Telescope marks" },
+                { "  Themes", "Spc t h", "Telescope themes" },
+                { "  Mappings", "Spc c h", "NvCheatsheet" },
+              },
+            },
+
+            cheatsheet = { theme = "grid" }, -- simple/grid
+
+            lsp = {
+              -- show function signatures i.e args as you type
+              signature = {
+                disabled = false,
+                silent = true, -- silences 'no signature help available' message from appearing
+              },
+            },
+          }
+
+          M.plugins = "" -- path i.e "custom.plugins", so make custom/plugins.lua file
+
+          M.lazy_nvim = require "plugins.configs.lazy_nvim" -- config for lazy.nvim startup options
+
+          M.mappings = require "core.mappings"
+
+          return M
+        '';
+        "init.lua".text = ''
+          local opt = vim.opt
+          local g = vim.g
+          local config = require("core.utils").load_config()
+
+          -------------------------------------- globals -----------------------------------------
+          g.nvchad_theme = config.ui.theme
+          g.base46_cache = vim.fn.stdpath "data" .. "/nvchad/base46/"
+          g.toggle_theme_icon = "   "
+          g.transparency = config.ui.transparency
+
+          -------------------------------------- options ------------------------------------------
+          opt.laststatus = 3 -- global statusline
+          opt.showmode = false
+
+          opt.clipboard = "unnamedplus"
+          opt.cursorline = true
+
+          -- Indenting
+          opt.expandtab = true
+          opt.shiftwidth = 2
+          opt.smartindent = true
+          opt.tabstop = 2
+          opt.softtabstop = 2
+
+          opt.fillchars = { eob = " " }
+          opt.ignorecase = true
+          opt.smartcase = true
+          opt.mouse = "a"
+
+          -- Numbers
+          opt.number = true
+          opt.numberwidth = 2
+          opt.ruler = false
+
+          -- disable nvim intro
+          opt.shortmess:append "sI"
+
+          opt.signcolumn = "yes"
+          opt.splitbelow = true
+          opt.splitright = true
+          opt.termguicolors = true
+          opt.timeoutlen = 400
+          opt.undofile = true
+
+          -- interval for writing swap file to disk, also used by gitsigns
+          opt.updatetime = 250
+
+          -- go to previous/next line with h,l,left arrow and right arrow
+          -- when cursor reaches end/beginning of line
+          opt.whichwrap:append "<>[]hl"
+
+          g.mapleader = " "
+
+          -- disable some default providers
+          for _, provider in ipairs { "node", "perl", "python3", "ruby" } do
+            vim.g["loaded_" .. provider .. "_provider"] = 0
+          end
+
+          -- add binaries installed by mason.nvim to path
+          local is_windows = vim.loop.os_uname().sysname == "Windows_NT"
+          vim.env.PATH = vim.fn.stdpath "data" .. "/mason/bin" .. (is_windows and ";" or ":") .. vim.env.PATH
+
+          -------------------------------------- autocmds ------------------------------------------
+          local autocmd = vim.api.nvim_create_autocmd
+
+          -- dont list quickfix buffers
+          autocmd("FileType", {
+            pattern = "qf",
+            callback = function()
+              vim.opt_local.buflisted = false
+            end,
+          })
+
+          -- reload some chadrc options on-save
+          autocmd("BufWritePost", {
+            pattern = vim.tbl_map(function(path)
+              return vim.fs.normalize(vim.loop.fs_realpath(path))
+            end, vim.fn.glob(vim.fn.stdpath "config" .. "/lua/custom/**/*.lua", true, true, true)),
+            group = vim.api.nvim_create_augroup("ReloadNvChad", {}),
+
+            callback = function(opts)
+              local fp = vim.fn.fnamemodify(vim.fs.normalize(vim.api.nvim_buf_get_name(opts.buf)), ":r") --[[@as string]]
+              local app_name = vim.env.NVIM_APPNAME and vim.env.NVIM_APPNAME or "nvim"
+              local module = string.gsub(fp, "^.*/" .. app_name .. "/lua/", ""):gsub("/", ".")
+
+              require("plenary.reload").reload_module "base46"
+              require("plenary.reload").reload_module(module)
+              require("plenary.reload").reload_module "custom.chadrc"
+
+              config = require("core.utils").load_config()
+
+              vim.g.nvchad_theme = config.ui.theme
+              vim.g.transparency = config.ui.transparency
+
+              -- statusline
+              require("plenary.reload").reload_module("nvchad.statusline." .. config.ui.statusline.theme)
+              vim.opt.statusline = "%!v:lua.require('nvchad.statusline." .. config.ui.statusline.theme .. "').run()"
+
+              -- tabufline
+              if config.ui.tabufline.enabled then
+                require("plenary.reload").reload_module "nvchad.tabufline.modules"
+                vim.opt.tabline = "%!v:lua.require('nvchad.tabufline.modules').run()"
+              end
+
+              require("base46").load_all_highlights()
+              -- vim.cmd("redraw!")
+            end,
+          })
+
+          -------------------------------------- commands ------------------------------------------
+          local new_cmd = vim.api.nvim_create_user_command
+
+          new_cmd("NvChadUpdate", function()
+            require "nvchad.updater"()
+          end, {})
+        '';
+        "mappings.lua".text = ''
+          -- n, v, i, t = mode names
+
+          local M = {}
+
+          M.general = {
+            i = {
+              -- go to  beginning and end
+              ["<C-b>"] = { "<ESC>^i", "Beginning of line" },
+              ["<C-e>"] = { "<End>", "End of line" },
+
+              -- navigate within insert mode
+              ["<C-h>"] = { "<Left>", "Move left" },
+              ["<C-l>"] = { "<Right>", "Move right" },
+              ["<C-j>"] = { "<Down>", "Move down" },
+              ["<C-k>"] = { "<Up>", "Move up" },
+            },
+
+            n = {
+              ["<Esc>"] = { ":noh <CR>", "Clear highlights" },
+              -- switch between windows
+              ["<C-h>"] = { "<C-w>h", "Window left" },
+              ["<C-l>"] = { "<C-w>l", "Window right" },
+              ["<C-j>"] = { "<C-w>j", "Window down" },
+              ["<C-k>"] = { "<C-w>k", "Window up" },
+
+              -- save
+              ["<C-s>"] = { "<cmd> w <CR>", "Save file" },
+
+              -- Copy all
+              ["<C-c>"] = { "<cmd> %y+ <CR>", "Copy whole file" },
+
+              -- line numbers
+              ["<leader>n"] = { "<cmd> set nu! <CR>", "Toggle line number" },
+              ["<leader>rn"] = { "<cmd> set rnu! <CR>", "Toggle relative number" },
+
+              -- Allow moving the cursor through wrapped lines with j, k, <Up> and <Down>
+              -- http://www.reddit.com/r/vim/comments/2k4cbr/problem_with_gj_and_gk/
+              -- empty mode is same as using <cmd> :map
+              -- also don't use g[j|k] when in operator pending mode, so it doesn't alter d, y or c behaviour
+              ["j"] = { 'v:count || mode(1)[0:1] == "no" ? "j" : "gj"', "Move down", opts = { expr = true } },
+              ["k"] = { 'v:count || mode(1)[0:1] == "no" ? "k" : "gk"', "Move up", opts = { expr = true } },
+              ["<Up>"] = { 'v:count || mode(1)[0:1] == "no" ? "k" : "gk"', "Move up", opts = { expr = true } },
+              ["<Down>"] = { 'v:count || mode(1)[0:1] == "no" ? "j" : "gj"', "Move down", opts = { expr = true } },
+
+              -- new buffer
+              ["<leader>b"] = { "<cmd> enew <CR>", "New buffer" },
+              ["<leader>ch"] = { "<cmd> NvCheatsheet <CR>", "Mapping cheatsheet" },
+
+              ["<leader>fm"] = {
+                function()
+                  vim.lsp.buf.format { async = true }
+                end,
+                "LSP formatting",
+              },
+            },
+
+            t = {
+              ["<C-x>"] = { vim.api.nvim_replace_termcodes("<C-\\><C-N>", true, true, true), "Escape terminal mode" },
+            },
+
+            v = {
+              ["<Up>"] = { 'v:count || mode(1)[0:1] == "no" ? "k" : "gk"', "Move up", opts = { expr = true } },
+              ["<Down>"] = { 'v:count || mode(1)[0:1] == "no" ? "j" : "gj"', "Move down", opts = { expr = true } },
+            },
+
+            x = {
+              ["j"] = { 'v:count || mode(1)[0:1] == "no" ? "j" : "gj"', "Move down", opts = { expr = true } },
+              ["k"] = { 'v:count || mode(1)[0:1] == "no" ? "k" : "gk"', "Move up", opts = { expr = true } },
+              -- Don't copy the replaced text after pasting in visual mode
+              -- https://vim.fandom.com/wiki/Replace_a_word_with_yanked_text#Alternative_mapping_for_paste
+              ["p"] = { 'p:let @+=@0<CR>:let @"=@0<CR>', "Dont copy replaced text", opts = { silent = true } },
+            },
+          }
+
+          M.tabufline = {
+            plugin = true,
+
+            n = {
+              -- cycle through buffers
+              ["<tab>"] = {
+                function()
+                  require("nvchad.tabufline").tabuflineNext()
+                end,
+                "Goto next buffer",
+              },
+
+              ["<S-tab>"] = {
+                function()
+                  require("nvchad.tabufline").tabuflinePrev()
+                end,
+                "Goto prev buffer",
+              },
+
+              -- close buffer + hide terminal buffer
+              ["<leader>x"] = {
+                function()
+                  require("nvchad.tabufline").close_buffer()
+                end,
+                "Close buffer",
+              },
+            },
+          }
+
+          M.comment = {
+            plugin = true,
+
+            -- toggle comment in both modes
+            n = {
+              ["<leader>/"] = {
+                function()
+                  require("Comment.api").toggle.linewise.current()
+                end,
+                "Toggle comment",
+              },
+            },
+
+            v = {
+              ["<leader>/"] = {
+                "<ESC><cmd>lua require('Comment.api').toggle.linewise(vim.fn.visualmode())<CR>",
+                "Toggle comment",
+              },
+            },
+          }
+
+          M.lspconfig = {
+            plugin = true,
+
+            -- See `<cmd> :help vim.lsp.*` for documentation on any of the below functions
+
+            n = {
+              ["gD"] = {
+                function()
+                  vim.lsp.buf.declaration()
+                end,
+                "LSP declaration",
+              },
+
+              ["gd"] = {
+                function()
+                  vim.lsp.buf.definition()
+                end,
+                "LSP definition",
+              },
+
+              ["K"] = {
+                function()
+                  vim.lsp.buf.hover()
+                end,
+                "LSP hover",
+              },
+
+              ["gi"] = {
+                function()
+                  vim.lsp.buf.implementation()
+                end,
+                "LSP implementation",
+              },
+
+              ["<leader>ls"] = {
+                function()
+                  vim.lsp.buf.signature_help()
+                end,
+                "LSP signature help",
+              },
+
+              ["<leader>D"] = {
+                function()
+                  vim.lsp.buf.type_definition()
+                end,
+                "LSP definition type",
+              },
+
+              ["<leader>ra"] = {
+                function()
+                  require("nvchad.renamer").open()
+                end,
+                "LSP rename",
+              },
+
+              ["<leader>ca"] = {
+                function()
+                  vim.lsp.buf.code_action()
+                end,
+                "LSP code action",
+              },
+
+              ["gr"] = {
+                function()
+                  vim.lsp.buf.references()
+                end,
+                "LSP references",
+              },
+
+              ["<leader>f"] = {
+                function()
+                  vim.diagnostic.open_float { border = "rounded" }
+                end,
+                "Floating diagnostic",
+              },
+
+              ["[d"] = {
+                function()
+                  vim.diagnostic.goto_prev { float = { border = "rounded" } }
+                end,
+                "Goto prev",
+              },
+
+              ["]d"] = {
+                function()
+                  vim.diagnostic.goto_next { float = { border = "rounded" } }
+                end,
+                "Goto next",
+              },
+
+              ["<leader>q"] = {
+                function()
+                  vim.diagnostic.setloclist()
+                end,
+                "Diagnostic setloclist",
+              },
+
+              ["<leader>wa"] = {
+                function()
+                  vim.lsp.buf.add_workspace_folder()
+                end,
+                "Add workspace folder",
+              },
+
+              ["<leader>wr"] = {
+                function()
+                  vim.lsp.buf.remove_workspace_folder()
+                end,
+                "Remove workspace folder",
+              },
+
+              ["<leader>wl"] = {
+                function()
+                  print(vim.inspect(vim.lsp.buf.list_workspace_folders()))
+                end,
+                "List workspace folders",
+              },
+            },
+          }
+
+          M.nvimtree = {
+            plugin = true,
+
+            n = {
+              -- toggle
+              ["<C-n>"] = { "<cmd> NvimTreeToggle <CR>", "Toggle nvimtree" },
+
+              -- focus
+              ["<leader>e"] = { "<cmd> NvimTreeFocus <CR>", "Focus nvimtree" },
+            },
+          }
+
+          M.telescope = {
+            plugin = true,
+
+            n = {
+              -- find
+              ["<leader>ff"] = { "<cmd> Telescope find_files <CR>", "Find files" },
+              ["<leader>fa"] = { "<cmd> Telescope find_files follow=true no_ignore=true hidden=true <CR>", "Find all" },
+              ["<leader>fw"] = { "<cmd> Telescope live_grep <CR>", "Live grep" },
+              ["<leader>fb"] = { "<cmd> Telescope buffers <CR>", "Find buffers" },
+              ["<leader>fh"] = { "<cmd> Telescope help_tags <CR>", "Help page" },
+              ["<leader>fo"] = { "<cmd> Telescope oldfiles <CR>", "Find oldfiles" },
+              ["<leader>fz"] = { "<cmd> Telescope current_buffer_fuzzy_find <CR>", "Find in current buffer" },
+
+              -- git
+              ["<leader>cm"] = { "<cmd> Telescope git_commits <CR>", "Git commits" },
+              ["<leader>gt"] = { "<cmd> Telescope git_status <CR>", "Git status" },
+
+              -- pick a hidden term
+              ["<leader>pt"] = { "<cmd> Telescope terms <CR>", "Pick hidden term" },
+
+              -- theme switcher
+              ["<leader>th"] = { "<cmd> Telescope themes <CR>", "Nvchad themes" },
+
+              ["<leader>ma"] = { "<cmd> Telescope marks <CR>", "telescope bookmarks" },
+            },
+          }
+
+          M.nvterm = {
+            plugin = true,
+
+            t = {
+              -- toggle in terminal mode
+              ["<A-i>"] = {
+                function()
+                  require("nvterm.terminal").toggle "float"
+                end,
+                "Toggle floating term",
+              },
+
+              ["<A-h>"] = {
+                function()
+                  require("nvterm.terminal").toggle "horizontal"
+                end,
+                "Toggle horizontal term",
+              },
+
+              ["<A-v>"] = {
+                function()
+                  require("nvterm.terminal").toggle "vertical"
+                end,
+                "Toggle vertical term",
+              },
+            },
+
+            n = {
+              -- toggle in normal mode
+              ["<A-i>"] = {
+                function()
+                  require("nvterm.terminal").toggle "float"
+                end,
+                "Toggle floating term",
+              },
+
+              ["<A-h>"] = {
+                function()
+                  require("nvterm.terminal").toggle "horizontal"
+                end,
+                "Toggle horizontal term",
+              },
+
+              ["<A-v>"] = {
+                function()
+                  require("nvterm.terminal").toggle "vertical"
+                end,
+                "Toggle vertical term",
+              },
+
+              -- new
+              ["<leader>h"] = {
+                function()
+                  require("nvterm.terminal").new "horizontal"
+                end,
+                "New horizontal term",
+              },
+
+              ["<leader>v"] = {
+                function()
+                  require("nvterm.terminal").new "vertical"
+                end,
+                "New vertical term",
+              },
+            },
+          }
+
+          M.whichkey = {
+            plugin = true,
+
+            n = {
+              ["<leader>wK"] = {
+                function()
+                  vim.cmd "WhichKey"
+                end,
+                "Which-key all keymaps",
+              },
+              ["<leader>wk"] = {
+                function()
+                  local input = vim.fn.input "WhichKey: "
+                  vim.cmd("WhichKey " .. input)
+                end,
+                "Which-key query lookup",
+              },
+            },
+          }
+
+          M.blankline = {
+            plugin = true,
+
+            n = {
+              ["<leader>cc"] = {
+                function()
+                  local ok, start = require("indent_blankline.utils").get_current_context(
+                    vim.g.indent_blankline_context_patterns,
+                    vim.g.indent_blankline_use_treesitter_scope
+                  )
+
+                  if ok then
+                    vim.api.nvim_win_set_cursor(vim.api.nvim_get_current_win(), { start, 0 })
+                    vim.cmd [[normal! _]]
+                  end
+                end,
+
+                "Jump to current context",
+              },
+            },
+          }
+
+          M.gitsigns = {
+            plugin = true,
+
+            n = {
+              -- Navigation through hunks
+              ["]c"] = {
+                function()
+                  if vim.wo.diff then
+                    return "]c"
+                  end
+                  vim.schedule(function()
+                    require("gitsigns").next_hunk()
+                  end)
+                  return "<Ignore>"
+                end,
+                "Jump to next hunk",
+                opts = { expr = true },
+              },
+
+              ["[c"] = {
+                function()
+                  if vim.wo.diff then
+                    return "[c"
+                  end
+                  vim.schedule(function()
+                    require("gitsigns").prev_hunk()
+                  end)
+                  return "<Ignore>"
+                end,
+                "Jump to prev hunk",
+                opts = { expr = true },
+              },
+
+              -- Actions
+              ["<leader>rh"] = {
+                function()
+                  require("gitsigns").reset_hunk()
+                end,
+                "Reset hunk",
+              },
+
+              ["<leader>ph"] = {
+                function()
+                  require("gitsigns").preview_hunk()
+                end,
+                "Preview hunk",
+              },
+
+              ["<leader>gb"] = {
+                function()
+                  package.loaded.gitsigns.blame_line()
+                end,
+                "Blame line",
+              },
+
+              ["<leader>td"] = {
+                function()
+                  require("gitsigns").toggle_deleted()
+                end,
+                "Toggle deleted",
+              },
+            },
+          }
+
+          return M
+        '';
+        "utils.lua".text = ''
+          local M = {}
+          local merge_tb = vim.tbl_deep_extend
+
+          M.load_config = function()
+            local config = require "core.default_config"
+            local chadrc_path = vim.api.nvim_get_runtime_file("lua/custom/chadrc.lua", false)[1]
+
+            if chadrc_path then
+              local chadrc = dofile(chadrc_path)
+
+              config.mappings = M.remove_disabled_keys(chadrc.mappings, config.mappings)
+              config = merge_tb("force", config, chadrc)
+              config.mappings.disabled = nil
+            end
+
+            return config
+          end
+
+          M.remove_disabled_keys = function(chadrc_mappings, default_mappings)
+            if not chadrc_mappings then
+              return default_mappings
+            end
+
+            -- store keys in a array with true value to compare
+            local keys_to_disable = {}
+            for _, mappings in pairs(chadrc_mappings) do
+              for mode, section_keys in pairs(mappings) do
+                if not keys_to_disable[mode] then
+                  keys_to_disable[mode] = {}
+                end
+                section_keys = (type(section_keys) == "table" and section_keys) or {}
+                for k, _ in pairs(section_keys) do
+                  keys_to_disable[mode][k] = true
+                end
+              end
+            end
+
+            -- make a copy as we need to modify default_mappings
+            for section_name, section_mappings in pairs(default_mappings) do
+              for mode, mode_mappings in pairs(section_mappings) do
+                mode_mappings = (type(mode_mappings) == "table" and mode_mappings) or {}
+                for k, _ in pairs(mode_mappings) do
+                  -- if key if found then remove from default_mappings
+                  if keys_to_disable[mode] and keys_to_disable[mode][k] then
+                    default_mappings[section_name][mode][k] = nil
+                  end
+                end
+              end
+            end
+
+            return default_mappings
+          end
+
+          M.load_mappings = function(section, mapping_opt)
+            vim.schedule(function()
+              local function set_section_map(section_values)
+                if section_values.plugin then
+                  return
+                end
+
+                section_values.plugin = nil
+
+                for mode, mode_values in pairs(section_values) do
+                  local default_opts = merge_tb("force", { mode = mode }, mapping_opt or {})
+                  for keybind, mapping_info in pairs(mode_values) do
+                    -- merge default + user opts
+                    local opts = merge_tb("force", default_opts, mapping_info.opts or {})
+
+                    mapping_info.opts, opts.mode = nil, nil
+                    opts.desc = mapping_info[2]
+
+                    vim.keymap.set(mode, keybind, mapping_info[1], opts)
+                  end
+                end
+              end
+
+              local mappings = require("core.utils").load_config().mappings
+
+              if type(section) == "string" then
+                mappings[section]["plugin"] = nil
+                mappings = { mappings[section] }
+              end
+
+              for _, sect in pairs(mappings) do
+                set_section_map(sect)
+              end
+            end)
+          end
+
+          M.lazy_load = function(plugin)
+            vim.api.nvim_create_autocmd({ "BufRead", "BufWinEnter", "BufNewFile" }, {
+              group = vim.api.nvim_create_augroup("BeLazyOnFileOpen" .. plugin, {}),
+              callback = function()
+                local file = vim.fn.expand "%"
+                local condition = file ~= "NvimTree_1" and file ~= "[lazy]" and file ~= ""
+
+                if condition then
+                  vim.api.nvim_del_augroup_by_name("BeLazyOnFileOpen" .. plugin)
+
+                  -- dont defer for treesitter as it will show slow highlighting
+                  -- This deferring only happens only when we do "nvim filename"
+                  if plugin ~= "nvim-treesitter" then
+                    vim.schedule(function()
+                      require("lazy").load { plugins = plugin }
+
+                      if plugin == "nvim-lspconfig" then
+                        vim.cmd "silent! do FileType"
+                      end
+                    end, 0)
+                  else
+                    require("lazy").load { plugins = plugin }
+                  end
+                end
+              end,
+            })
+          end
+
+          return M
+        '';
+      };
+      "plugins/init.lua".text = ''
+        -- All plugins have lazy=true by default,to load a plugin on startup just lazy=false
+        -- List of all default plugins & their definitions
+        local default_plugins = {
+
+          "nvim-lua/plenary.nvim",
+
+          {
+            "NvChad/base46",
+            branch = "v2.0",
+            build = function()
+              require("base46").load_all_highlights()
+            end,
+          },
+
+          {
+            "NvChad/ui",
+            branch = "v2.0",
+            lazy = false,
+          },
+
+          {
+            "NvChad/nvterm",
+            init = function()
+              require("core.utils").load_mappings "nvterm"
+            end,
+            config = function(_, opts)
+              require "base46.term"
+              require("nvterm").setup(opts)
+            end,
+          },
+
+          {
+            "NvChad/nvim-colorizer.lua",
+            init = function()
+              require("core.utils").lazy_load "nvim-colorizer.lua"
+            end,
+            config = function(_, opts)
+              require("colorizer").setup(opts)
+
+              -- execute colorizer as soon as possible
+              vim.defer_fn(function()
+                require("colorizer").attach_to_buffer(0)
+              end, 0)
+            end,
+          },
+
+          {
+            "nvim-tree/nvim-web-devicons",
+            opts = function()
+              return { override = require "nvchad.icons.devicons" }
+            end,
+            config = function(_, opts)
+              dofile(vim.g.base46_cache .. "devicons")
+              require("nvim-web-devicons").setup(opts)
+            end,
+          },
+
+          {
+            "lukas-reineke/indent-blankline.nvim",
+            version = "2.20.7",
+            init = function()
+              require("core.utils").lazy_load "indent-blankline.nvim"
+            end,
+            opts = function()
+              return require("plugins.configs.others").blankline
+            end,
+            config = function(_, opts)
+              require("core.utils").load_mappings "blankline"
+              dofile(vim.g.base46_cache .. "blankline")
+              require("indent_blankline").setup(opts)
+            end,
+          },
+
+          {
+            "nvim-treesitter/nvim-treesitter",
+            init = function()
+              require("core.utils").lazy_load "nvim-treesitter"
+            end,
+            cmd = { "TSInstall", "TSBufEnable", "TSBufDisable", "TSModuleInfo" },
+            build = ":TSUpdate",
+            opts = function()
+              return require "plugins.configs.treesitter"
+            end,
+            config = function(_, opts)
+              dofile(vim.g.base46_cache .. "syntax")
+              require("nvim-treesitter.configs").setup(opts)
+            end,
+          },
+
+          -- git stuff
+          {
+            "lewis6991/gitsigns.nvim",
+            ft = { "gitcommit", "diff" },
+            init = function()
+              -- load gitsigns only when a git file is opened
+              vim.api.nvim_create_autocmd({ "BufRead" }, {
+                group = vim.api.nvim_create_augroup("GitSignsLazyLoad", { clear = true }),
+                callback = function()
+                  vim.fn.system("git -C " .. '"' .. vim.fn.expand "%:p:h" .. '"' .. " rev-parse")
+                  if vim.v.shell_error == 0 then
+                    vim.api.nvim_del_augroup_by_name "GitSignsLazyLoad"
+                    vim.schedule(function()
+                      require("lazy").load { plugins = { "gitsigns.nvim" } }
+                    end)
+                  end
+                end,
+              })
+            end,
+            opts = function()
+              return require("plugins.configs.others").gitsigns
+            end,
+            config = function(_, opts)
+              dofile(vim.g.base46_cache .. "git")
+              require("gitsigns").setup(opts)
+            end,
+          },
+
+          -- lsp stuff
+          {
+            "williamboman/mason.nvim",
+            cmd = { "Mason", "MasonInstall", "MasonInstallAll", "MasonUninstall", "MasonUninstallAll", "MasonLog" },
+            opts = function()
+              return require "plugins.configs.mason"
+            end,
+            config = function(_, opts)
+              dofile(vim.g.base46_cache .. "mason")
+              require("mason").setup(opts)
+
+              -- custom nvchad cmd to install all mason binaries listed
+              vim.api.nvim_create_user_command("MasonInstallAll", function()
+                vim.cmd("MasonInstall " .. table.concat(opts.ensure_installed, " "))
+              end, {})
+
+              vim.g.mason_binaries_list = opts.ensure_installed
+            end,
+          },
+
+          {
+            "neovim/nvim-lspconfig",
+            init = function()
+              require("core.utils").lazy_load "nvim-lspconfig"
+            end,
+            config = function()
+              require "plugins.configs.lspconfig"
+            end,
+          },
+
+          -- load luasnips + cmp related in insert mode only
+          {
+            "hrsh7th/nvim-cmp",
+            event = "InsertEnter",
+            dependencies = {
+              {
+                -- snippet plugin
+                "L3MON4D3/LuaSnip",
+                dependencies = "rafamadriz/friendly-snippets",
+                opts = { history = true, updateevents = "TextChanged,TextChangedI" },
+                config = function(_, opts)
+                  require("plugins.configs.others").luasnip(opts)
+                end,
+              },
+
+              -- autopairing of (){}[] etc
+              {
+                "windwp/nvim-autopairs",
+                opts = {
+                  fast_wrap = {},
+                  disable_filetype = { "TelescopePrompt", "vim" },
+                },
+                config = function(_, opts)
+                  require("nvim-autopairs").setup(opts)
+
+                  -- setup cmp for autopairs
+                  local cmp_autopairs = require "nvim-autopairs.completion.cmp"
+                  require("cmp").event:on("confirm_done", cmp_autopairs.on_confirm_done())
+                end,
+              },
+
+              -- cmp sources plugins
+              {
+                "saadparwaiz1/cmp_luasnip",
+                "hrsh7th/cmp-nvim-lua",
+                "hrsh7th/cmp-nvim-lsp",
+                "hrsh7th/cmp-buffer",
+                "hrsh7th/cmp-path",
+              },
+            },
+            opts = function()
+              return require "plugins.configs.cmp"
+            end,
+            config = function(_, opts)
+              require("cmp").setup(opts)
+            end,
+          },
+
+          {
+            "numToStr/Comment.nvim",
+            keys = {
+              { "gcc", mode = "n", desc = "Comment toggle current line" },
+              { "gc", mode = { "n", "o" }, desc = "Comment toggle linewise" },
+              { "gc", mode = "x", desc = "Comment toggle linewise (visual)" },
+              { "gbc", mode = "n", desc = "Comment toggle current block" },
+              { "gb", mode = { "n", "o" }, desc = "Comment toggle blockwise" },
+              { "gb", mode = "x", desc = "Comment toggle blockwise (visual)" },
+            },
+            init = function()
+              require("core.utils").load_mappings "comment"
+            end,
+            config = function(_, opts)
+              require("Comment").setup(opts)
+            end,
+          },
+
+          -- file managing , picker etc
+          {
+            "nvim-tree/nvim-tree.lua",
+            cmd = { "NvimTreeToggle", "NvimTreeFocus" },
+            init = function()
+              require("core.utils").load_mappings "nvimtree"
+            end,
+            opts = function()
+              return require "plugins.configs.nvimtree"
+            end,
+            config = function(_, opts)
+              dofile(vim.g.base46_cache .. "nvimtree")
+              require("nvim-tree").setup(opts)
+            end,
+          },
+
+          {
+            "nvim-telescope/telescope.nvim",
+            dependencies = "nvim-treesitter/nvim-treesitter",
+            cmd = "Telescope",
+            init = function()
+              require("core.utils").load_mappings "telescope"
+            end,
+            opts = function()
+              return require "plugins.configs.telescope"
+            end,
+            config = function(_, opts)
+              dofile(vim.g.base46_cache .. "telescope")
+              local telescope = require "telescope"
+              telescope.setup(opts)
+
+              -- load extensions
+              for _, ext in ipairs(opts.extensions_list) do
+                telescope.load_extension(ext)
+              end
+            end,
+          },
+
+          -- Only load whichkey after all the gui
+          {
+            "folke/which-key.nvim",
+            keys = { "<leader>", "<c-r>", '"', "'", "`", "c", "v", "g" },
+            init = function()
+              require("core.utils").load_mappings "whichkey"
+            end,
+            cmd = "WhichKey",
+            config = function(_, opts)
+              dofile(vim.g.base46_cache .. "whichkey")
+              require("which-key").setup(opts)
+            end,
+          },
+        }
+
+        local config = require("core.utils").load_config()
+
+        if #config.plugins > 0 then
+          table.insert(default_plugins, { import = config.plugins })
+        end
+
+        require("lazy").setup(default_plugins, config.lazy_nvim)
+      '';
+      "plugins/configs/" = {
+        "cmp.lua".text = ''
+          local cmp = require "cmp"
+
+          dofile(vim.g.base46_cache .. "cmp")
+
+          local cmp_ui = require("core.utils").load_config().ui.cmp
+          local cmp_style = cmp_ui.style
+
+          local field_arrangement = {
+            atom = { "kind", "abbr", "menu" },
+            atom_colored = { "kind", "abbr", "menu" },
+          }
+
+          local formatting_style = {
+            -- default fields order i.e completion word + item.kind + item.kind icons
+            fields = field_arrangement[cmp_style] or { "abbr", "kind", "menu" },
+
+            format = function(_, item)
+              local icons = require "nvchad.icons.lspkind"
+              local icon = (cmp_ui.icons and icons[item.kind]) or ""
+
+              if cmp_style == "atom" or cmp_style == "atom_colored" then
+                icon = " " .. icon .. " "
+                item.menu = cmp_ui.lspkind_text and "   (" .. item.kind .. ")" or ""
+                item.kind = icon
+              else
+                icon = cmp_ui.lspkind_text and (" " .. icon .. " ") or icon
+                item.kind = string.format("%s %s", icon, cmp_ui.lspkind_text and item.kind or "")
+              end
+
+              return item
+            end,
+          }
+
+          local function border(hl_name)
+            return {
+              { "╭", hl_name },
+              { "─", hl_name },
+              { "╮", hl_name },
+              { "│", hl_name },
+              { "╯", hl_name },
+              { "─", hl_name },
+              { "╰", hl_name },
+              { "│", hl_name },
+            }
+          end
+
+          local options = {
+            completion = {
+              completeopt = "menu,menuone",
+            },
+
+            window = {
+              completion = {
+                side_padding = (cmp_style ~= "atom" and cmp_style ~= "atom_colored") and 1 or 0,
+                winhighlight = "Normal:CmpPmenu,CursorLine:CmpSel,Search:PmenuSel",
+                scrollbar = false,
+              },
+              documentation = {
+                border = border "CmpDocBorder",
+                winhighlight = "Normal:CmpDoc",
+              },
+            },
+            snippet = {
+              expand = function(args)
+                require("luasnip").lsp_expand(args.body)
+              end,
+            },
+
+            formatting = formatting_style,
+
+            mapping = {
+              ["<C-p>"] = cmp.mapping.select_prev_item(),
+              ["<C-n>"] = cmp.mapping.select_next_item(),
+              ["<C-d>"] = cmp.mapping.scroll_docs(-4),
+              ["<C-f>"] = cmp.mapping.scroll_docs(4),
+              ["<C-Space>"] = cmp.mapping.complete(),
+              ["<C-e>"] = cmp.mapping.close(),
+              ["<CR>"] = cmp.mapping.confirm {
+                behavior = cmp.ConfirmBehavior.Insert,
+                select = true,
+              },
+              ["<Tab>"] = cmp.mapping(function(fallback)
+                if cmp.visible() then
+                  cmp.select_next_item()
+                elseif require("luasnip").expand_or_jumpable() then
+                  vim.fn.feedkeys(vim.api.nvim_replace_termcodes("<Plug>luasnip-expand-or-jump", true, true, true), "")
+                else
+                  fallback()
+                end
+              end, {
+                "i",
+                "s",
+              }),
+              ["<S-Tab>"] = cmp.mapping(function(fallback)
+                if cmp.visible() then
+                  cmp.select_prev_item()
+                elseif require("luasnip").jumpable(-1) then
+                  vim.fn.feedkeys(vim.api.nvim_replace_termcodes("<Plug>luasnip-jump-prev", true, true, true), "")
+                else
+                  fallback()
+                end
+              end, {
+                "i",
+                "s",
+              }),
+            },
+            sources = {
+              { name = "nvim_lsp" },
+              { name = "luasnip" },
+              { name = "buffer" },
+              { name = "nvim_lua" },
+              { name = "path" },
+            },
+          }
+
+          if cmp_style ~= "atom" and cmp_style ~= "atom_colored" then
+            options.window.completion.border = border "CmpBorder"
+          end
+
+          return options
+        '';
+        "lazy_nvim.lua".text = ''
+          return {
+            defaults = { lazy = true },
+            install = { colorscheme = { "nvchad" } },
+
+            ui = {
+              icons = {
+                ft = "",
+                lazy = "󰂠 ",
+                loaded = "",
+                not_loaded = "",
+              },
+            },
+
+            performance = {
+              rtp = {
+                disabled_plugins = {
+                  "2html_plugin",
+                  "tohtml",
+                  "getscript",
+                  "getscriptPlugin",
+                  "gzip",
+                  "logipat",
+                  "netrw",
+                  "netrwPlugin",
+                  "netrwSettings",
+                  "netrwFileHandlers",
+                  "matchit",
+                  "tar",
+                  "tarPlugin",
+                  "rrhelper",
+                  "spellfile_plugin",
+                  "vimball",
+                  "vimballPlugin",
+                  "zip",
+                  "zipPlugin",
+                  "tutor",
+                  "rplugin",
+                  "syntax",
+                  "synmenu",
+                  "optwin",
+                  "compiler",
+                  "bugreport",
+                  "ftplugin",
+                },
+              },
+            },
+          }
+        '';
+        "lspconfig.lua".text = ''
+          dofile(vim.g.base46_cache .. "lsp")
+          require "nvchad.lsp"
+
+          local M = {}
+          local utils = require "core.utils"
+
+          -- export on_attach & capabilities for custom lspconfigs
+
+          M.on_attach = function(client, bufnr)
+            client.server_capabilities.documentFormattingProvider = false
+            client.server_capabilities.documentRangeFormattingProvider = false
+
+            utils.load_mappings("lspconfig", { buffer = bufnr })
+
+            if client.server_capabilities.signatureHelpProvider then
+              require("nvchad.signature").setup(client)
+            end
+
+            if not utils.load_config().ui.lsp_semantic_tokens and client.supports_method "textDocument/semanticTokens" then
+              client.server_capabilities.semanticTokensProvider = nil
+            end
+          end
+
+          M.capabilities = vim.lsp.protocol.make_client_capabilities()
+
+          M.capabilities.textDocument.completion.completionItem = {
+            documentationFormat = { "markdown", "plaintext" },
+            snippetSupport = true,
+            preselectSupport = true,
+            insertReplaceSupport = true,
+            labelDetailsSupport = true,
+            deprecatedSupport = true,
+            commitCharactersSupport = true,
+            tagSupport = { valueSet = { 1 } },
+            resolveSupport = {
+              properties = {
+                "documentation",
+                "detail",
+                "additionalTextEdits",
+              },
+            },
+          }
+
+          require("lspconfig").lua_ls.setup {
+            on_attach = M.on_attach,
+            capabilities = M.capabilities,
+
+            settings = {
+              Lua = {
+                diagnostics = {
+                  globals = { "vim" },
+                },
+                workspace = {
+                  library = {
+                    [vim.fn.expand "$VIMRUNTIME/lua"] = true,
+                    [vim.fn.expand "$VIMRUNTIME/lua/vim/lsp"] = true,
+                    [vim.fn.stdpath "data" .. "/lazy/ui/nvchad_types"] = true,
+                    [vim.fn.stdpath "data" .. "/lazy/lazy.nvim/lua/lazy"] = true,
+                  },
+                  maxPreload = 100000,
+                  preloadFileSize = 10000,
+                },
+              },
+            },
+          }
+
+          return M
+        '';
+        "mason.lua".text = ''
+          local options = {
+            ensure_installed = { "lua-language-server" }, -- not an option from mason.nvim
+
+            PATH = "skip",
+
+            ui = {
+              icons = {
+                package_pending = " ",
+                package_installed = "󰄳 ",
+                package_uninstalled = " 󰚌",
+              },
+
+              keymaps = {
+                toggle_server_expand = "<CR>",
+                install_server = "i",
+                update_server = "u",
+                check_server_version = "c",
+                update_all_servers = "U",
+                check_outdated_servers = "C",
+                uninstall_server = "X",
+                cancel_installation = "<C-c>",
+              },
+            },
+
+            max_concurrent_installers = 10,
+          }
+
+          return options
+        '';
+        "nvimtree.lua".text = ''
+          local options = {
+            filters = {
+              dotfiles = false,
+              exclude = { vim.fn.stdpath "config" .. "/lua/custom" },
+            },
+            disable_netrw = true,
+            hijack_netrw = true,
+            hijack_cursor = true,
+            hijack_unnamed_buffer_when_opening = false,
+            sync_root_with_cwd = true,
+            update_focused_file = {
+              enable = true,
+              update_root = false,
+            },
+            view = {
+              adaptive_size = false,
+              side = "left",
+              width = 30,
+              preserve_window_proportions = true,
+            },
+            git = {
+              enable = false,
+              ignore = true,
+            },
+            filesystem_watchers = {
+              enable = true,
+            },
+            actions = {
+              open_file = {
+                resize_window = true,
+              },
+            },
+            renderer = {
+              root_folder_label = false,
+              highlight_git = false,
+              highlight_opened_files = "none",
+
+              indent_markers = {
+                enable = false,
+              },
+
+              icons = {
+                show = {
+                  file = true,
+                  folder = true,
+                  folder_arrow = true,
+                  git = false,
+                },
+
+                glyphs = {
+                  default = "󰈚",
+                  symlink = "",
+                  folder = {
+                    default = "",
+                    empty = "",
+                    empty_open = "",
+                    open = "",
+                    symlink = "",
+                    symlink_open = "",
+                    arrow_open = "",
+                    arrow_closed = "",
+                  },
+                  git = {
+                    unstaged = "✗",
+                    staged = "✓",
+                    unmerged = "",
+                    renamed = "➜",
+                    untracked = "★",
+                    deleted = "",
+                    ignored = "◌",
+                  },
+                },
+              },
+            },
+          }
+
+          return options
+        '';
+        "others.lua".text = ''
+          local M = {}
+          local utils = require "core.utils"
+
+          M.blankline = {
+            indentLine_enabled = 1,
+            filetype_exclude = {
+              "help",
+              "terminal",
+              "lazy",
+              "lspinfo",
+              "TelescopePrompt",
+              "TelescopeResults",
+              "mason",
+              "nvdash",
+              "nvcheatsheet",
+              "",
+            },
+            buftype_exclude = { "terminal" },
+            show_trailing_blankline_indent = false,
+            show_first_indent_level = false,
+            show_current_context = true,
+            show_current_context_start = true,
+          }
+
+          M.luasnip = function(opts)
+            require("luasnip").config.set_config(opts)
+
+            -- vscode format
+            require("luasnip.loaders.from_vscode").lazy_load()
+            require("luasnip.loaders.from_vscode").lazy_load { paths = vim.g.vscode_snippets_path or "" }
+
+            -- snipmate format
+            require("luasnip.loaders.from_snipmate").load()
+            require("luasnip.loaders.from_snipmate").lazy_load { paths = vim.g.snipmate_snippets_path or "" }
+
+            -- lua format
+            require("luasnip.loaders.from_lua").load()
+            require("luasnip.loaders.from_lua").lazy_load { paths = vim.g.lua_snippets_path or "" }
+
+            vim.api.nvim_create_autocmd("InsertLeave", {
+              callback = function()
+                if
+                  require("luasnip").session.current_nodes[vim.api.nvim_get_current_buf()]
+                  and not require("luasnip").session.jump_active
+                then
+                  require("luasnip").unlink_current()
+                end
+              end,
+            })
+          end
+
+          M.gitsigns = {
+            signs = {
+              add = { text = "│" },
+              change = { text = "│" },
+              delete = { text = "󰍵" },
+              topdelete = { text = "‾" },
+              changedelete = { text = "~" },
+              untracked = { text = "│" },
+            },
+            on_attach = function(bufnr)
+              utils.load_mappings("gitsigns", { buffer = bufnr })
+            end,
+          }
+
+          return M
+        '';
+        "telescope.lua".text = ''
+          local options = {
+            defaults = {
+              vimgrep_arguments = {
+                "rg",
+                "-L",
+                "--color=never",
+                "--no-heading",
+                "--with-filename",
+                "--line-number",
+                "--column",
+                "--smart-case",
+              },
+              prompt_prefix = "   ",
+              selection_caret = "  ",
+              entry_prefix = "  ",
+              initial_mode = "insert",
+              selection_strategy = "reset",
+              sorting_strategy = "ascending",
+              layout_strategy = "horizontal",
+              layout_config = {
+                horizontal = {
+                  prompt_position = "top",
+                  preview_width = 0.55,
+                  results_width = 0.8,
+                },
+                vertical = {
+                  mirror = false,
+                },
+                width = 0.87,
+                height = 0.80,
+                preview_cutoff = 120,
+              },
+              file_sorter = require("telescope.sorters").get_fuzzy_file,
+              file_ignore_patterns = { "node_modules" },
+              generic_sorter = require("telescope.sorters").get_generic_fuzzy_sorter,
+              path_display = { "truncate" },
+              winblend = 0,
+              border = {},
+              borderchars = { "─", "│", "─", "│", "╭", "╮", "╯", "╰" },
+              color_devicons = true,
+              set_env = { ["COLORTERM"] = "truecolor" }, -- default = nil,
+              file_previewer = require("telescope.previewers").vim_buffer_cat.new,
+              grep_previewer = require("telescope.previewers").vim_buffer_vimgrep.new,
+              qflist_previewer = require("telescope.previewers").vim_buffer_qflist.new,
+              -- Developer configurations: Not meant for general override
+              buffer_previewer_maker = require("telescope.previewers").buffer_previewer_maker,
+              mappings = {
+                n = { ["q"] = require("telescope.actions").close },
+              },
+            },
+
+            extensions_list = { "themes", "terms" },
+          }
+
+          return options
+        '';
+        "treesitter.lua".text = ''
+          local options = {
+          ensure_installed = { "lua" },
+
+          highlight = {
+            enable = true,
+            use_languagetree = true,
+          },
+
+          indent = { enable = true },
+        }
+
+        return options
+        '';
+      };
+    };
+  };
+
+  };
 }
+
 #    plugins = with pkgs.vimPlugins; [
 #      # vim-airline # Trying out lualine - below
 #      YouCompleteMe