Neovim / LazyVim Cheatsheet

I've been a long-time Vim user, but only in the past couple years was I introduced to Neovim. I was really impressed by it overall, but I really ended up missing the comfort of all the settings and everything that I had in place with my standard Vim setup.

As a part of my more current workflow, I thought I'd give Neovim another shot and give it a little bit more time to get used to it. To help me out, I worked with Claude to put together a cheat sheet with a bunch of shortcuts and commands that I'd likely reach for on a day-to-day basis.

Note this is meant to serve as a reference for someone who already knows Vim. Core Vim motions, operators, text objects, registers, and Ex commands all work the same as they do in Vim. This document focuses on what LazyVim adds or changes on top of stock Vim, plus the Neovim-specific pieces that don't exist in Vim 8.

Leader key is <Space>. Local leader is \. See Notation for how key combinations are written throughout.

Version note: LazyVim moves fast. Two things have shifted recently and you may see either set depending on when your config was scaffolded:

• Picker: older setups use telescope.nvim, newer ones use snacks.picker. The keymaps below are nearly identical either way.
• File explorer: older setups use neo-tree, newer ones use snacks.explorer. Same <leader>e binding.
• Surround: the mini.surround prefix changed from gz to gs. If gsa does nothing, try gza.

The authoritative answer for your install is always <leader>sk (search keymaps) — see Discoverability.

Table of Contents

1. Notation: leaders and modifiers
2. Discoverability
3. LazyVim's changes to core Vim behavior
4. Files, buffers, and pickers
5. Search
6. File explorer
7. Windows, splits, and tabs
8. LSP: navigation and code actions
9. Diagnostics and Trouble
10. Completion and snippets
11. Git
12. Terminal
13. Motion: flash.nvim
14. Surround, comments, and text objects
15. Toggles
16. Sessions and project management
17. Plugin and tooling management
18. Debugging and testing
19. Neovim features Vim doesn't have
20. Web dev specifics
21. Config layout
22. Troubleshooting
23. Getting back up to speed

Notation: leaders and modifiers

Modifiers

Other special keys you'll see: <CR> (Enter), <Esc>, <Tab>, <BS> (Backspace), <Space>, <Up/Down/Left/Right>, <F1>–<F12>, <C-_> (see below).

Combinations stack: <C-S-p> is Ctrl+Shift+P. A sequence without brackets is pressed in order — <leader>ff means Space, then f, then f.

<D- (Command) does not work in a terminal. Terminals cannot transmit the Command key, so it's only available in GUI clients like Neovide, VimR, and goneovim. Running inside a terminal multiplexer, treat Command as nonexistent — every Cmd+P / Cmd+Shift+F / Cmd+S reflex needs a new home (<leader><space>, <leader>/, <C-s>).

<S- with letters is redundant. Shift+letter is the uppercase letter, so <S-h> and H are the same mapping — LazyVim writes it verbosely for symmetry with <S-l>. Shift notation is only strictly necessary for non-letter keys: <S-Tab>, <S-CR>, <S-F5>, <S-Insert>.

Terminal modifier limits. Standard terminals collapse many Ctrl and Ctrl+Shift combinations into identical byte sequences, which is why almost no config binds <C-S-x>. If you want full modifier fidelity, use a terminal supporting the kitty keyboard protocol — Kitty, WezTerm, Ghostty, or recent Alacritty.

Two specific casualties worth knowing:

• <C-/> is sent as <C-_> by many terminals. That's why the terminal toggle is listed as both.
• <C-s> is historically the XOFF flow-control signal and may freeze your terminal until you press <C-q>. Fix by adding stty -ixon to your shell rc.

Leader vs. local leader

<leader> is for global mappings, active in every buffer. <localleader> is for buffer-local, filetype-specific mappings — the convention exists so a LaTeX or Org plugin can claim a dozen keys without colliding with your global namespace.

LazyVim core defines essentially zero <localleader> mappings. It sets the variable so plugins expecting it behave correctly. You'll only encounter it via plugins like vimtex, quarto, neorg, molten, or iron.nvim. For PHP/JS work you may never press it.

Note that stock Vim and Neovim default both leaders to \. LazyVim moves leader to Space and leaves localleader at the vanilla default — so if you never set mapleader in your .vimrc, your old Vim leader is now your local leader.

Checking your values:

:lua print(vim.inspect(vim.g.mapleader))
:lua print(vim.inspect(vim.g.maplocalleader))

