The Ultimate Vim/Neovim Cheatsheet

# ── Entering Insert Mode ──
i              # insert before cursor
I              # insert at beginning of line (before first non-blank)
a              # insert after cursor
A              # insert at end of line
o              # open new line below, enter insert
O              # open new line above, enter insert
s              # delete character and enter insert (substitute)
S              # delete entire line content and enter insert
gi             # go to last insert position and enter insert
gI             # insert at column 1 of the line
<c-o>          # in insert mode: execute one Normal command, return

# ── Entering Visual Mode ──
v              # character-wise visual
V              # line-wise visual
<c-v>          # block-wise visual (column selection)

# ── Entering Replace Mode ──
R              # enter replace mode (overwrites characters)
gR             # virtual replace mode (handles tabs correctly)

# ── Quick Normal → Command → Normal ──
Q              # enter Ex mode (command-line, deprecated)
gQ             # improved Ex mode
:

# ── Line Navigation ──
gg             # go to first line
G              # go to last line
5gg / 5G       # go to line 5
:{number}      # go to line number (e.g., :42)
{number}G      # go to line number (Normal mode)
:{number}{enter} # same, shorter form

# ── Screen Navigation ──
H              # top of screen (home)
M              # middle of screen
L              # bottom of screen
<c-f>          # scroll down one page (forward)
<c-b>          # scroll up one page (backward)
<c-d>          # scroll down half page (down)
<c-u>          # scroll up half page (up)
<c-e>          # scroll down one line (expose)
<c-y>          # scroll up one line
zt             # scroll so cursor is at top
zz             # scroll so cursor is centered
zb             # scroll so cursor is at bottom

# ── Jump List Navigation ──
<c-o>          # jump backward in jump list
<c-i>          # jump forward in jump list
:jumps         # display jump list
:{number}      # sets a new jump point

