Glossary

This glossary provides quick definitions for the key terms, commands, and concepts used throughout this book. Terms are organized alphabetically for easy reference. Each entry includes a pointer to the chapter where the concept is covered in detail.

---

Abbreviation — Auto-expanding text shortcuts. When you type a trigger word, Vim replaces it with a longer string. Unlike mappings, abbreviations are context-aware and only expand after word boundaries. (Chapter 20)

Alternate Buffer — The previously edited buffer. Switch to it with Ctrl+^ (or Ctrl+6). Shown as # in the buffer list. Extremely useful for toggling between two files. (Chapter 5)

Arglist (Argument List) — The list of files passed to Vim at startup (e.g., vim file1.txt file2.txt). A subset of the buffer list, useful for batch operations with :argdo. (Chapter 5)

AST (Abstract Syntax Tree) — A tree representation of source code structure built by Treesitter. Enables language-aware features like smart selection, accurate highlighting, and structural navigation. (Chapter 14)

Autocommand — A command that runs automatically when a specific event occurs (e.g., opening a file, saving, entering a buffer). Defined with autocmd in Vimscript or vim.api.nvim_create_autocmd() in Lua. (Chapters 10, 11, 21)

Black Hole Register ("_) — A special register that discards anything written to it. Use "_d to delete text without overwriting your unnamed register. (Chapter 4)

Breakpoint — A marker on a line of code where the debugger will pause execution, allowing you to inspect variables and program state. (Chapter 19)

Buffer — A file loaded into memory for editing. Buffers persist even when not visible in any window. Every file you open becomes a buffer, and you can list them with :ls. (Chapter 5)

Buffer List — All files currently loaded in memory. View with :ls or :buffers. Each buffer has a number and status indicators showing whether it is active, hidden, or modified. (Chapter 5)

Changelist — A per-buffer list of positions where changes were made. Navigate backward with g; and forward with g,. Useful for jumping back to where you were editing. (Chapter 2)

Clipboard Register ("+) — The register that bridges Vim and your system clipboard. Use "+y to copy to clipboard and "+p to paste from it. (Chapter 4)

Colorscheme — A set of color definitions for syntax highlighting and the editor UI. Set with :colorscheme name. Popular schemes include gruvbox, catppuccin, and tokyonight. (Chapter 10)

Command-line Mode — The mode activated by pressing : in Normal mode. Used for running Ex commands like :w, :s, :g, and :q. (Chapter 2)

conform.nvim — A Neovim plugin for code formatting that integrates with LSP formatters and standalone tools like prettier, black, and stylua. (Chapter 13)

DAP (Debug Adapter Protocol) — A standardized protocol (like LSP but for debugging) that connects Neovim to language-specific debuggers. Implemented via nvim-dap. (Chapter 19)

Diagnostic — An error, warning, hint, or informational message produced by LSP or a linter. Shown in the sign column, as virtual text, or in a floating window. (Chapter 13)

diffview.nvim — A Neovim plugin that provides a tabbed interface for viewing diffs, file history, and merge conflicts side by side. (Chapter 17)

Dot Command (.) — Repeats the last change you made. One of Vim's most powerful features — structure your edits so that . does something useful, and you can repeat complex changes with a single keystroke. (Chapter 2)

Dotfile — Configuration files that live in your home directory, typically starting with a dot (e.g., .vimrc, .config/nvim/init.lua). (Chapter 10)

Ex Command — Commands entered in Command-line mode, prefixed with :. Named after the ex line editor, Vim's ancestor. Examples: :w, :s, :g, :normal. (Chapters 1, 2)

Expression Register ("=) — A special register that evaluates a Vimscript expression and returns the result. In Insert mode, press Ctrl+r = to type an expression (like 2+2) and insert its result. (Chapter 4)

fd — A fast, user-friendly alternative to the find command. Often used as Telescope's file finder backend. (Chapters 18, 23)

Filter Command (!) — Pipes selected text through an external program and replaces it with the output. For example, !}sort sorts lines in the current paragraph. (Chapter 18)

Fold — Collapsing regions of text to hide detail. Methods include indent, syntax, expr, marker, and manual. Toggle with za, open with zo, close with zc. (Chapter 20)

Fugitive (vim-fugitive) — Tim Pope's comprehensive Git wrapper for Vim/Neovim. Provides :Git commands for staging, committing, diffing, blaming, and more. (Chapter 17)

Fuzzy Finding — Searching with partial, approximate matching. Type a few characters and the finder shows all items that match those characters in order, not necessarily consecutively. (Chapter 15)

fzf — A general-purpose command-line fuzzy finder. Can be integrated into Vim/Neovim for file and text searching. (Chapters 15, 23)

gitsigns.nvim — A Neovim plugin that shows Git diff markers in the sign column and provides hunk-level operations (stage, reset, preview, blame). (Chapter 17)

Global Command (:g) — Executes an Ex command on every line matching a pattern. For example, :g/TODO/d deletes all lines containing "TODO". Its inverse, :v, operates on non-matching lines. (Chapter 7)

Hidden Buffer — A buffer that is loaded in memory but not displayed in any window. Allows you to switch away from modified files without saving first (requires set hidden). (Chapter 5)

Hunk — A contiguous block of changed lines in a Git diff. Plugins like gitsigns let you stage, reset, and navigate at the hunk level. (Chapter 17)

Incremental Selection — A Treesitter feature that progressively expands the visual selection to the next larger syntax node (e.g., variable → expression → statement → function). (Chapter 14)

init.lua — Neovim's main configuration file when using Lua. Located at ~/.config/nvim/init.lua. (Chapters 11, 12)

Insert Mode — The mode for typing text. Entered with i, a, o, and variants. Press Esc to return to Normal mode. (Chapter 2)

jq — A command-line JSON processor. Useful with Vim's filter command to format and query JSON data. (Chapter 18)

Jump List — A list of cursor positions maintained across jumps (searches, marks, tag jumps, etc.). Navigate backward with Ctrl+o and forward with Ctrl+i. (Chapter 2)

Language Server — A backend process that provides code intelligence (completion, diagnostics, go-to-definition, rename) for a specific language. Examples: pyright (Python), ts_ls (TypeScript), gopls (Go). (Chapter 13)

lazy.nvim — A modern Neovim plugin manager with automatic lazy-loading, lockfile support, and a visual UI. The most popular plugin manager in the Neovim ecosystem. (Chapter 12)

Leader Key — A configurable prefix key for custom mappings. Set with let mapleader = " " (Vimscript) or vim.g.mapleader = " " (Lua). Commonly set to Space. (Chapter 9)

Linewise — An operation that affects whole lines. Linewise yanks include the newline character and paste on a new line above or below. Contrast with characterwise. (Chapters 3, 4)

LSP (Language Server Protocol) — A standardized protocol that lets editors communicate with language servers for features like autocompletion, diagnostics, go-to-definition, and refactoring. (Chapter 13)

Lua — A lightweight scripting language that Neovim adopted as its first-class configuration and plugin language. Faster and more expressive than Vimscript for complex configurations. (Chapter 11)

LuaSnip — A powerful snippet engine for Neovim written in Lua. Supports dynamic snippets, choice nodes, and VS Code snippet format. (Chapter 16)

Macro — A recorded sequence of keystrokes stored in a register. Record with q{register}, replay with @{register}. Ideal for semi-repetitive editing that search-and-replace can't handle. (Chapter 8)

Mapping — A custom key binding that executes a sequence of commands. Defined with map, nmap, imap, etc. Always use the noremap variants to prevent recursive expansion. (Chapter 9)

Mark — A bookmarked cursor position. Lowercase marks (a-z) are local to a buffer; uppercase marks (A-Z) are global across files. Jump to a mark with ` or '. (Chapter 20)

mason.nvim — A Neovim package manager for installing and managing LSP servers, DAP adapters, linters, and formatters. (Chapters 13, 19)

Modeline — A special comment in a file that sets Vim options for that file only. For example, /* vim: set ts=4 sw=4: */ at the top or bottom of a file. (Chapter 10)

Motion — A command that moves the cursor. Motions can follow operators to define the range of text affected. For example, in dw, w is the motion (forward one word) and d is the operator (delete). (Chapters 2, 3)

$MYVIMRC — An environment variable that points to your main Vim/Neovim configuration file. Use :echo $MYVIMRC to see its path, or :e $MYVIMRC to edit it. (Chapters 2, 10)

Named Register ("a-"z) — User-controlled registers for deliberate storage. Use lowercase to overwrite ("ayy) or uppercase to append ("Ayy). (Chapter 4)

neogit — A Magit-inspired Git interface for Neovim, providing an interactive staging UI similar to Emacs' Magit. (Chapter 17)

netrw — Vim's built-in file explorer and network file reader. Open with :Explore or :Ex. (Chapter 22)

Normal Mode — Vim's default mode where every key is a command. This is where you navigate, delete, copy, paste, and compose editing actions. Press Esc from any mode to return here. (Chapter 2)

Numbered Registers ("0-"9) — Automatically managed registers. "0 always holds the last yank. "1 through "9 hold the last nine deletions, shifting like a queue. (Chapter 4)

nvim-cmp — The most popular autocompletion engine for Neovim. Supports multiple sources (LSP, snippets, buffers, paths) and is highly configurable. (Chapter 16)

nvim-dap — The Debug Adapter Protocol client for Neovim. Provides breakpoints, stepping, variable inspection, and REPL through a standardized debugging interface. (Chapter 19)

nvim-lint — A Neovim plugin for asynchronous linting using external tools (eslint, flake8, shellcheck, etc.). (Chapter 13)

Operator — A command that acts on text defined by a motion or text object. The main operators are d (delete), c (change), y (yank), > (indent), < (unindent), gu (lowercase), and gU (uppercase). (Chapter 3)

Operator-Pending Mode — The brief mode after pressing an operator (like d) where Vim waits for a motion or text object to define the range. (Chapter 9)

Picker — In Telescope, a specific search interface (e.g., find_files, live_grep, buffers, lsp_references). Each picker searches a different source. (Chapter 15)

Plugin — An extension that adds features to Vim/Neovim. Modern Neovim plugins are typically written in Lua and managed with lazy.nvim. (Chapter 12)

Put — Paste text from a register. p puts after the cursor, P puts before. Can also be used as an Ex command: :put a pastes from register a. (Chapter 4)

Quickfix List — A global list of locations (file, line, column, message) populated by commands like :vimgrep, :make, or LSP diagnostics. Navigate with :cn (next) and :cp (previous). (Chapters 5, 6)

Recursive Macro — A macro that calls itself at the end of its recording. It keeps executing until it encounters an error (like end of file), making it useful for processing an unknown number of lines. (Chapter 8)

Register — A named storage location for text. Vim has many register types: unnamed, named, numbered, clipboard, black hole, expression, and more. (Chapter 4)

REPL (Read-Eval-Print Loop) — An interactive environment for evaluating expressions during debugging. nvim-dap provides a REPL for inspecting variables and running code at breakpoints. (Chapter 19)

ripgrep (rg) — A blazingly fast regex search tool. Used by Telescope's live_grep picker and as a standalone command-line tool. (Chapters 18, 23)

Runtimepath — The list of directories Vim searches for configuration files, plugins, syntax files, and other resources. (Chapter 10)

Scratch Buffer — A temporary buffer with no associated file. Useful for jotting notes, testing code, or storing intermediate results. Created with :enew and optionally setlocal buftype=nofile. (Chapter 5)

Search Register ("/) — Stores the last search pattern. Access the search history with q/. The pattern persists across commands and can be reused in substitutions with an empty pattern (:s//replacement/). (Chapter 4)

Session — A saved snapshot of your editing state: open buffers, window layout, cursor positions, and more. Create with :mksession, restore with :source Session.vim or vim -S Session.vim. (Chapter 20)

Shada (Shared Data) — Neovim's persistent data file (replacing Vim's viminfo). Stores command history, search history, marks, and registers across sessions. (Chapter 10)

Snippet — A template with placeholders that expands when triggered. For example, typing fn and pressing Tab might expand to a full function definition. Managed by engines like LuaSnip. (Chapter 16)

Substitution (:s) — The search-and-replace command. Basic syntax: :s/pattern/replacement/flags. Common flags: g (global on line), c (confirm each), i (case-insensitive), n (count only). (Chapter 6)

Tab — In Vim, a tab page is a collection of windows — essentially a workspace or layout. Not like browser tabs. Each tab can have its own arrangement of splits and buffers. (Chapter 5)

Telescope — A highly extensible fuzzy finder for Neovim. Searches files, buffers, text, LSP symbols, Git data, and more through a unified interface with live preview. (Chapter 15)

Terminal Mode — A Neovim-specific mode for interacting with an embedded terminal. Enter with :terminal, exit to Normal mode with Ctrl+\ Ctrl+n. (Chapters 2, 18)

Text Object — A structured chunk of text that Vim understands: words (iw/aw), sentences (is/as), paragraphs (ip/ap), quoted strings (i"/a"), brackets (i(/a(), tags (it/at), and more. Prefixed with i (inner, excluding delimiters) or a (around, including delimiters). (Chapter 3)

toggleterm.nvim — A Neovim plugin for managing multiple terminal windows with easy toggling, custom layouts, and persistent sessions. (Chapter 18)

Treesitter — An incremental parsing library that builds concrete syntax trees for source code. In Neovim, it powers accurate syntax highlighting, smart indentation, code folding, and structural text objects. (Chapter 14)

Undo Tree — Vim's non-linear undo history. Unlike most editors that have a linear undo stack, Vim remembers every change branch. Navigate with :earlier and :later (by time) or u/Ctrl+r (by change). (Chapter 5)

Unnamed Register ("") — The default register. Every d, c, s, x, and y command writes to it automatically. When you paste with p without specifying a register, this is what gets pasted. (Chapter 4)

Very Magic Mode (\v) — A regex flag that makes most special characters work without escaping. Instead of \(foo\|bar\), write \v(foo|bar). (Chapter 6)

Vimscript — Vim's built-in scripting language. Still supported in Neovim but increasingly replaced by Lua for new configurations and plugins. (Chapters 10, 21)

Visual Mode — A mode for selecting text before applying an operator. Three sub-modes: characterwise (v), linewise (V), and blockwise (Ctrl+v). (Chapter 2)

Window — A viewport displaying a buffer. You can split the screen into multiple windows horizontally (:split) or vertically (:vsplit) to view different files or different parts of the same file. (Chapter 5)

WORD — In Vim, a sequence of non-blank characters separated by whitespace. Broader than a word (which stops at punctuation). Navigate WORDs with W, B, E. (Chapters 2, 3)

Yank — Vim's term for copying text. Use y followed by a motion or text object (e.g., yy for a line, yiw for inner word). Yanked text goes to the unnamed register and register "0. (Chapter 4)

\zs / \ze — Regex anchors that define the start (\zs) and end (\ze) of the match within a larger pattern. Text outside these anchors provides context but is not affected by substitution. (Chapter 6)