Changing them — ordering is critical. Leader is resolved at mapping-definition time, not at press time. Set it after plugins load and existing mappings keep the old leader while new ones use the new value, producing a half-broken config that's genuinely hard to diagnose. In LazyVim the correct place is lua/config/options.lua, which loads before plugin setup:

-- lua/config/options.lua
vim.g.mapleader = " "
vim.g.maplocalleader = ","

("\\" in Lua is an escaped backslash — a single \ character.)

Discoverability (the most important section)

Do not memorize this document. Memorize these four things and let the editor teach you the rest.

Mnemonic scheme. LazyVim's prefixes are consistent, which is what makes them learnable:

Learn the prefix, then use which-key for the second key. That's the whole system.

LazyVim's changes to core Vim behavior

These are the ones that will feel "wrong" coming from stock Vim. Worth reading carefully.

Things that are unchanged and worth remembering: all operators (d, c, y, >, =, gu, gU, g~), all text objects (iw, ap, i", it, ab), all motions (f, t, %, {, }, (, ), [[, ]]), marks, macros (q, @), registers ("a), . repeat, Ctrl-o/Ctrl-i jumplist, g;/g, changelist.

Files, buffers, and pickers

Finding files

Root dir vs cwd: LazyVim auto-detects a "root" per buffer using LSP workspace, then .git, then falls back to cwd. In a monorepo or a multi-plugin WordPress project this matters a lot. Uppercase variants (<leader>fF, <leader>sW) generally mean "use cwd instead of root."

Buffers

Inside a picker

Search

Grep syntax tip: the live grep uses ripgrep. You can pass rg flags inline in most setups by typing your pattern, then -- -g '*.php' to restrict to a glob. Check ? inside the picker for your version.

File explorer

<leader>e toggles the explorer at the project root. <leader>E opens at cwd. (In neo-tree setups, <leader>fe / <leader>fE.)

Neo-tree also has source tabs: < and > cycle between filesystem, buffers, and git status views. The git status view is a fast way to see and stage changed files.

Windows, splits, and tabs

Tabs (Vim tabs = window layouts, not "tabs" in the VS Code sense — your buffers are the VS Code tabs):

LSP: navigation and code actions

This is the part that replaces most of what you used VS Code for. <leader>cl shows LSP info for the current buffer.

Formatting control: <leader>uf toggles autoformat globally, <leader>uF toggles it for the current buffer only. Very useful when you open a legacy file you don't want to reformat entirely.

Diagnostics and Trouble

Completion and snippets

LazyVim uses blink.cmp (newer) or nvim-cmp (older). Bindings are close to identical.

Native Vim completion still works and is sometimes faster: <C-x><C-f> for file paths, <C-x><C-l> for whole lines, <C-n> for buffer words.

Git

Gitsigns (in-buffer hunks)

Terminal

In a Herd session specifically: you may want to skip the built-in terminal entirely and let the multiplexer own your panes — one pane for Neovim, one for the shell, one for an agent. If you go that route, be aware <C-/>, <C-h/j/k/l>, and <S-h>/<S-l> are the bindings most likely to collide with a multiplexer prefix. Check for conflicts early; remapping the multiplexer prefix is usually easier than remapping LazyVim.

Motion: flash.nvim

This is the biggest genuinely-new motion capability versus stock Vim. It replaces f/t hunting and EasyMotion.

s and S work as operator targets: ds<char><label> deletes to that point. Very fast once it's muscle memory.

Note: s in stock Vim is "substitute character" (= cl). LazyVim rebinds it. Use cl if you miss it.

Surround, comments, and text objects

mini.surround

Prefix is gs in current LazyVim, gz in older versions.

For HTML/JSX/Blade, gsat adds a tag; gsdt deletes the surrounding tag.

Comments

Treesitter text objects

These make code manipulation far better than Vim's paragraph-based guessing.

Combine as usual: daf deletes a function, vic selects a class body, cia changes an argument.

mini.ai extras

a/i also work with:

