Bundles

Bundles are optional feature groups. The core works with none enabled.

Enable one by uncommenting its import line in ~/.config/nvim/init.lua, or open :NoetherVim bundles, highlight it, and press <C-y>. A diff prompt shows the exact change before anything is written.

Note

This page is generated from the same annotations :checkhealth noethervim reads. Run that for the state of the bundles you actually have enabled.

Programming languages

c-cpp

Installs clangd on demand and adds the C and C++ treesitter parsers. With the debug bundle also enabled, registers the codelldb adapter and launch configurations for both languages; with the test bundle, runs CTest through neotest, whatever framework the project uses.

{ import = "noethervim.bundles.languages.c-cpp" }

Requires:

• compile_commands.json: clangd resolves includes and flags from it; without one it falls back to guessing and cross-file features degrade
  CMake writes it with CMAKE_EXPORT_COMPILE_COMMANDS=ON; Make users usually generate it with bear
• codelldb (optional): stepping through C and C++, when the debug bundle is also enabled
  :MasonInstall codelldb
• CTest (optional): running tests, when the test bundle is also enabled; ships with CMake
  https://cmake.org/download/ (CMake 3.21 or newer)

go

Go development beyond what gopls alone gives you: generate tests, edit struct tags, implement interfaces, fill structs, and run tests by file or by function from the editor. With the test bundle also enabled, registers the neotest-golang adapter.

{ import = "noethervim.bundles.languages.go" }

Requires:

• Go toolchain: building, testing and every go.nvim command
  https://go.dev/dl/
• Delve (optional): stepping through Go, when the debug bundle is also enabled
  go install github.com/go-delve/delve/cmd/dlv@latest

java

jdtls needs workspace management and jar paths that plain lspconfig cannot supply, so it gets a dedicated client, started per buffer with a workspace directory of its own. With the debug bundle also enabled it loads the Java debug and test jars into the server, which is what makes breakpoints and the JUnit adapter work.

{ import = "noethervim.bundles.languages.java" }

Requires:

• a JDK 21 or newer: jdtls itself runs on 21; the project it indexes may target older
  https://adoptium.net/
• Maven or Gradle (optional): neotest-java builds and runs through the project’s own tool, when the test bundle is also enabled
  whichever your project already uses

latex

VimTeX for compilation, PDF viewing and inverse search, with texlab as the language server. On top of that: snippets, textobjects and a math spell dictionary from noethervim-tex, label and heading pickers, BibTeX citations, and clipboard image paste. Set vim.g.vimtex_view_method to choose a PDF viewer.

{ import = "noethervim.bundles.languages.latex" }

Requires:

• latexmk: compiling documents through VimTeX
  ships with TeX Live and MacTeX
• pdflatex (optional): the engine latexmk drives by default
  ships with TeX Live and MacTeX
• pngpaste (optional): pasting images from the clipboard on macOS
  brew install pngpaste

python

:VenvSelect finds .venv, venv, conda and poetry environments, points the language server at whichever you pick, and exports VIRTUAL_ENV so terminal commands agree; the last choice is remembered and reactivated per project. With the debug bundle also enabled, registers the debugpy adapter against that same environment; with the test bundle, the neotest-python adapter.

{ import = "noethervim.bundles.languages.python" }

Requires:

• Python 3: virtual-environment discovery
  https://www.python.org/downloads/
• debugpy (optional): stepping through Python, when the debug bundle is also enabled
  pip install debugpy, into the environment you debug
• pytest (optional): running Python tests, when the test bundle is also enabled
  pip install pytest, into the environment you test

rust

rustaceanvim goes past plain rust-analyzer with macro expansion, runnables and debuggables, the crate graph, hover actions and structural search-replace. It manages its own LSP client, so no lspconfig entry is needed. With the test bundle also enabled, cargo tests run through neotest; with the debug bundle, it loads debug targets from rust-analyzer once an adapter is installed.

{ import = "noethervim.bundles.languages.rust" }

Requires:

• rust-analyzer: every rustaceanvim feature
  rustup component add rust-analyzer
• Cargo: building and running from the editor
  https://rustup.rs/
• cargo-nextest (optional): running tests, when the test bundle is also enabled; neotest-rust drives nextest rather than cargo test
  cargo install cargo-nextest
• codelldb (optional): stepping through Rust, when the debug bundle is also enabled
  :MasonInstall codelldb, or put lldb-dap on PATH

web-dev

Installs the ts_ls, cssls and eslint language servers on demand, and adds two editing aids: strings convert to template literals as soon as you interpolate, and CSS, hex, rgb, hsl and Tailwind colors preview inline. With the test bundle also enabled, registers the Jest and Vitest adapters.

{ import = "noethervim.bundles.languages.web-dev" }

Requires:

• Node.js: the ts_ls, cssls and eslint servers Mason installs
  https://nodejs.org/
• npm (optional): building vscode-js-debug, when the debug bundle is also enabled
  ships with Node.js

Tools

ai

CodeCompanion, defaulting to Anthropic and also supporting OpenAI, Gemini and Ollama. Keys are read from lua/secrets.lua first, then from the matching environment variable.

