# Vim motions i actually use vimmers love giving you a list of 200 keybindings. most of them you'll never use. these are the ones that actually live in my muscle memory. ## navigation ### basic movement ``` h j k l — left, down, up, right w b — forward/backward by word 0 _ $ — start of line, first char, end of line gg G — top of file, bottom of file :[line] — jump to line number ``` ### half-page jumps ``` ctrl+d — half page down ctrl+u — half page up ``` when you don't have a specific target, these are faster than counting lines. ### paragraph jumping ``` { } — up/down by paragraph ``` paragraph = block of text separated by blank lines. works surprisingly well in code. ### relative line jumps ``` [count]j — down 8 lines (8j) [count]k — up 5 lines (5k) ``` turn on `relativenumber`. the line numbers tell you exactly how many lines to jump. no mental math. tree-sitter context makes this even better — `18k` lands you on the function definition directly. ## horizontal motion the real speed comes from moving on the same line without reaching for `w` or `b`. ``` f[char] — jump forward TO the character t[char] — jump forward BEFORE the character F[char] — jump backward TO the character T[char] — jump backward BEFORE the character ; — repeat last f/t forward , — repeat last f/t backward ``` example: you're on a line and need to delete everything up to a closing quote. `dt"` — delete till `"`. done. ## the operator + motion language this is the thing that makes vim actually click. every command is: ``` [operator] + [count] + [motion] ``` the operators you'll use daily: ``` d — delete c — change (delete then enter insert mode) y — yank (copy) v — visual select ``` now combine them with motions: ### delete + motion ``` d$ — delete from cursor to end of line d0 — delete from cursor to start of line dw — delete one word forward db — delete one word backward d3w — delete 3 words forward d2j — delete current line + 2 below dt) — delete until before ) df) — delete up to and including ) d/foo — delete until first occurrence of "foo" dap — delete around paragraph di{ — delete inside curly braces da{ — delete a block including braces ``` ### change + motion ``` cw — change one word forward c3w — change 3 words forward ciw — change inner word (works anywhere in the word) ci" — change inside double quotes ci( — change inside parentheses ca( — change around parentheses (removes them too) ct, — change until before comma cf, — change up to and including comma c$ — change from cursor to end of line C — same as c$ (built-in shortcut) cc — change entire line ``` ### yank + motion ``` yw — yank one word y3w — yank 3 words yt" — yank until before " yf" — yank up to and including " yi( — yank inside parentheses ya{ — yank around braces (includes the braces) yap — yank around paragraph y$ — yank from cursor to end of line yy — yank entire line ``` once you get this pattern you stop memorizing commands and start composing them. `d` is delete. `c` is change. `y` is yank. then you just pick the motion. the same motions work with all three operators — `dw` deletes a word, `cw` changes it, `yw` copies it. same motion, different outcome. ## text objects ``` iw — inner word i( i{ i[ — inside parentheses, braces, brackets i' i" — inside quotes a( a{ a[ — around (includes the brackets) ip ap — inner/around paragraph ``` combine with operators: `ci(` changes everything inside parentheses. `da{` deletes the whole block with braces. `yap` yanks the whole paragraph. the trick: `vi{` then escape jumps you to the bottom of the block. select inside braces, exit visual — cursor is at the end of the function. way faster than scrolling. ## editing ``` dd — delete line D — delete from cursor to end of line yy — yank (copy) line p — paste after cursor u — undo ctrl+r — redo == — auto-indent line =ap — auto-indent paragraph ``` ## modes ``` i — insert before cursor a — insert after cursor I — insert at start of line A — insert at end of line o — open new line below O — open new line above v — visual mode (char selection) V — visual line mode ctrl+v — visual block mode esc / ctrl+c — back to normal mode ``` ## replace without clobbering your register ``` leader + p — paste without overwriting clipboard ``` in visual mode, this deletes the selection into the void register and pastes. your yanked text stays untouched. i remapped this and never looked back. ## search ``` /[pattern] — forward search ?[pattern] — backward search n N — next / previous match * — search word under cursor forward # — search word under cursor backward ``` ## increments ``` ctrl+a — increment number under cursor ctrl+x — decrement ``` works on dates, hex, everything. `gaa` increments all numbers in a selection if you need to renumber a list. ## bracket hopping ``` % — jump between matching bracket ``` cursor on `{`, press `%`, you're on `}`. works for `()`, `[]`, `{}`. ## netrw / file tree ``` :Lex — open file explorer vim . — open current directory ``` no plugin needed. netrw ships with vim and it's fine. but honestly i just use a fuzzy finder most of the time. --- that's it. not 200 commands. maybe 40 that actually matter. learn these and you'll stop reaching for the mouse. the rest is just showing off.