• aq / iq — any quote
• ab / ib — any bracket
• at / it — a tag
• an / in + object — the next occurrence (cin( changes inside the next parens)
• al / il + object — the last occurrence

Toggles

Everything under <leader>u toggles a UI or behavior setting. Press <leader>u and read the which-key menu.

Sessions and project management

Sessions restore your open buffers and window layout per directory. Combined with the projects picker, this is your equivalent of VS Code workspaces.

Plugin and tooling management

Inside Lazy: I install, U update, X clean, S sync, L log, ? help, q quit. Inside Mason: i install, X uninstall, U update, / filter, g? help.

:LazyExtras is the single most useful command for a returning user. Rather than hand-configuring an LSP, enable lang.php, lang.typescript, lang.tailwind, lang.json, lang.yaml, etc., and LazyVim wires up the server, formatter, linter, and Treesitter parser for you.

Debugging and testing

Requires the dap.core and test.core extras (:LazyExtras).

DAP

Neotest

Neovim features Vim doesn't have

Worth knowing these exist, since they're the reason the ecosystem works the way it does.

Useful Ex commands: :LspInfo, :LspRestart, :ConformInfo (formatters), :TSInstallInfo, :messages, :Inspect, :InspectTree.

Web dev specifics

Relevant to PHP/WordPress and modern JS work:

• Enable via :LazyExtras: lang.php, lang.typescript, lang.tailwind, lang.json, lang.yaml, lang.markdown, lang.docker, lang.git, lang.sql.
• PHP ships with intelephense (needs a license key for the premium features) or phpactor. Formatting via pint or php-cs-fixer; add phpcs/phpcbf through Mason if you're on WordPress Coding Standards.
• Emmet: emmet-language-server is available via Mason and works in completion — type div.wrapper>ul>li*3 and confirm.
• Tailwind: the lang.tailwind extra gives you color swatches in completion and class sorting.
• ts_ls / vtsls for TypeScript, with <leader>co for organize imports and <leader>cM for missing imports.
• Auto tag closing and matchup (% on HTML tags, if/endif, foreach/endforeach) come from Treesitter extras.
• gx opens the URL under the cursor in your browser.

Config layout

Your customizations go in ~/.config/nvim/lua/config/ and ~/.config/nvim/lua/plugins/. Never edit the LazyVim plugin itself.

~/.config/nvim/
├── init.lua                 -- bootstraps lazy.nvim, loads config
├── lua/
│   ├── config/
│   │   ├── autocmds.lua     -- your autocommands (added to LazyVim's)
│   │   ├── keymaps.lua      -- your keymaps (added to LazyVim's)
│   │   ├── lazy.lua         -- lazy.nvim setup + which extras load
│   │   └── options.lua      -- your options (added to LazyVim's)
│   └── plugins/
│       └── *.lua            -- one file per plugin/override, auto-loaded
└── lazyvim.json             -- tracks which extras you've enabled

Overriding a LazyVim keymap — you must delete it first if you want the key free:

-- lua/config/keymaps.lua
vim.keymap.del("n", "<S-h>")
vim.keymap.set("n", "<S-h>", "H", { desc = "Top of screen" })

Overriding a plugin's options — create a file in lua/plugins/:

-- lua/plugins/gitsigns.lua
return {
  "lewis6991/gitsigns.nvim",
  opts = {
    current_line_blame = true,
  },
}

Disabling a plugin:

return { "folke/flash.nvim", enabled = false }

Troubleshooting

Getting back up to speed

A realistic ramp for someone who is already very comfortable with Vim:

Week 1 — prefixes only. Learn <leader><space> (find file), <leader>/ (grep), <leader>, (buffers), <leader>e (explorer), <leader>gg (lazygit). Use which-key for everything else. Don't try to memorize; just pause after <leader> and read.

Week 2 — LSP. Force yourself to use gd, <C-o>, gr, K, <leader>ca, <leader>cr, ]d/[d. These are the ones that make Neovim competitive with VS Code, and they're only five or six keys.

Week 3 — Treesitter text objects and flash. daf, cia, vic, then s for jumping. This is where you exceed what VS Code can do.

Week 4 — customize. Now that you know what annoys you, edit lua/config/keymaps.lua. Not before.

Supporting resources: :Tutor inside Neovim for the basics refresher, :help lazyvim for the plugin's own docs, and <leader>sk whenever you're stuck. The LazyVim site (lazyvim.org) has a keymaps page generated from the same source as this document's contents, so it's a good cross-check against your specific version.

One habit that pays off disproportionately: when you catch yourself doing something inefficiently, stop and run <leader>sk with a guess at the word. LazyVim's descriptions are written in plain English, so searching "rename" or "stage" or "symbol" usually finds it in one try.

---

Category: Dev Tools

Tags: vim, neovim, cheatsheets