# ── Marks ──
m{a-z}        # set local mark (a-z) at cursor
m{A-Z}        # set global mark (file-level) at cursor
'{a-z}        # jump to local mark (line start)
`{a-z}        # jump to local mark (exact position)
:marks        # list all marks

# ── Delete Commands ──
x              # delete character under cursor
X              # delete character before cursor (backspace)
dd             # delete entire line
D              # delete from cursor to end of line (= d$)
dw             # delete to start of next word
d$             # delete to end of line
d0             # delete to beginning of line
d^             # delete to first non-blank
dt)            # delete till closing paren
da(            # delete around parentheses (including parens)
di(            # delete inside parentheses (keeping parens)
dip            # delete inner paragraph
dit            # delete inside HTML tag
3dd            # delete 3 lines
J              # join line below to current (delete newline)
gJ             # join without adding space

# ── Change Commands ──
cc / S         # change entire line (clear and enter insert)
cw             # change word (delete word, enter insert)
C              # change to end of line (= c$)
cb             # change previous word
ct(            # change till opening paren
ci{'"'}           # change inside double quotes
ci(            # change inside parentheses
cit            # change inside HTML/XML tag
cfn            # change text until next 'n'
r{char}        # replace single character with char
R              # enter replace mode (overwrite)
~              # toggle case of character under cursor

# ── Yank (Copy) Commands ──
yy             # yank entire line
yw             # yank word
y$             # yank to end of line
yit            # yank inside HTML tag
yap            # yank paragraph
{'"'}ayy          # yank line into register {'"'}a{'"'}
{'"'}+y           # yank into system clipboard
{'"'}+p           # paste from system clipboard
0{'"'}+y$         # yank entire line to system clipboard

# ── Paste Commands ──
p              # paste after cursor (or below for lines)
P              # paste before cursor (or above for lines)
gp             # paste after, cursor at end of pasted text
gP             # paste before, cursor at end of pasted text
]p             # paste after with auto-indent adjustment
[p             # paste before with auto-indent adjustment
{'"'}0p           # paste from last yank (after {'"'}1 becomes d register)
{'"'}1p           # paste from last delete

# ── Undo / Redo ──
u              # undo last change
<c-r>          # redo last undo
U              # undo all changes on current line
.              # repeat last edit command (!!!)
:earlier 10m   # go back 10 minutes in undo history
:later 5m     # go forward 5 minutes
:undolist      # show undo branches

# ── Basic Search ──
/pattern       # search forward for pattern
?pattern       # search backward for pattern
n              # repeat search forward
N              # repeat search backward
*              # search forward for word under cursor
#              # search backward for word under cursor
g*             # search forward for partial word under cursor
g#             # search backward for partial word under cursor
gd             # go to local declaration of word under cursor
gD             # go to global declaration of word under cursor

# ── Search Options ──
:set hlsearch  # highlight all search matches
:set incsearch # incremental search (highlight as you type)
:set ignorecase # case-insensitive search
:set smartcase  # case-insensitive unless uppercase used
:set nohlsearch # turn off highlighting
:noh           # temporarily clear search highlighting

# ── Search in Selection ──
# 1. Visual select text
# 2. Type : to enter command mode (shows :'<,'>)
# 3. Type /pattern to search within selection

# ── Find & Replace ──
:%s/old/new/           # replace first occurrence on each line
:%s/old/new/g          # replace all occurrences on each line
:%s/old/new/gc         # replace all with confirmation (c = confirm)
:%s/old/new/gI         # case-sensitive (I overrides ignorecase)
:%s/old/new/gn         # just count matches, don't replace
:s/old/new/g           # only on current line
:5,20s/old/new/g       # on lines 5-20
:%s/old/new/gi         # case-insensitive replace
:'<,'>s/old/new/g      # in visual selection
:%s/\&lt;old\&gt;/new/g    # whole word only (word boundaries)
:g/pattern/d           # delete all lines matching pattern
:g!/pattern/d          # delete all lines NOT matching pattern
:v/pattern/d           # same as g!

# ── Sub-replace Special Characters ──
:%s/old/new/ | &       # in replacement: the matched text
:%s/(\w+)/\1_backup/ | \1 # in replacement: capture group 1
:%s/\n/\r/g           # replace \n literal with newline (in regex)
:%s/\t/    /g          # replace tabs with 4 spaces

# ── Multi-line Replace ──
:%s/\n\n/\r/g         # collapse double newlines to single

# ── :g — The Global Command ──
# Syntax: :[range]g/{pattern}/{command}
:g/foo/d               # delete all lines containing "foo"
:g/^$/d               # delete all blank lines
:g/^\s*$/d           # delete all blank/whitespace lines
:g!/foo/d             # delete lines NOT containing "foo"
:v/foo/d              # same as g!/foo/d (invert)

# ── Practical Examples ──
:g/^/s/$/;/           # append semicolon to every line
:g/TODO/s/^/  /       # indent TODO lines
:g/DEBUG/d            # remove all debug lines
:g/{/ .+1,/}/-1 sort  # sort each {...} block

# ── :v (inverse of :g) ──
:v/\/\/.*/d          # delete all comment lines
:v/./d                # delete all empty lines
:v/^\s*\(\/\/\|$\)/d   # delete lines that are empty or comments

# ── Opening Files ──
:e filename         # edit file (open in current buffer)
:edit .             # open file explorer (netrw)
:find file          # find file in path
:Ex / :Lex          # open netrw file explorer
:vsp file           # open in vertical split
:sp file            # open in horizontal split
:tabe file          # open in new tab

# ── Saving ──
:w                  # write (save) current file
:w!                 # force write (override permissions)
:w filename         # save as new file
:saveas filename    # save as and edit new file
:up                 # write only if modified
:sav file           # save as new file, edit the new file
:x                  # write if modified, then close (like :wq)
ZZ                  # same as :x (fast save and quit)

# ── Quitting ──
:q                  # quit (fails if unsaved changes)
:q!                 # quit without saving
:qa                 # quit all
:qa!                # quit all without saving
:wq                 # write and quit
:wqa                # write and quit all
:xa                 # same as :wqa

# ── Buffer Navigation ──
:ls / :buffers      # list all open buffers
:bnext / :bn        # next buffer
:bprev / :bp        # previous buffer
:bfirst / :bf       # first buffer
:blast / :bl        # last buffer
:b 3                # go to buffer #3
:b filename         # go to buffer by name (tab completion)
:bd 3               # close buffer #3
:bd!                # force close current buffer
:%bd                # close all buffers
:%bd|e#             # close all buffers except current
:bw                 # wipe out buffer (also from list)

# ── Quick Buffer Switching ──
<c-^>                # alternate between current and previous buffer
<c-6>               # same as <c-^>

# ── Split Commands ──
<c-w>s              # horizontal split (below)
<c-w>v              # vertical split (right)
:sp file            # horizontal split with file
:vsp file           # vertical split with file
:copen              # open quickfix window (horizontal)
:copen 10           # open with 10 lines height
:lopen              # open location list window

# ── Window Navigation ──
<c-w>h              # move to window left
<c-w>j              # move to window below
<c-w>k              # move to window above
<c-w>l              # move to window right
<c-w>w              # cycle through windows
<c-w>W              # cycle in reverse
<c-w>t              # go to top window
<c-w>b              # go to bottom window
<c-w>p              # go to previous (last accessed) window

# ── Window Resize ──
<c-w>+              # increase height
<c-w>-              # decrease height
<c-w>>              # increase width
<c-w><              # decrease width
<c-w>=              # equalize all windows
:c-w>_              # maximize current window height
<c-w>|              # maximize current window width
:resize 20          # set current window height to 20 lines
:vertical resize 80 # set width to 80 columns
<c-w>5+             # increase height by 5

# ── Window Movement ──
<c-w>H              # move window to far left (full height)
<c-w>J              # move window to bottom (full width)
<c-w>K              # move window to top (full width)
<c-w>L              # move window to far right (full height)
<c-w>T              # move window to new tab

# ── Window Close ──
<c-w>c              # close current window
<c-w>o              # close all other windows (only current remains)
:only               # same as <c-w>o
<c-w>q              # quit window (closes if last, quits vim)
:q                  # quit current window

# ── Tab Commands ──
:tabe file          # open file in new tab
:tabnew             # open empty buffer in new tab
:tabc               # close current tab
:tabo               # close all other tabs
:tabs               # list all tabs
:tabn / gt           # next tab
:tabp / gT           # previous tab
:tabfirst           # go to first tab
:tablast            # go to last tab
:tabmove 0          # move current tab to first position
:tabmove 3          # move to position 3
:tabmove $          # move to last position
:tabmove +1         # move right by one
:tabmove -1         # move left by one
{count}gt            # go to tab number (e.g., 3gt)
:tab split          # copy current window to new tab

# ── Tab-Related Settings ──
:set showtabline=2  # always show tab bar
:set showtabline=1  # show when 2+ tabs
:set showtabline=0  # never show tab bar

-- ── lazy.nvim Bootstrap (auto-install) ──
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
  vim.fn.system({
    "git",
    "clone",
    "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable",
    lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)

require("lazy").setup("plugins")  -- loads lua/plugins/*.lua

-- ── Treesitter: Syntax Highlighting & Code Intelligence ──
return {
  "nvim-treesitter/nvim-treesitter",
  build = ":TSUpdate",
  event = { "BufReadPost", "BufNewFile" },
  config = function()
    require("nvim-treesitter.configs").setup({
      ensure_installed = {
        "lua", "vim", "vimdoc", "python", "javascript",
        "typescript", "json", "yaml", "toml", "html", "css",
        "go", "rust", "c", "cpp", "bash", "markdown",
      },
      highlight = { enable = true },
      indent = { enable = true },
      incremental_selection = {
        enable = true,
        keymaps = {
          init_selection = "gnn",
          node_incremental = "grn",
          scope_incremental = "grc",
          node_decremental = "grm",
        },
      },
      textobjects = {
        select = {
          enable = true,
          lookahead = true,
          keymaps = {
            ["af"] = "@function.outer",
            ["if"] = "@function.inner",
            ["ac"] = "@class.outer",
            ["ic"] = "@class.inner",
          },
        },
      },
    })
  end,
}

-- ── LSP: Language Server Protocol ──
return {
  "neovim/nvim-lspconfig",
  dependencies = {
    "williamboman/mason.nvim",
    "williamboman/mason-lspconfig.nvim",
    "hrsh7th/cmp-nvim-lsp",
    { "j-hui/fidget.nvim", opts = {} },
  },
  event = { "BufReadPre", "BufNewFile" },
  config = function()
    -- Mason: LSP installer
    require("mason").setup()
    require("mason-lspconfig").setup({
      ensure_installed = {
        "lua_ls", "pyright", "ts_ls", "gopls",
        "rust_analyzer", "html", "cssls", "bashls",
      },
    })

    -- LSP keymaps
    vim.api.nvim_create_autocmd("LspAttach", {
      callback = function(args)
        local buf = args.buf
        local map = function(keys, func, desc)
          vim.keymap.set("n", keys, func,
            {'{'} buffer = buf, desc = "LSP: " .. desc {'}'})
        end
        map("gd", vim.lsp.buf.definition, "Go to Definition")
        map("gD", vim.lsp.buf.declaration, "Go to Declaration")
        map("gi", vim.lsp.buf.implementation, "Go to Implementation")
        map("gr", vim.lsp.buf.references, "References")
        map("K", vim.lsp.buf.hover, "Hover Documentation")
        map("<c-k>", vim.lsp.buf.signature_help, "Signature Help")
        map("rn", vim.lsp.buf.rename, "Rename Symbol")
        map("<leader>ca", vim.lsp.buf.code_action, "Code Action")
        map("<leader>fm", function()
          vim.lsp.buf.format({'{'}async = true{'}'})
        end, "Format Buffer")
      end,
    })

    -- Setup servers
    local lspconfig = require("lspconfig")
    local capabilities = require("cmp_nvim_lsp").default_capabilities()

    for _, server in ipairs({'{'} "lua_ls", "pyright", "ts_ls", "gopls" {'}'}) do
      lspconfig[server].setup({'{'} capabilities = capabilities {'}'})
    end
  end,
}

-- ── Telescope: Fuzzy Finder ──
return {
  "nvim-telescope/telescope.nvim",
  tag = "0.1.8",
  dependencies = {'{'} "nvim-lua/plenary.nvim" {'}'},
  keys = {
    {'{'} "<leader>ff", "<cmd>Telescope find_files<cr>", desc = "Find Files" {'}'},
    {'{'} "<leader>fg", "<cmd>Telescope live_grep<cr>",  desc = "Live Grep" {'}'},
    {'{'} "<leader>fb", "<cmd>Telescope buffers<cr>",    desc = "Buffers" {'}'},
    {'{'} "<leader>fh", "<cmd>Telescope help_tags<cr>",  desc = "Help Tags" {'}'},
    {'{'} "<leader>fo", "<cmd>Telescope oldfiles<cr>",   desc = "Recent Files" {'}'},
    {'{'} "<leader>gs", "<cmd>Telescope git_status<cr>", desc = "Git Status" {'}'},
    {'{'} "<leader>fw", "<cmd>Telescope grep_string<cr>",desc = "Word under Cursor" {'}'},
    {'{'} "<leader>fd", "<cmd>Telescope diagnostics<cr>",desc = "Diagnostics" {'}'},
  },
  config = function()
    require("telescope").setup({
      defaults = {'{'}
        file_ignore_patterns = {'{'} "node_modules", ".git" {'}'},
        layout_config = {'{'} prompt_position = "top" {'}'},
        sorting_strategy = "ascending",
      {'}'},
      pickers = {'{'}
        find_files = {'{'} hidden = true {'}'},
        live_grep = {'{'} additional_args = function()
          return {'{'} "--hidden" {'}'}
        end {'}'},
      {'}'},
    })
  end,
}

-- ── Leader Key ──
vim.g.mapleader = " "
vim.g.maplocalleader = " "

-- ── Basic Settings ──
vim.opt.number = true         -- line numbers
vim.opt.relativenumber = true -- relative line numbers
vim.opt.scrolloff = 8         -- keep 8 lines above/below cursor
vim.opt.sidescrolloff = 8     -- keep 8 cols left/right
vim.opt.signcolumn = "yes"    -- always show sign column
vim.opt.cursorline = true     -- highlight current line
vim.opt.colorcolumn = "80"    -- ruler at column 80
vim.opt.expandtab = true      -- spaces instead of tabs
vim.opt.shiftwidth = 2        -- indent width
vim.opt.tabstop = 2           -- tab width
vim.opt.softtabstop = 2       -- backspace over tabs
vim.opt.smartindent = true    -- auto-indent new lines
vim.opt.autoindent = true
vim.opt.breakindent = true    -- wrapped lines maintain indent
vim.opt.wrap = false          -- don't wrap long lines
vim.opt.linebreak = true      -- wrap at word boundaries (if wrap=on)
vim.opt.showbreak = "↪ "      -- wrapped line indicator

-- ── Search Settings ──
vim.opt.hlsearch = true       -- highlight search results
vim.opt.incsearch = true      -- incremental search
vim.opt.ignorecase = true     -- case-insensitive search
vim.opt.smartcase = true      -- case-sensitive if uppercase
vim.opt.inccommand = "split"  -- show live substitute preview

-- ── File Handling ──
vim.opt.hidden = true         -- allow switching unsaved buffers
vim.opt.confirm = true        -- confirm unsaved changes
vim.opt.undofile = true       -- persistent undo
vim.opt.backup = false        -- no backup files
vim.opt.writebackup = false
vim.opt.swapfile = false      -- no swap files
vim.opt.fileencoding = "utf-8"
vim.opt.encoding = "utf-8"

-- ── Performance ──
vim.opt.updatetime = 250      -- faster cursor hold events
vim.opt.timeoutlen = 300      -- mapped sequence timeout
vim.opt.redrawtime = 1500     -- max time for syntax highlighting
vim.opt.lazyredraw = false

-- ── Clipboard ──
vim.opt.clipboard = "unnamedplus" -- system clipboard

-- ── Completion ──
vim.opt.completeopt = "menu,menuone,noselect"

-- ── Netrw (file explorer) ──
vim.g.netrw_banner = 0
vim.g.netrw_liststyle = 3     -- tree style
vim.g.netrw_winsize = 25

-- ── Leader Key Mappings ──
local map = vim.keymap.set
local opts = {'{'} noremap = true, silent = true {'}'}

-- Pane / Window navigation
map("n", "<c-h>", "<c-w>h", opts)
map("n", "<c-j>", "<c-w>j", opts)
map("n", "<c-k>", "<c-w>k", opts)
map("n", "<c-l>", "<c-w>l", opts)

-- Resize windows
map("n", "<c-up>", "<c-w>+", opts)
map("n", "<c-down>", "<c-w>-", opts)
map("n", "<c-left>", "<c-w><", opts)
map("n", "<c-right>", "<c-w>>", opts)

-- Buffer navigation
map("n", "<leader>bn", ":bnext<cr>", opts)
map("n", "<leader>bp", ":bprev<cr>", opts)
map("n", "<leader>bd", ":bdelete<cr>", opts)

-- Split management
map("n", "<leader>sv", ":vsplit<cr>", opts)
map("n", "<leader>sh", ":split<cr>", opts)
map("n", "<leader>sc", ":close<cr>", opts)

-- Clear search highlight
map("n", "<esc>", ":noh<cr>", opts)

-- Move selected lines (Visual mode)
map("v", "J", ":m '>+1<cr>gv=gv", opts)
map("v", "K", ":m '<-2<cr>gv=gv", opts)

-- Stay in indent mode
map("v", "<", "<gv", opts)
map("v", ">", ">gv", opts)

-- Paste without replacing register
map("x", "<leader>p", '"_dP', opts)

-- Delete to void register
map("n", "<leader>d", '"_d', opts)
map("v", "<leader>d", '"_d', opts)

-- Yank to end of line
map("n", "Y", "y$", opts)

-- J join lines with cursor at join point (not end)
-- Tip: Use gi to jump back to last edit position after J
map("n", "J", "J", opts)

-- Center cursor on half-page scroll
map("n", "<c-d>", "<c-d>zz", opts)
map("n", "<c-u>", "<c-u>zz", opts)

~/.config/nvim/
├── init.lua                  # Entry point: require("config")
├── lua/
│   ├── config/
│   │   ├── options.lua       # vim.opt settings
│   │   ├── keymaps.lua       # key mappings
│   │   ├── autocmds.lua      # autocommands
│   │   └── lazy.lua          # lazy.nvim bootstrap
│   └── plugins/
│       ├── treesitter.lua    # treesitter config
│       ├── lsp.lua           # LSP + Mason config
│       ├── cmp.lua           # completion config
│       ├── telescope.lua     # fuzzy finder config
│       ├── gitsigns.lua      # git signs config
│       ├── lualine.lua       # statusline config
│       └── nvim-tree.lua     # file explorer config
└── stylua.toml               # Lua formatter config