{ import = "noethervim.bundles.tools.ai" }

Requires:

• curl: all provider requests go through it
  preinstalled on macOS and most Linux distributions
• A provider API key (optional): CodeCompanion cannot talk to a model without one
  Anthropic by default; OPENAI_API_KEY, GEMINI_API_KEY and Ollama also work

database

vim-dadbod with its interactive UI and SQL completion. Connections are driven by whichever client binary the database needs, so PostgreSQL, MySQL and SQLite each depend on their own command-line tool being installed.

{ import = "noethervim.bundles.tools.database" }

Requires:

• psql (optional): PostgreSQL connections; dadbod shells out to the client
  part of postgresql
• mysql (optional): MySQL and MariaDB connections
  part of mysql-client
• sqlite3 (optional): SQLite connections
  preinstalled on macOS and most Linux distributions

debug

nvim-dap with a multi-panel sidebar and inline virtual text for variable values, plus snacks pickers over commands, breakpoints, variables and frames. The debugger itself is language-agnostic and needs nothing installed; each language bundle registers its own adapter when this bundle is also enabled.

{ import = "noethervim.bundles.tools.debug" }

git

fugitive for :Git commands, blame and diffsplits; vim-flog for the log graph; Fugit2 as a TUI client; diffview for diffs and file history; git-conflict for resolving conflict markers; and a .gitignore generator.

{ import = "noethervim.bundles.tools.git" }

Requires:

• libgit2: fugit2 links against it; the TUI will not load otherwise
  brew install libgit2, or your package manager
• lazygit (optional): the <C-w><C-g> floating terminal
  https://github.com/jesseduffield/lazygit

http

kulala.nvim runs requests written in a .http or .rest file and shows the response in the editor. Covers HTTP, gRPC, GraphQL, WebSocket and streaming, using JetBrains HTTP Client syntax.

{ import = "noethervim.bundles.tools.http" }

Requires:

• curl: kulala sends every request through it
  preinstalled on macOS and most Linux distributions

nvim-dev

:StartupTime benchmarks startup averaged over ten runs, :Luapad gives a live Lua scratchpad, and the vimls server provides completion and diagnostics for legacy .vim files.

{ import = "noethervim.bundles.tools.nvim-dev" }

Requires:

• Node.js (optional): the vimls server Mason installs
  https://nodejs.org/

octo

Review pull requests, read and write issues, and manage gists without leaving the editor, backed by the gh CLI. Pairs with the git bundle for a full GitHub workflow.

{ import = "noethervim.bundles.tools.octo" }

Requires:

• GitHub CLI: every octo command
  https://cli.github.com/, then gh auth login

refactoring

Language-aware extraction: pull a visual selection into its own function, variable or file, and inline variables back again.

{ import = "noethervim.bundles.tools.refactoring" }

repl

iron.nvim keeps a REPL beside the buffer and sends lines, selections or whole files to it. Works with any interpreter; you supply the binary for the language you are using.

{ import = "noethervim.bundles.tools.repl" }

Requires:

• a REPL for your language: iron.nvim drives an external interpreter
  python3, ipython, ghci, node, … whichever you send code to

task-runner

overseer.nvim runs and tracks tasks, compiler.nvim wraps it in a project compiler UI, and <leader>rf and <leader>rp run the current file or the project around it, respecting filetype, project markers and version managers.

{ import = "noethervim.bundles.tools.task-runner" }

Requires:

• your project build tool: overseer and compiler.nvim shell out to it
  make, cargo, latexmk, npm, … whatever the project uses

test

The neotest framework, with results shown beside the code they cover. The runner itself is language-agnostic; each language bundle registers its own adapter when this bundle is also enabled.

{ import = "noethervim.bundles.tools.test" }

Navigation & editing

editing-extras

argmark marks positions inside a function’s argument list so you can add, cycle and clear them without reselecting by hand. comment- box.nvim draws decorative ASCII boxes and dividers around comments.

{ import = "noethervim.bundles.navigation.editing-extras" }

flash

Puts a label on every match, so a jump is one keystroke rather than a count. Augments / and ? as well as f, t, F and T, works operator- pending and visual, and adds a treesitter-scoped variant.

{ import = "noethervim.bundles.navigation.flash" }

harpoon

harpoon2 keeps a short ordered list of files per project, so the handful you are actually working on stay one keystroke apart instead of buried in a fuzzy finder.

{ import = "noethervim.bundles.navigation.harpoon" }

projects

Browses recently used project directories, changes into the one you pick, and immediately opens a file picker scoped to it.

{ import = "noethervim.bundles.navigation.projects" }

yanky

Keeps a rolling history of every yank and delete, so you can paste, realise it was the wrong one, and cycle back through earlier yanks instead of re-yanking or pre-tagging named registers. A fuzzy picker covers the full history.

{ import = "noethervim.bundles.navigation.yanky" }

Writing & notes

markdown

In-editor rendering and concealment, a live browser preview, smart table editing, inline math, and clipboard image paste.

{ import = "noethervim.bundles.writing.markdown" }

Requires:

• Node.js (optional): markdown-preview builds its viewer with it
  https://nodejs.org/
• a terminal with the kitty graphics protocol (optional): inline math rendering by Snacks.image
  kitty, WezTerm, or Ghostty
• pdflatex (optional): Snacks.image typesets each equation before displaying it
  MacTeX or TeX Live; tectonic also works
• ImageMagick (optional): converts the typeset equation into a displayable image
  https://imagemagick.org

neorg

Neorg’s structured note-taking format, with workspaces, linking and folding. Defaults to ~/neorg/. Wiki buffers open under <Leader> rather than the search namespace, because they open and close rather than search.

{ import = "noethervim.bundles.writing.neorg" }

Requires:

• ImageMagick (optional): image.nvim renders inline images through it
  brew install imagemagick, or your package manager
• a terminal with the kitty graphics protocol (optional): displaying those images
  kitty, WezTerm, or Ghostty

obsidian

obsidian.nvim over an existing Obsidian vault: follow and create links, search notes, and manage frontmatter. Set the vault path in lua/user/config.lua. Enable the markdown bundle alongside it for rendering, preview, tables, math and image paste.

{ import = "noethervim.bundles.writing.obsidian" }

Requires:

• a vault path: obsidian.nvim has nothing to open without one
  set it in lua/user/config.lua; see :help noethervim-user-config-data

wrapsearch

Hard-wrapped prose breaks search: a phrase that reads as one line on screen has a newline in the middle, so /brown fox finds nothing when the wrap falls between the two words. This rewrites the pattern so a space also matches a line break and the next line’s indentation. n, N, search offsets and the search register are unaffected, because the rewritten pattern is what runs.

{ import = "noethervim.bundles.writing.wrapsearch" }

zotero

A citation picker that reads your local Zotero database directly, for LaTeX, Markdown, Quarto, Typst, Org and AsciiDoc. Zotero must be running. For LaTeX it complements the latex bundle rather than replacing it.

{ import = "noethervim.bundles.writing.zotero" }

Requires:

• Zotero: the citation picker reads its local database
  https://www.zotero.org/
• sqlite3: sqlite.lua opens the Zotero database through it
  preinstalled on macOS and most Linux distributions

Terminal & environment

better-term

Terminals you can name, number and return to, rather than one anonymous split. Includes a floating terminal, and bindings to toggle the primary terminal or select one by number from both normal and terminal mode.

{ import = "noethervim.bundles.terminal.better-term" }

remote-dev

distant.nvim edits files on a remote host over SSH, with the language server running there rather than locally. The distant binary has to be present at both ends.

{ import = "noethervim.bundles.terminal.remote-dev" }

Requires:

• distant: the local half of the connection
  https://distant.dev/
• distant on the remote host: the remote half of the connection
  ssh host ‘curl -L https://sh.distant.dev | sh’

tmux

<C-h/j/k/l> moves between Neovim splits and tmux panes without caring which is which, and tmux window names follow the Neovim session automatically.

{ import = "noethervim.bundles.terminal.tmux" }

Requires:

• tmux: pane navigation and window naming
  brew install tmux, or your package manager

UI & appearance

colorscheme

Breadth only. The theming machinery lives in core and keeps working without this bundle: SearchLeader+C picks the active scheme and the choice survives restarts, and colorscheme.tweak() carries highlight overrides across switches. All nine are lazy, so only the active one loads.

{ import = "noethervim.bundles.ui.colorscheme" }

eye-candy

Optional visual extras: a scrollbar carrying LSP diagnostic marks, seasonal falling animations, a code block visualizer, and CellularAutomaton for when a file deserves to be dissolved.

{ import = "noethervim.bundles.ui.eye-candy" }

helpview

Renders Neovim’s help files with real formatting, headings and tables via treesitter, instead of plain fixed-width text.

{ import = "noethervim.bundles.ui.helpview" }

minimap

A minimap down the side of the window carrying diagnostics, git signs and search highlights. On by default when the bundle loads; toggle it globally or per window.

{ import = "noethervim.bundles.ui.minimap" }

tableaux

Enabling it puts a scene on the dashboard straight away, picked at random until you choose one with <space>ud. Thirty-one in all, covering number-theoretic processes such as the Sieve of Eratosthenes, Collatz and pi convergents, dynamical systems including Conway’s Game of Life and the Lorenz attractor, topological objects, and contemplative time-of-day scenes.

{ import = "noethervim.bundles.ui.tableaux" }

Practice & utilities

hardtime

Warns on, or outright blocks, repeated hjkl and other low-value motions so you reach for a real motion instead. Starts disabled; run :Hardtime to switch it on.

{ import = "noethervim.bundles.practice.hardtime" }

presentation

presenting.nvim turns a Markdown, Org or AsciiDoc file into a slide deck without leaving the editor. showkeys puts your keypresses on screen, which is what you want when screensharing or recording.

{ import = "noethervim.bundles.practice.presentation" }

training

Three games, each lazy-loaded by its own command: vim-be-good for motions, speedtyper for typing speed, and typr for typing practice with statistics.

{ import = "noethervim.bundles.practice.training" }