Nvim plugins

Plugins are configured in lua/plugins/*.lua.

Plugins are configured using lazy.nvim. This supports lazy-loading of plugins to keep a snappy startup time, and only load plugins when they’re needed. See Migrating to Neovim Lua config for my rationale on that.

Quick-reference on lazy.nvim

Each plugin spec in lua/plugins/*.lua is a table. The first property is the name of the plugin. Other properties:

• lazy: only load when requested by something else. Saves on initial load time, but use this with care since it can get confusing.

• ft: only load the plugin when editing this filetype. Implies lazy=true.

• cmd: only load the plugin when first running this command. Implies lazy=true.

• keys: only load the plugin when using these keymappings. Implies lazy=true.

• config: run this stuff after the plugin loads. If config = true, just run the default setup for the plugin.

• init: similar to config, but used for pure-vim plugins

If keys are specified, this is the only place they need to be mapped, and they will make their way into the which-key menu even if they trigger a lazy-loaded plugin. Use the desc argument to give which-key a description to use.

Note

Don’t like a plugin? Find it in lua/plugins/*.lua and add enabled = false next to where the plugin is named. For example:

{ "user/plugin-name", enabled = false },

Or delete the file completely.

screencast of lazy.nvim setting up plugins

Because of how frequently nvim changes, each plugin section below has a changelog. Since I have reorganized files over the years, the changelogs show the mention of a plugin in a commit message, in a filename, or as part of the changeset of a commit in an attempt to catch all of the changes. This may be a little overzealous (for example the trouble plugin picks up commits related to troubleshooting) but I’ve opted to err on the side of completeness.

Plugin list

I’ve organized the plugins into broad categories:

Git-related

The following commands are built-in vim commands when in diff mode, but are used heavily when working with git, so here is a reminder:

command	description
]c	Go to the next diff
[c	Go to the previous diff
do	Use the [o]ther file’s contents for the current diff
dp	[P]ut the contents of this diff into the other file

vim-fugitive

vim-fugitive provides a git interface in vim.

Fugitive is wonderful for making incremental commits from within vim. This makes it a terminal-only version of GUIs like git-cola, gitkraken, or GitHub Desktop.

I use it so much that I have a bash alias for starting this directly from the command line: gsv (mnemonic: git status viewer).

command	description
:Git	Opens the main screen for fugitive (hint: use vim -c “:Git” from the command line to jump right into it)
:tab Git	Opens the main screen for fugitive in a new tab, for fullscreen usage; :q to get back to what you were editing on before running it.
=	Toggle visibility of changes
- (when over a filename)	Stage or unstage the file
- (when in a chunk after using =)	Stage or unstage the chunk
- (in visual select mode (V))	Stage or unstage just the selected lines. Perfect for making incremental commits.
cc	Commit, opening up a separate buffer in which to write the commit message
dd (when over a file)	Open the file in diff mode (to better see intraline diffs)

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/vim-fugitive.lua:

 -- vim-fugitive provides a convenient git interface, with incremental commits
 return {
  { "tpope/vim-fugitive", cmd = "Git", lazy = true },
 }

diffview.nvim

diffview.nvim supports viewing diffs across multiple files. It also has a nice interface for browsing previous commits. I find this to be nicer for browsing git history when there are multiple files per commit.

I have a bash alias for starting this directly from the command line: glv (mnemonic: git log viewer).

command	description
:DiffviewOpen	Opens the viewer
:DiffviewFileHistory	View diffs for this file throughout git history

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/diffview.lua:

-- diffview provides an interface for exploring git history
return {
  { "sindrets/diffview.nvim", cmd = { "DiffviewOpen", "DiffviewFileHistory" } },
}

gitsigns

gitsigns shows a “gutter” along the left side of the line numbers, indicating where there were changes in a file. Only works in git repos.

Since you can stage and make commits with this plugin, it is in a way redundant with vim-fugitive. I find fugitive to be more useful when making commits across multiple files, and gitsigns to be more useful in showing what’s changed while still editing a file.

Most commands require being in a hunk. Keymappings start with h, mnemonic is “hunk” (the term for a block of changes).

command	description
[h	Previous change
]h	Next change
<leader>hp	Preview hunk (shows floating window of the change, only works in a change)
<leader>hs	Stage hunk (or stage lines in visual mode)
<leader>hr	Reset hunk (or reset lines in visual mode)
<leader>hu	Undo stage hunk
<leader>hS	Stage buffer
<leader>hR	Reset buffer
<leader>hb	Blame line in floating window
hd	Diff this file (opens diff mode)

Additionally, this supports hunks as text objects using ih (inside hunk). E.g., select a hunk with vih, or delete a hunk with dih.

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/gitsigns.lua:

-- gitsigns shows changes in file, when working in a git repo
return {
  {
    "lewis6991/gitsigns.nvim",
    dependencies = {
      "nvim-lua/plenary.nvim",
    },
    opts = {
      on_attach = function(buffer)
        local gs = package.loaded.gitsigns

        local function map(mode, l, r, desc)
          vim.keymap.set(mode, l, r, { buffer = buffer, desc = desc })
        end

        map("n", "]h", gs.next_hunk, "Next hunk")
        map("n", "[h", gs.prev_hunk, "Prev hunk")
        map({ "n", "v" }, "<leader>hs", ":Gitsigns stage_hunk<CR>", "Stage hunk")
        map({ "n", "v" }, "<leader>hr", ":Gitsigns reset_hunk<CR>", "Reset hunk")
        map("n", "<leader>hS", gs.stage_buffer, "Stage buffer")
        map("n", "<leader>hu", gs.undo_stage_hunk, "Undo Stage hunk")
        map("n", "<leader>hR", gs.reset_buffer, "Reset buffer")
        map("n", "<leader>hp", gs.preview_hunk, "Preview hunk")
        map("n", "<leader>hb", function()
          gs.blame_line({ full = true })
        end, "Blame line")
        map("n", "<leader>hd", gs.diffthis, "Diff this")
        map("n", "<leader>hD", function()
          gs.diffthis("~")
        end, "Diff This ~")
        map({ "o", "x" }, "ih", ":<C-U>Gitsigns select_hunk<CR>", "GitSigns Select hunk")
      end,
    },
  },
}

gv

vim.gv provides an interface to easily view and browse git history.

It’s simpler than diffview.nvim which can be helpful sometimes.

command	description
:GV in visual mode	View commits affecting selection
GV	Open a commit browser, hit Enter on a commit to view

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/gv.lua:

-- gv.vim provides a graphical git log
return {
  {
    "junegunn/gv.vim",
    cmd = "GV",
    dependencies = { "tpope/vim-fugitive" }
  },
}

vim-mergetool

vim-mergetool makes 3-way merge conflicts much easier to deal with by only focusing on what needs to be manually edited.

This makes it MUCH easier to work with 3-way diffs (like what happens in merge conflicts), while at the same time allowing enough flexibility in configuration to be able to reproduce default behaviors.

Note

You’ll need to set the following in your .gitconfig:

[merge]
conflictStyle = diff3

command	description
:MergetoolStart	Starts the tool
:diffget	Pulls “theirs” (that is, assume the remote is correct)
do, dp	Used as in vim diff mode

Save and quit, or use :MergetoolStop.

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/vim-mergetool.lua:

-- vim-mergetool lets you easily work with 3-way merge conflicts
return {
  {
    "samoshkin/vim-mergetool",
    cmd = "MergetoolStart",
  },
}

LSP-related

The Language Server Protocol lets an editor like neovim communicate with a language server. A language server is installed per language (e.g. Python, Bash, etc), which knows a LOT about the language, and supports things like:

• advanced autocomplete

• advanced highlighting

• going to definitiions or references (e.g., find where a function is originally defined, or where it is used)

• identifying syntax errors directly in the editor

Microsoft’s overview of LSP has more information.

You install an LSP server for each language you want to use it with (see mason.nvim for installing these). Then you enable the LSP server for a buffer, and you get code-aware hints, warnings, etc.

Not all features are implemented in every LSP server. For example, the Python LSP is quite feature-rich. In contrast, the R LSP is a bit weak.

The Python LSP may be quite verbose if you enable it on existing code, though in my experience addressing everything it’s complaining about will improve your code. You may find you need to add type annotations in some cases.

Because the experience can be hit-or-miss depending on the language you’re using, and the language servers need to be installed, LSP is disabled by default; start it with cl.

Warning

nvim 0.11 changed the way LSPs are handled, making them more natively integrated. However, this breaks the existing plugin configuration.

These dotfiles currently only support nvim <0.11.

I experimented with supporting both versions simultaneously. But the files got complex, and it was a pain to keep switching versions to test everything on both. So I’m opting to require nvim 0.10 for now. After a little while, I’ll move everything to 0.11+ and require nvim 0.11+.

nvim-lspconfig

nvim-lspconfig provides access to nvim’s Language Server Protocol (LSP).

Note

You’ll probably need to install NodeJS to install language servers with :Mason (see mason.nvim):

./setup.sh --install-npm  # install nodejs into conda env

These keymaps start with c (mnemonic: “code”). You need to start the language server with cl to have access to any of the other keymaps.

command	description
<leader>cl	Start the LSP server for this buffer
<leader>ce	Open diagnostic details
[d	Prev diagnostic
]d	Next diagnostic
<leader>cgd	Goto definition (e.g., when cursor is over a function)
<leader>cK	Hover help
<leader>crn	Rename all instances of this symbol
<leader>cr	Goto references
<leader>ca	Code action (opens a menu if implemented)

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/nvim-lspconfig.lua:

-- nvim-lspconfig allows convenient configuration of LSP clients
return {
  {
    "neovim/nvim-lspconfig",
    cmd = "LspStart",
    init = function()
      local lspconfig = require("lspconfig")

      -- Below, autostart = false means that you need to explicity call :LspStart (<leader>cl)
      --
      -- ----------------------------------------------------------------------
      -- CONFIGURE ADDITIONAL LANGUAGE SERVERS HERE
      --
      -- pyright is the language server for Python
      lspconfig.pyright.setup({ autostart = false })

      lspconfig.bashls.setup({ autostart = false })

      -- language server for R
      lspconfig.r_language_server.setup({ autostart = false })

      -- Language server for Lua. These are the recommended options
      -- when mainly using Lua for Neovim
      lspconfig.lua_ls.setup({
        autostart = false,
        on_init = function(client)
          local path = client.workspace_folders[1].name
          if not vim.loop.fs_stat(path .. "/.luarc.json") and not vim.loop.fs_stat(path .. "/.luarc.jsonc") then
            client.config.settings = vim.tbl_deep_extend("force", client.config.settings, {
              Lua = {
                runtime = { version = "LuaJIT" },
                workspace = {
                  checkThirdParty = false,
                  library = {
                    vim.env.VIMRUNTIME,
                  },
                },
              },
            })

            client.notify("workspace/didChangeConfiguration", { settings = client.config.settings })
          end
        end,
      })

      -- Use LspAttach autocommand to only map the following keys after
      -- the language server attaches to the current buffer
      vim.api.nvim_create_autocmd("LspAttach", {
        group = vim.api.nvim_create_augroup("UserLspConfig", {}),
        callback = function(ev)
          vim.keymap.set("n", "<leader>cgd", vim.lsp.buf.definition, { buffer = ev.buf, desc = "Goto definition" })
          vim.keymap.set("n", "<leader>cK", vim.lsp.buf.hover, { buffer = ev.buf, desc = "Hover help" })
          vim.keymap.set("n", "<leader>crn", vim.lsp.buf.rename, { buffer = ev.buf, desc = "Rename" })
          vim.keymap.set("n", "<leader>cgr", vim.lsp.buf.references, { buffer = ev.buf, desc = "Goto references" })
          vim.keymap.set("n", "<leader>ca", vim.lsp.buf.code_action, { buffer = ev.buf, desc = "Code action" })
        end,
      })
    end,
    keys = {
      -- Because autostart=false above, need to manually start the language server.
      { "<leader>cl", "<cmd>LspStart<CR>", desc = "Start LSP" },
      { "<leader>ce", vim.diagnostic.open_float, desc = "Open diagnostics/errors" },
      { "]d", vim.diagnostic.goto_next, desc = "Next diagnostic/error" },
      { "[d", vim.diagnostic.goto_prev, desc = "Prev diagnostic/error" },
    },
  },
}

mason.nvim

mason.nvim easily installs Language Server Protocols, debuggers, linters, and formatters. Use :Mason to open the interface, and hit i on what you want to install, or g? for more help.

Note

Many language servers use the npm (javascript package manager) to install. This is the case for pyright, for example. You can use ./setup.sh --install-npm to easily create a conda env with npm and add its bin dir to your $PATH.

For Python, try pyright.

For Lua (working on your nvim configs), use lua-language-server (nvim-lspconfig calls this lua-ls).

For Bash, bash-language-server.

For R, you can try r-languageserver, but this needs to be installed within the environment you’re using R (and R itself must be available). It’s not that useful if you want to use it in multiple conda environments. It doesn’t have that many features yet, either.

command	description
:Mason	Open the mason interface
i on an item	Install

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/mason.lua:

-- mason allows convenient installation of LSP clients
return {
  {
    "williamboman/mason.nvim",
    lazy = false,
    config = true,
  },
}

trouble.nvim

trouble.nvim organizes all the LSP diagnostics into a single window. You can use that to navigate the issues found in your code.

This only works if you’ve started the LSP for the buffer with cl (see nvim-lspconfig).

The alternative is using [d and ]d to move between diagnostics (see nvim-lspconfig) but it’s nice to get an overview with this plugin.

command	description
<leader>ct	Toggle trouble.nvim window

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/trouble.lua:

-- trouble splits window to show issues found by LSP
return {
  "folke/trouble.nvim",
  opts = {}, -- for default options, refer to the configuration section for custom setup.
  cmd = "Trouble",
  keys = {
    { "<leader>ct", "<cmd>Trouble diagnostics toggle<cr>", desc = "Diagnostics (Trouble)", },
  },
}

conform

conform runs style formatters on the current buffer.

For example, if black is avaiable it will run that on the code, but in a way that the changes can be undone (in contrast to running black manually on the file, which overwrites it).

command	description
<leader>cf	Run configured formatter on buffer (mnemonic: [c]ode [f]ormat)

You can install formatters via mason.nvim.

For example, for Python I have isort and black; for Lua, stylua; for bash, shfmt. See the config file for how to set this up.

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/conform.lua:

-- conform runs code through a formatter
return {
  {
    "stevearc/conform.nvim",
    event = { "BufWritePre" },
    cmd = { "ConformInfo" },
    keys = {
      {
        "<leader>cf",
        function()
          require("conform").format({ async = true, lsp_fallback = true })
        end,
        mode = "",
        desc = "Run buffer through formatter",
      },
    },
    opts = {
      formatters_by_ft = {
        lua = { "stylua" },
        python = { "isort", "black" },
        bash = { "shfmt" },
        sh = { "shfmt" },
      },
      formatters = {
        shfmt = {
          prepend_args = { "-i", "2" },
        },
        stylua = {
          prepend_args = { "--indent-type", "Spaces", "--indent-width", "2" },
        },
      },
      init = function()
        -- If you want the formatexpr, here is the place to set it
        vim.o.formatexpr = "v:lua.require'conform'.formatexpr()"
      end,
    },
  },
}

lsp-progress.nvim

lsp-progress.nvim adds a status/progress indicator to the lualine (at the bottom of a window) so you know when it’s running.

No additional commands configured.

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/lsp-progress.lua:

-- lsp-progress adds LSP status to the bottom line so you know it's running
return {
  {
    "linrongbin16/lsp-progress.nvim",
    config = true,
  },
}

Interfaces

These plugins add different interfaces unrelated to git (interfaces related to git are described above).

telescope

Telescope provides a floating window with fuzzy-search selection.

Searching and selecting what, you ask? Pretty much anything you hook it up to.

Type in the text box to filter the list. Hit enter to select (and open the selected file in a new buffer). Hit Esc twice to exit.

command	description
<leader>ff	Find files under this directory. Handy alternative to :e
<leader>fg	Search directory for string. This is like using ripgrep, but in vim. Selecting entry takes you right to the line.
<leader>/	Fuzzy find within buffer
<leader>fc	Find code object

Other useful things you can do with Telescope:

• :Telescope highlights to see the currently set highlights for the colorscheme.

• :Telescope builtin to see a picker of all the built-in pickers. Selecting one opens that picker. Very meta. But also very interesting for poking around to see what’s configured.

• :Telescope planets to use a telescope

• :Telescope autocommands, :Telescope commands, :Telescope vim_options, :Telescope man_pages are some other built-in pickers that are interesting to browse through.

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/telescope.lua:

-- telescope provides a pop-up window used for fuzzy-searching and selecting
return {
  {
    "nvim-telescope/telescope.nvim",
    dependencies = {
      "nvim-lua/plenary.nvim",
    },
    cmd = "Telescope",
    keys = {
      {
        "<leader>ff",
        function()
          -- use a previewer that doesn't show each file's contents
          local previewer = require("telescope.themes").get_dropdown({ previewer = false })
          require("telescope.builtin").find_files(previewer)
        end,
        desc = "[f]ind [f]iles",
      },
      { "<leader>fg", "<cmd>Telescope live_grep<cr>", desc = "[f]ind with [g]rep in directory" },
      { "<leader>/", "<cmd>Telescope current_buffer_fuzzy_find<cr>", desc = "Fuzzy find in buffer" },
      { "<leader>fc", "<cmd>Telescope treesitter<CR>", desc = "[f]ind [c]ode object" },
      { "<leader>fr", "<cmd>Telescope oldfiles<CR>", desc = "[f]ind [r]ecently-opened files" },
    },
  },
}

nvim-tree

nvim-tree provides a filesystem tree for browsing.

command	description
<leader>fb	Toggle file browser
- (within browser)	Go up a directory.
Enter (within browser)	Open file or directory, or close directory

The window-switching shortcuts <leader>w and <leader>q (move to windows left and right respectively; see toggleterm) also work.

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/nvim-tree.lua:

-- nvim-tree is a file browser that opens on the left side
return {
  {
    "nvim-tree/nvim-tree.lua",

    -- don't lazy load; otherwise, opening a directory as first buffer doesn't trigger it.
    lazy = false,

    config = true,
    keys = {
      { "<leader>fb", "<cmd>NvimTreeToggle<CR>", desc = "[f]ile [b]rowser toggle" },
    },
  },
}

which-key

which-key displays a popup with possible key bindings of the command you started typing. This is wonderful for discovering commands you didn’t know about, or have forgotten.

The window will appear 1 second after pressing a key. For example, try pressing the leader key (,) and waiting a second to see all the keys you can press after the leader and what the behavior will be.

The length of this delay is configured with vim.o.timeoutlen, e.g. vim.o.timeoutlen=500 for half a sectond). There is no timeout though for registers (") or marks (') or spelling (z= over a word).

You can hit a displayed key to execute the command, or if it’s a multi-key command (typically indicated with a +prefix to show there’s more), then that will take you to the next menu.

Use <Backspace> to back out a menu. In fact, pressing any key, waiting for the menu, and then hitting backspace will give a list of all the default mapped keys in vim.

There is currently no extra configuration. Instead, when a key is mapped (either in lua/mappings.lua or lua/plugins/*.lua), an additional parameter desc = "description of mapping" is included. This allows which-key to show a description. Mappings with no descriptions will still be shown.

-- example mapping using vim.keymap.set, with description
vim.keymap.set('n', '<leader>1', ':bfirst<CR>',
  { desc = "First buffer" })

-- example mapping when inside a plugin spec
{ "plugin/plugin-name",
  keys = {
    { "<leader>1", ":bfirst<CR>", desc = "First buffer" },
  }
}

command	description
any	after 1 second, shows a popup menu
<Backspace>	Goes back a menu
z= (over a word)	Show popup with spelling suggestions, use indicated character to select
'	Show popup with list of marks
"	Show popup with list of registers

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/which-key.lua:

-- which-key pops up a window showing possible keybindings
return {
  {
    "folke/which-key.nvim",

    -- later versions raise errors on conflicting keybindings
    commit = "0539da005b98b02cf730c1d9da82b8e8edb1c2d2",

    lazy = false,
    config = true,

  },
}

aerial

aerial provides a navigation sidebar for quickly moving around code (for example, jumping to functions or classes or methods). For markdown or ReStructured Text, it acts like a table of contents.

command	description
<leader>a	Toggle aerial sidebar
{ and }	Jump to prev or next item (function, snakemake rule, markdown section)

For navigating complex codebases, there are other keys that are automatically mapped, which you can read about in the README for aerial.

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/aerial.lua:

-- navigation with an "aerial view" on the left side
return {
  {
    "stevearc/aerial.nvim",
    dependencies = {
      "nvim-tree/nvim-web-devicons",
      "nvim-treesitter/nvim-treesitter",
    },
    opts = { layout = { default_direction = "prefer_left" } },
    keys = {
      { "{", "<cmd>AerialPrev<CR>", desc = "Prev code symbol" },
      { "}", "<cmd>AerialNext<CR>", desc = "Next code symbol" },
      { "<leader>a", "<cmd>AerialToggle<CR>", desc = "Toggle [a]erial nav" },
    },
  },
}

Visuals

These plugins add various visual enhancements to nvim.

bufferline

bufferline.nvim provides the tabs along the top.

command	description
<leader>b, then type highlighted letter in tab	Switch to buffer

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/bufferline.lua:

-- tabs for buffers along the top
return {
  {
    "akinsho/bufferline.nvim",
    lazy = false,
    keys = {
      { "<leader>b", "<cmd>BufferLinePick<CR>", desc = "Pick buffer" },
    },
    opts = {
      options = {
        diagnostics = "nvim_lsp", -- buffer label will indicate errors
        custom_filter = function(buf_number, buf_numbers) -- don't show tabs for fugitive
          if vim.bo[buf_number].filetype ~= "fugitive" then
            return true
          end
        end,

        -- Disable the filetype icons in tabs
        show_buffer_icons = false,

        -- When using aerial or file tree, shift the tab so it's over the
        -- actual file.
        offsets = {
          {
            filetype = "NvimTree",
            highlight = "Directory",
            separator = true,
          },
          {
            filetype = "aerial",
            highlight = "Directory",
            separator = true,
          },
        },
      },
    },
  },
}

beacon

Beacon provides an animated marker to show where the cursor is.

command	description
n or N after search	Flash beacon at search hit

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/beacon.lua:

-- flash a beacon to show where you are
return {
  {
    "danilamihailov/beacon.nvim",

    -- later versions are lua-only and not as nice to configure
    commit = "5ab668c4123bc51269bf6f0a34828e68c142e764",

    -- don't lazy load -- otherwise, on first KJ you get a double-flash
    lazy = false,
    config = function()

      -- Disable the beacon globally; only the commands below will activate it.
      vim.cmd("let g:beacon_enable=0")

    end,
    keys = {
      { "N", "N:Beacon<CR>", desc = "Prev search hit and flash beacon" },
      { "n", "n:Beacon<CR>", desc = "Next search hit and flash beacon" },
      { "%", "%:Beacon<CR>", desc = "Go to matching bracket and flash beacon" },
      { "*", "*:Beacon<CR>", desc = "Go to next word occurrence and flash beacon" },
    },
  },
}

lualine

lualine provides the status line along the bottom.

No additional commands configured, but see the homepage for all the things you can add to it.

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/lualine.lua:

-- lualine is a status line along the bottom
return {
  {
    "nvim-lualine/lualine.nvim",
    dependencies = {
      "linrongbin16/lsp-progress.nvim",
    },
    opts = {
      options = { theme = "zenburn" },
      sections = {
        lualine_c = { { "filename", path = 2 } },
        -- use lsp-progress plugin to show LSP activity
        lualine_x = {
          function()
            return require("lsp-progress").progress()
          end,
        },
      },
    },
  },
}

indent-blankline

indent-blankline shows vertical lines where there is indentation, and highlights one of these vertical lines to indicate the current scope.

No additional commands configured. However, depending on the font you use, you may want to play around with the symbol used.

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/indent-blankline.lua:

-- indent-blankline shows vertical lines at tabstops
return {
  {
    "lukas-reineke/indent-blankline.nvim",
    lazy = false,
    main = "ibl",
    opts = {
      -- make the character a little less dense
      indent = { char = "┊" },
      exclude = { filetypes = { "markdown", "rst" } },

      -- don't underline beginning and end (I think it adds too much visual
      -- clutter)
      scope = {
        show_start = false,
        show_end = false,
      },
    },
  },
}

render-markdown

render-markdown provides a nicer reading experience for markdown files. This includes bulleted list and checkbox icons, fancy table rendering, colored background for code blocks, and more.

In my testing I found it to be more configurable and performant than the obsidian.nvim equivalent functionality, and in daler/zenburn.nvim I’ve added highlight groups for this plugin.

Some notes about its behavior:

• It uses “conceal” functionality to replace things like - (for bulleted lists) with the unicode •. It hides URLs and only shows the link text (like a website does)

• It’s configured to differentiate between a web link (http) and an internal link (no http) and show an icon for an internal link.

• It has functionality for parsing headlines and making them stand out more in a document. The actual styling of headlines is configured in the colorscheme.

• Code blocks have an icon indicating their language, and the background of code blocks is different from surrounding text.

• Tables are rendered nicely

This plugin is specifically disabled for RMarkdown files, which are typically heavy on the source code, and the background of code chunks can get distracting when entering and exiting insert mode. However, this plugin can be useful when reviewing a long RMarkdown file to focus on the narrative text.

command	description
<leader>rm	Toggle [r]ender[m]arkdown on an [r][m]arkdown file

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/render-markdown.lua:

-- render-markdown nicely renders markdown callouts, tables, heading symbols, and code blocks
return {
  {
    "MeanderingProgrammer/render-markdown.nvim",
    dependencies = { "nvim-treesitter/nvim-treesitter", "nvim-tree/nvim-web-devicons" },
    opts = {
      heading = {

        -- don't indent subsequent headers
        position = "inline",

        -- don't replace ### with icons
        icons = {},
      },
      code = {

        -- don't add a sign column indicator
        sign = false,
      },
      bullet = {

        -- make bullets of all indentations the same
        icons = { "•" },
      },
      link = {

        -- internal links get a symbol in front of them; regular (web) links do not
        custom = {
          web = { pattern = "^http[s]?://", icon = "", highlight = "RenderMarkdownLink" },
          internal = { pattern = ".*", icon = "⛬ ", highlight = "RenderMarkdownLink" },
        },
      },
      checkbox = {
        checked = { icon = "✓" }
      }
    },
  },
}

nvim-colorizer

nvim-colorizer is a high-performance color highlighter. It converts hex codes to their actual colors.

command	description
ColorizerToggle	Toggle colorizing of hex codes

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/nvim-colorizer.lua:

-- nvim-colorizer colors hex codes by their actual color
return {
  {
    "norcalli/nvim-colorizer.lua",
    config = true,
    lazy = true,
    cmd = "ColorizerToggle"
  }, 
}

lush

lush is a helper for adjusting colors in a colorscheme.

Open up a color scheme file, run :Lushify, and you can use <C-a> and <C-x> to increase/decrease values. This gives you live feedback as you’re working. See the homepage linked above for a demo, and zenfade for a colorscheme that used lush (and so supports it well).

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/lush.lua:

-- lush is used for colormaps and designing/modifying colormaps
return {
  priority=1000,
  lazy=false,
  "rktjmp/lush.nvim",
}

Everything else

These plugins don’t have a clear categorization. That doesn’t mean they’re not super helpful though!

vim-commentary

vim-commentary lets you easily toggle comments on lines or blocks of code.

command	description
gc on a visual selection	toggle comment
gcc on a single line	toggle comment

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/vim-commentary.lua:

-- vim-commentary toggles comments
return {
  { "tpope/vim-commentary" },
}

accelerated-jk

accelerated-jk speeds up j and k movements: longer presses will jump more and more lines.

In particular, you might want to tune the acceleration curve depending on your system’s keyboard repeat rate settings – see the config file for an explanation of how to tweak.

command	description
j, k	Keep holding for increasing vertical scroll speed

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/accelerated-jk.lua:

-- speeds up vertical navigation with j and k
return {
  {
    "rhysd/accelerated-jk",
    keys = {
      { "j", "<Plug>(accelerated_jk_gj)" },
      { "k", "<Plug>(accelerated_jk_gk)" },
    },
    config = function()

      -- see :help accelerated_jk_acceleration_table
      vim.cmd("let g:accelerated_jk_acceleration_table = [7, 13, 20, 33, 53, 86]")

    end,
  },
}

blink

blink offers autocomplete.

In this config, I’ve chosen to mimic the bash style of completion, the commands documented here reflect that. I’ve also disabled the menu popping up all the time. There are a lot of ways you can customize this yourself though – see the blink docs.

command	description
<C-space>	Open completion menu
<Tab> (when typing and the cursor is in a word)	Open completion menu
<Tab>, <Shift-Tab> (in menu)	Next, previous entry
Enter (when menu visible)	Select entry
up/down arrow (in menu)	Next, previous entry

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/blink.lua:

-- blink.cmp provides autocompletion

-- Used below to detect if we're in a word or not
local has_words_before = function()
  local col = vim.api.nvim_win_get_cursor(0)[2]
  if col == 0 then
    return false
  end
  local line = vim.api.nvim_get_current_line()
  return line:sub(col, col):match("%s") == nil
end
return {
  "saghen/blink.cmp",
  dependencies = {
    "rafamadriz/friendly-snippets",
    'Kaiser-Yang/blink-cmp-dictionary',
    dependencies = { 'nvim-lua/plenary.nvim' }
  },

  -- using a release tag downloads pre-built binaries
  version = "v1.*",

  opts = {
    keymap = {
      -- At any time, <C-Space> to show menu, arrows to select, Enter to accept.
      preset = 'default',

      -- Additionally, this configures tab-completion to mimic what happens in bash:
      --   * Tab shows selections if cursor is in or immediately after a word, and immediately fills in the first item
      --   * Enter to select.
      --   * Tab scrolls thru suggestions (or Shift-Tab to go back)
      --
      ['<Tab>'] = {
        function(cmp)
          if has_words_before() then
            return cmp.show_and_insert()
          end
        end,
        'snippet_forward',
        'select_next',
        'fallback',
      },
      -- Navigate to the previous suggestion or cancel completion if currently on the first one.
      ['<S-Tab>'] = { 'snippet_backward', 'insert_prev' },
      ['<CR>'] = { 'accept', 'fallback' },
    },
    sources = {
      default = function()
        local result = { 'lsp', 'path', 'snippets', 'buffer' }

        -- turn on dictionary completion in non-code files
        if vim.tbl_contains({ 'markdown', 'text', 'rst' }, vim.bo.filetype) then
          table.insert(result, 'dictionary')
        end
        return result
      end,
      providers = {
        dictionary = {
          module = 'blink-cmp-dictionary',
          name = 'Dict',
          min_keyword_length = 3,
          opts = {
            -- This is the location of the word list on macOS and many Linux distributions
            dictionary_files = { '/usr/share/dict/words' }
          }
        }
      },
    },
    fuzzy = { implementation = "prefer_rust_with_warning" },
    completion = {
      menu = { auto_show = false },
      trigger = { show_in_snippet = false },
    },
  },
  opts_extend = { "sources.default" },
}

treesitter

treesitter is a parsing library that underpins many other plugins.

You install a parser for a language, and it figures out which tokens are functions, classes, variables, modules, etc. Then it’s up to other plugins to do something with that. For example, colorschemes can use that information, or you can select text based on its semantic meaning within the programming language (like easily select an entire function, or the body of a for-loop).

Treesitter is configured to ensure the parsers listed in the config are installed. These will be attempted to be installed automatically, but they do require a C compiler to be available.

• On a Mac, this may need XCode Command Line Tools to be installed.

• A fresh Ubuntu installation will need sudo apt install build-essential

• RHEL/Fedora will need sudo dnf install 'Development Tools' (and may need the EPEL repo enabled).

• Alternatively, if you don’t have root access, you can install compiler packages via conda,

Alternatively, comment out the entire ensure_installed block in ~/.config/nvim/lua/plugins/treesitter.lua; this means you will not have treesitter-enabled syntax highlighting though.

command	description
<leader>cs	Start incremental selection
<Tab> (in incremental selection)	Increase selection by node
<S-Tab> (in incremental selection)	Decrease selection by node

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/treesitter.lua:

-- treesitter provides sophisticated syntax highlighting and code inspection
return {
  {
    "nvim-treesitter/nvim-treesitter",
    version = false,
    build = ":TSUpdate",
    event = { "BufReadPost", "BufNewFile" },
    config = function()
      require("nvim-treesitter.configs").setup({
        highlight = {
          enable = true,
        },
        indent = {
          enable = true,
          -- Let vim-python-pep8-indent handle the python and snakemake indentation;
          -- disable markdown indentation because it prevents bulleted lists from wrapping correctly with `gq`.
          disable = { "markdown" },
        },
        -- --------------------------------------------------------------------
        -- CONFIGURE ADDITIONAL PARSERS HERE
        -- These will be attempted to be installed automatically, but you'll need a C compiler installed.
        ensure_installed = {
          "bash",
          "css",
          "dockerfile",
          "html",
          "json",
          "lua",
          "markdown",
          "markdown_inline",
          "python",
          "vim",
          "vimdoc",
          "yaml",
          "r",
          "rst",
          "snakemake",
        },
        incremental_selection = {
          enable = true,
          keymaps = {
            init_selection = "<leader>cs",
            node_incremental = "<Tab>",
            scope_incremental = false,
            node_decremental = "<S-Tab>",
          },
        },
      })
      vim.cmd("set foldmethod=expr")
      vim.cmd("set foldexpr=nvim_treesitter#foldexpr()")
      vim.cmd("set nofoldenable")

      -- RMarkdown doesn't have a good treesitter parser, but Markdown does
      vim.treesitter.language.register("markdown", "rmd")
      vim.treesitter.language.register("markdown", "rmarkdown")
    end,
  },
}

toggleterm

ToggleTerm lets you easily interact with a terminal within vim.

The greatest benefit of this is that you can send text from a text buffer (Python script, RMarkdown file, etc) over to a terminal. This lets you reproduce an IDE-like environment purely from the terminal. The following commands are custom mappings set in .config/nvim/init.vim that affect the terminal use.

Note

The terminal will jump to insert mode when you switch to it (either using keyboard shortcuts or mouse), but clicking the mouse a second time will enter visual mode, just like in a text buffer. This can get confusing if you’re not expecting it.

You can either click to the text buffer and immediately back in the terminal, or use a or i in the terminal to get back to insert mode.

command	description
<leader>t	Open terminal to the right.
<leader>w	Move to the right window (assumes it’s terminal), and enter insert mode
<leader>q	Move to the text buffer to the left, and enter normal mode
<leader>cd	Send the current RMarkdown code chunk to the terminal, and jump to the next chunk
gxx	Send the current line to the terminal buffer
gx	Send the current selection to the terminal buffer
<leader>k	Render the current RMarkdown file to HTML using knitr::render(). Assumes you have knitr installed and you’re running R in the terminal buffer.
<leader>k	Run the current Python script in IPython. Assumes you’re running IPython in the terminal buffer.

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/toggleterm.lua:

-- toggleterm provides a terminal in vim you can send code to
return {
  {
    "akinsho/toggleterm.nvim",

    -- later versions break sending visual selection with gxx
    commit = "c80844fd52ba76f48fabf83e2b9f9b93273f418d",

    config = function()
      -- tweak the sizes of the new terminal
      require("toggleterm").setup({
        size = function(term)
          if term.direction == "horizontal" then
            return 15
          elseif term.direction == "vertical" then
            return vim.o.columns * 0.5
          end
        end,
      })

      -- Always use insert mode when entering a terminal buffer, even with mouse click.
      -- NOTE: Clicking with a mouse a second time enters visual select mode, just like in a text buffer.
      vim.api.nvim_create_autocmd("BufEnter", {
        pattern = "*",
        callback = function()
          vim.cmd("if &buftype == 'terminal' | startinsert | endif")
        end,
      })

      -- Patch toggleterm to use bracketed paste (special escape codes before
      -- and after the text to be pasted)
      -- https://en.wikipedia.org/wiki/Bracketed-paste
      -- https://cirw.in/blog/bracketed-paste
      vim.api.nvim_create_user_command(
        "ToggleTermSendBracketedPaste",
        function(args)
          require("toggleterm").exec("\x1b[200~", 1)
          require("toggleterm").send_lines_to_terminal("visual_selection", false, args)
          require("toggleterm").exec("\x1b[201~", 1)
        end,
        { range = true, nargs = "?" }
      )
    end,

    keys = {
      { "gxx", ":ToggleTermSendCurrentLine<CR><CR>", desc = "Send current line to terminal" },
      { "gx", ":ToggleTermSendBracketedPaste<CR><CR>", desc = "Send selection to terminal", mode = "x" },

      {
        "<leader>cd",
        "/```{r<CR>NjV/```<CR>k<Esc>:ToggleTermSendBracketedPaste<CR>/```{r<CR>",
        desc = "Send RMarkdown chunk to R",
      },
      -- Immiedately after creating the terminal, disable the cursorline.
      -- This otherwise looks confusing with a single, differently-colored line at
      -- the bottom of the terminal when commands are running.
      { "<leader>t", ":ToggleTerm direction=vertical<CR><C-\\><C-n>:set nocul<CR>i", desc = "New terminal on right" },
    },
  },
}

vim-diff-enhanced

vim-diff-enhanced provides additional diff algorithms that work better on certain kinds of files. If your diffs are not looking right, try changing the algorithm with this plugin:

command	description
:EnhancedDiff <algorithm>	Configure the diff algorithm to use, see below table

The following algorithms are available:

algorithm	description
myers	Default diff algorithm
default	alias for myers
minimal	Like myers, but tries harder to minimize the resulting diff
patience	Patience diff algorithm
histogram	Histogram is similar to patience but slightly faster

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/vim-diff-enhanced.lua:

-- vim-diff-enhanced provides other diff algorithms
return {
  { "chrisbra/vim-diff-enhanced" },
}

vim-table-mode

vim-table-mode provides easy formatting of tables in Markdown and Restructured Text

Nice Markdown and ReStructured Text tables are a pain to format. This plugin makes it easy, by auto-padding table cells and adding the header lines as needed.

• With table mode enabled, || on a new line to start the header.

• Type the header, with column names separated by |.

• On a new line, use || to fill in the header underline.

• On subsequent rows, delimit fields by | (including a leading and trailing |)

• Complete the table with || on a new line.

command	description
:TableModeEnable	Enables table mode, which makes on-the-fly adjustments to table cells as they’re edited
:TableModeDisable	Disables table mode
:Tableize	Creates a markdown or restructured text table based on TSV or CSV text
TableModeRealign	Realigns an existing table, adding padding as necessary

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/vim-table-mode.lua:

-- vim-table-mode lets you easily work with ReST and Markdown tables
return {
  { "dhruvasagar/vim-table-mode" },
}

flash

flash lets you jump around in a buffer with low mental effort.

The trick is to keep your eyes on the destination. Hit s, and type the first 2 letters of where you’re trying to go. This plugin will dim the rest of the buffer, only highlighting instances where those 2 letters occur. It will also add a third letter after it. If you type that third letter, the cursor will jump to that location.

Alternatively, if a treesitter parser is installed for this filetype, you can use S and suffix letters will be shown at different levels of the syntax tree. For example inside a for-loop (i.e. don’t include the for); outside a for-loop (including the for), an entire function, entire Rmd code chunk, etc. In this mode, which is just for selection, you don’t type the two characters you’re looking for. Instead you just type the letter coresponding to level of code that you want to select.

command	description
s in normal mode	jump to match (see details)
S in normal mode	select this treesitter node (see details)
Ctrl-s when searching	Toggle flash during search

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/flash.lua:

-- flash is for search and select, including parts of code parsed by treesitter
return {
  {
    "folke/flash.nvim",
    event = "VeryLazy",
    opts = {},
    keys = {
      {
        "s",
        mode = { "n", "x", "o" },
        function()
          require("flash").jump()
        end,
        desc = "Flash",
      },
      {
        "S",
        mode = { "n", "x", "o" },
        function()
          require("flash").treesitter()
        end,
        desc = "Flash Treesitter",
      },
      {
        "<c-s>",
        mode = { "c" },
        function()
          require("flash").toggle()
        end,
        desc = "Toggle Flash Search",
      },
    },
  },
}

vim-surround

vim-surround lets you easily change surrounding characters.

command	description
cs"'	change surrounding " to '
csw}	add { and } surrounding word
csw{	same, but include a space

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/vim-surround.lua:

-- vim-surround provides tools for easily changing surrounding characters
return {
  { "tpope/vim-surround" },
}

vis

vis provides better behavior on visual blocks.

By default in vim and neovim, when selecting things in visual block mode, operations (substitutions, sorting) operate on the entire line – not just the block, as you might expect. However sometimes you want to edit just the visual block selection, for example when editing TSV files.

command	description
<C-v>, then use :B instead of :	Operates on visual block selection only

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/vis.lua:

-- vis restricts replacement only to visual selection
return {
  { "vim-scripts/vis" },
}

stickybuf.nvim

stickybuf.nvim prevents text buffers from opening up inside a terminal buffer.

Otherwise, you run nvim inside of nvim, and it gets hard to control which instance of nvim is supposed to be interpreting your keystrokes.

No additional commands configured.

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/stickybuf.lua:

-- stickybuf prevents opening buffers in terminal buffer
return {
  {
    "stevearc/stickybuf.nvim",
    opts = {
      get_auto_pin = function(bufnr)
        return require("stickybuf").should_auto_pin(bufnr)
      end,
    },
  },
}

obsidian.nvim

obsidian.nvim is a plugin originally written for working with Obsidian which is a GUI notetaking app (that uses markdown and has vim keybindings). If you’re an Obsidian user, this plugin makes the experience with nvim quite nice.

However, after using it for a bit I really like it for markdown files in general, in combination with the render-markdown plugin.

I’ve been using it to take daily notes.

The mapped commands below use o ([o]bsidian) as a a prefix.

command	description
Enter on any link	Open the link in a browser (if http) or open the file in a new buffer
<leader>od	[o]bsidian [d]ailies: choose or create a daily note
<leader>os	[o]bsidian [s]search for notes with ripgrep
<leader>ot	[o]bsidian [t]ags finds occurrences of #tagname across files in directory
<leader>on	[o]bsidian [n]ew link with a word selected will make a link to that new file

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/obsidian.lua:

-- obsidian provides convenient highlighting for markdown, and obsidian-like notetaking
return {
  {
    "epwalsh/obsidian.nvim",
    version = "*",
    lazy = true,
    ft = "markdown",
    dependencies = { "nvim-lua/plenary.nvim" },
    opts = {

      -- don't add yaml frontmatter automatically to markdown
      disable_frontmatter = true,

      -- disable the icons and highlighting, since this is taken care of by render-markdown plugin
      ui = { enable = false },

      mappings = {
        -- Default <CR> mapping will convert a line into a checkbox if not in
        -- a link or follow it if in a link. This makes it only follow a link.
        ["<CR>"] = {
          action = function()
            if require("obsidian").util.cursor_on_markdown_link(nil, nil, true) then
              return "<cmd>ObsidianFollowLink<CR>"
            end
          end,
          opts = { buffer = true, expr = true },
        },
      },

      -- Default is to add a unique id to the beginning of a note filename;
      -- this disables it
      note_id_func = function(title)
        return title
      end,

      -- Default is "wiki"; this keeps it regular markdown
      preferred_link_style = "markdown",

      -- The following allows obsidian.nvim to work on general markdown files
      -- outside of obsidian vaults.
      workspaces = {
        {
          name = "no-vault",
          path = function()
            return assert(vim.fs.dirname(vim.api.nvim_buf_get_name(0)))
          end,
          overrides = {
            notes_subdir = vim.NIL,
            new_notes_location = "current_dir",
            templates = { folder = vim.NIL },
            disable_frontmatter = true,
            daily_notes = { folder = vim.NIL },
          },
        },
      },

      daily_notes = {
        folder = "daily",
      },

      -- Open URL under cursor in browser (uses `open` for MacOS).
      follow_url_func = function(url)
        vim.inspect(vim.system({ "open", url }))
      end,
    },

    keys = {
      { "<leader>os", "<cmd>ObsidianSearch<cr>", desc = "[o]bsidian [s]earch" },
      { "<leader>on", "<cmd>ObsidianLinkNew<cr>", mode = { "v" }, desc = "[o]bsidian [n]ew link" },
      { "<leader>ol", "<cmd>ObsidianLink<cr>", mode = { "v" }, desc = "[o]bsidian [l]ink to existing" },
      { "<leader>od", "<cmd>ObsidianDailies -999 0<cr>", desc = "[o]bsidian [d]ailies" },
      { "<leader>ot", "<cmd>ObsidianTags<cr>", desc = "[o]bsidian [t]ags" },
    },
  },
}

browsher.nvim

browsher.nvim constructs a URL for GitHub or GitLab that includes line highlighting, based on your visual selection.

Run :Browsher on a line of code, and a URL to that line of code in the upstream repo (GitHub, GitLab) will be copied to your clipboard.

It is currently configured to store the URL on your OS clipboard, which makes it useful for working on remote systems. However, you can comment out the open_cmd config option if you want it to automatically open a browser tab for working on a local machine.

It is also currently configured to optionally read from a file stored outside of a dotfiles repo. This is to support the construction of URLs for private GitHub/GitLab instances. See the config file .config/nvim/lua/plugins/browsher.lua for details.

-- Add the following to ~/.browsher.lua, using your own instance URL
 return {
   ["gitlab.private.com"] = {
     url_template = "%s/-/blob/%s/%s",
     single_line_format = "#L%d",
     multi_line_format = "#L%d-%d",
   },
 }

command	description
Browsher	Store URL on OS clipboard

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/browsher.lua:

-- browsher will copy a link to github/gitlab based on where you are in the code
return {
  'claydugo/browsher.nvim',
  event = "VeryLazy",
  config = function()

    function get_custom_providers(filename)
      -- You may have custom providers that you don't want to publish in
      -- a dotfiles repo. If so, store them in `filename`.
      --
      -- If `filename` doesn't exist, just return an empty table, which will
      -- give the default browsher behavior (i.e., providers for just
      -- github.com and gitlab.com).
      --
      -- For example, the file ~/.browsher.lua might contain the following:
      --
      -- return {
      --   ["gitlab.private.com"] = {
      --     url_template = "%s/-/blob/%s/%s",
      --     single_line_format = "#L%d",
      --     multi_line_format = "#L%d-%d",
      --   },
      -- }
      local f = io.open(filename, "r")
      if f ~= nil and io.close(f) then
        return dofile(filename)
      else
        return {}
      end
    end

    require('browsher').setup({
      -- Copy URL to OS clipboard. If you want a browser to open automatically,
      -- don't specify open_cmd here.
      open_cmd = "+",

      -- Default location of custom providers is ~/.browsher.lua, but it's OK
      -- if it doesn't exist.
      providers = get_custom_providers(vim.env.HOME .. '/.browsher.lua'),
    })
  end
}

indent-o-matic

indent-o-matic is “dumb automatic fast indentation detection”.

To quote more from the home page, “Instead of trying to be smart about detecting an indentation using statistics, it will find the first thing that looks like a standard indentation (tab or 8/4/2 spaces) and assume that’s what the file’s indentation is. This has the advantage of being fast and very often correct while being simple enough that most people will understand what it will do predictably”

When starting a blank file, if it’s not doing what you want when you hit <Tab> then give it a hint: manually use the tab spacing you want and then run :IndentOMatic to re-check.

No additional commands configured.

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/indent-o-matic.lua:

-- indent-o-matic provides automatic detection of indentation settings
return {
  'Darazaki/indent-o-matic'
}

TreeSJ

TreeSJ uses treesitter to split and join nodes. This is one of those things that is a lot easier to show than explain. It converts back and forth between this:

def f(a, b=True, c='default'):
    pass

and this:

def f(
    a,
    b=True,
    c='default',
 ):
     pass

command	description
<leader>j	Toggle split/join

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/treesj.lua:

-- treesj splits and joins nodes
return {
  'Wansmer/treesj',
  lazy = false,
  dependencies = { 'nvim-treesitter/nvim-treesitter' },
  config = function()
    require('treesj').setup({
      use_default_keymaps = false,
    })
    vim.keymap.set('n', '<leader>j', require('treesj').toggle, { desc = "Toggle split/join nodes" })
  end,
}

Colorschemes

If colors look broken then you may be using a terminal like the default Terminal.app on macOS that does not support true color. See nvim has light gray text, colorscheme looks broken for how to fix.

For years I’ve been using the venerable zenburn colorscheme. However, now with additional plugins and highlighting mechansims (especially treesitter), it became important to be able to configure more than what that colorscheme supported.

zenburn.nvim is a reboot of this colorscheme, but there were some parts of it that I wanted to change, or at least have more control over.

My fork of the repo is used here. If you’re interested in tweaking your own colorschemes, I’ve hopefully documented that fork enough to give you an idea of how to modify on your own.

zenfade is what I’ve been working on recently. It’s a warmer and more faded version of zenburn and I like it quite a bit. However, since zenburn has been the default for a while and other people are using it (and are probably used to it), I’m not setting zenfade to be the default, at least not yet.

Changelog for zenburn:

Added:

• 2025-08-14 aa2da9d Merge pull request #61 from daler/2025-08-update

Config

This can be found in .config/nvim/lua/plugins/colorschemes.lua:

-- zenburn is a colorscheme
-- Note that this is a fork, which allows more customization
return {
  {
    "daler/zenburn.nvim",

    -- lazy.nvim recommends using these settings for colorschemes so they load
    -- quickly
    lazy = false,
    priority = 1000,
  },
  -- gruvbox is an example of an alternative colorscheme, here disabled
  {
    "morhetz/gruvbox",
    enabled = false,
    lazy = false,
    priority = 1000,
  },

  -- onedark is another colorscheme, here enabled as a fallback for terminals
  -- with no true-color support like the macOS Terminal.app.
  {
    "joshdick/onedark.vim",
    lazy = false,
    priority = 1000,
  },
  { "daler/zenfade", dependencies = { "rktjmp/lush.nvim" }, lazy = false, priority = 1000 },
}

Changelog for zenfade:

Added:

• Unknown ` <https://github.com/daler/dotfiles/commit/>`__ **

Changelog for colorscheme:

Added:

• Unknown ` <https://github.com/daler/dotfiles/commit/>`__ **

Deprecations

Sometimes there are better plugins for a particular functionality. I’ve kept the documentation here in case you’re using an old version.

Deprecated plugins

vim-rmarkdown

Added:

• Unknown ` <https://github.com/daler/dotfiles/commit/>`__ **

Warning

DEPRECATED:

Removed in favor of treesitter

vim-pandoc

Added:

• Unknown ` <https://github.com/daler/dotfiles/commit/>`__ **

Warning

DEPRECATED:

Removed in favor of treesitter

vim-pandoc-syntax

Added:

• Unknown ` <https://github.com/daler/dotfiles/commit/>`__ **

Warning

DEPRECATED:

Removed in favor of treesitter

vim-tmux-clipboard

Added:

• Unknown ` <https://github.com/daler/dotfiles/commit/>`__ **

Warning

DEPRECATED:

Removed because OSC 52 support in modern terminals/tmux/nvim makes things much easier for handling copy/paste.

leap.nvim

Added:

• Unknown ` <https://github.com/daler/dotfiles/commit/>`__ **

Warning

DEPRECATED:

Removed in favor of the flash plugin, which behaves similarly but also supports treesitter selections

nvim-cmp

Added:

• Unknown ` <https://github.com/daler/dotfiles/commit/>`__ **

Warning

DEPRECATED:

Deprecated in favor of blink, which has similar configurability but does not require it. blink also seems to play nicer with LSP.

vim-sleuth

Added:

• Unknown ` <https://github.com/daler/dotfiles/commit/>`__ **

Warning

DEPRECATED:

vim-sleuth would often get things wrong. indent-o-matic’s simpler algorithm seems to work better.

Notes on tried plugins

• nvim-aider, when paired with neo-tree, was nice to use for adding files to the context. But now:

  • nvim-aider supports nvim-tree too now

  • aider has gotten better at tab-completion, making it easy to add even deeply-nested files

  • nvim-tree’s - to go up a directory was confusing with neo-tree’s “remove from aider context”

  • It’s a better experience to just keep aider running in a different tmux pane/window … no need to consume nnvim screen real estate.

• vim-matchup was nice to have (esp for Python) but it caused errors when trying to edit a buffer where a treesitter parser wasn’t installed.

• jakewvincent/mkdnflow.nvim was nice for hitting <CR> to open a linked file and then <BS> to go back. But I realized I needed to keep the context in my head of where I came from. I prefer having separate buffers open so I can keep track of that (and buffer navigation helps move between them). This plugin is also pretty nice for collapsing sections into fancy headers. But I didn’t consider it sufficiently useful to warrant including and configuring it.

• lukas-reineke/headlines.nvim had nice section headers, and it had backgrounds for code blocks. However that ended up having too much visual noise for my taste.

• nvim-telekasten/telekasten.nvim has nice pickers for tags and files and making links, but it was too opinionated for forcing the “telekasten” style of note-taking.