Neovim Guide — Advanced Features

🆕 Registers Normal / Visual

Registers are named storage slots for text. Access them with " followed by the register name before an operator.

Named Registers (a–z)

`"ayy`	Yank line into register a
`"ap`	Paste from register a
`"Ayy`	Append yank to register A

Special Registers

`"0`	Last yank
`"1–"9`	Delete history
`""`	Default (unnamed)
`"+`	System clipboard
`"*`	Primary selection (X11)
`"/`	Last search pattern
`".`	Last inserted text
`"%`	Current filename
`":`	Last Ex command

Using in Insert / Command Mode

`Ctrl`+`r a`	Paste register a while in Insert
`Ctrl`+`r +`	Paste clipboard in Insert
`:reg`	List all registers
`:reg a b`	Show registers a and b

Tip: Always use "0p to paste from your last yank, so deletes don't clobber it.

🏵 Marks Normal

Marks let you bookmark locations in files and jump back instantly.

Setting & Jumping

`m{a-z}`	Set local mark (per file)
`m{A-Z}`	Set global mark (cross-file)
`'{mark}`	Jump to mark line
`{mark}	Jump to exact mark position
`''`	Jump to last jump location
`.	Jump to last edit location
`[ / `]	Start/end of last change
`< / `>	Start/end of last visual
`:marks`	List all marks
`:delmarks a`	Delete mark a

Jump List & Change List

`Ctrl`+`o`	Go to older jump position
`Ctrl`+`i`	Go to newer jump position
`g;`	Go to older change position
`g,`	Go to newer change position
`:jumps`	Show jump list
`:changes`	Show change list

▶ Macros Normal

Record a sequence of commands and replay them. Essential for repetitive bulk edits.

Recording & Playing

`q{a-z}`	Start recording into register
`q`	Stop recording
`@{a-z}`	Play macro
`@@`	Replay last macro
`5@a`	Play macro a 5 times
`:norm @a`	Run macro on each line

Workflow: Position cursor at start → qa → make your edits → q → move to next item → @a. Use 100@a to run it 100 times (it stops at errors).

Editing a Macro

`:let @a='`	Edit macro a directly
`"ap`	Paste macro to edit in buffer
`"ayy`	Yank edited macro back

▩ Text Objects Operator + Object

Text objects let you operate on semantic units: words, sentences, blocks, and delimiters. Used as the motion part of an operator.

Inner (i) vs Around (a)

i = content only | a = content + surrounding delimiters/whitespace

`iw` / `aw`	Word
`is` / `as`	Sentence
`ip` / `ap`	Paragraph
`i"` / `a"`	Double-quoted string
`i'` / `a'`	Single-quoted string
i` / a`	Backtick string
`i(` / `a(`	Parentheses
`i[` / `a[`	Brackets
`i{` / `a{`	Braces
`it` / `at`	HTML/XML tag

Examples:
ci" — change content inside quotes
da{ — delete block including braces
yip — yank current paragraph
vat — visually select around HTML tag
2i( — operate on 2nd level parens

Neovim Treesitter Text Objects plugin

With nvim-treesitter-textobjects, you get syntax-aware objects:

`if`	Inner function body
`af`	Around function (with signature)
`ic`	Inner class
`ia`	Inner argument/parameter

▩ Windows & Tabs Normal

Splits

`:sp`	Horizontal split
`:vsp`	Vertical split
`Ctrl`+`w s`	Horizontal split
`Ctrl`+`w v`	Vertical split
`Ctrl`+`w h/j/k/l`	Navigate splits
`Ctrl`+`w H/J/K/L`	Move split direction
`Ctrl`+`w =`	Equalize split sizes
`Ctrl`+`w _`	Maximize height
`Ctrl`+`w \|`	Maximize width
`Ctrl`+`w q`	Close split
`Ctrl`+`w o`	Close all other splits

Tabs

`:tabnew`	Open new tab
`:tabn`	Next tab
`:tabp`	Previous tab
`gt`	Next tab (normal mode)
`gT`	Previous tab
`:tabclose`	Close current tab
`:tabonly`	Close all other tabs
`:tabs`	List all tabs

Buffers

`:ls`	List buffers
`:bn` / `:bp`	Next/prev buffer
`:b{n}`	Go to buffer n
`:bd`	Delete (close) buffer

⚡ LSP (Language Server Protocol) neovim native

Neovim has built-in LSP support since 0.5. Configure with vim.lsp APIs or use nvim-lspconfig for easy setup.

Default LSP Keymaps

`gd`	Go to definition
`gD`	Go to declaration
`gr`	Show references
`gi`	Go to implementation
`K`	Hover documentation
`Ctrl`+`k`	Signature help
`<leader>rn`	Rename symbol
`<leader>ca`	Code actions
`[d` / `]d`	Prev/next diagnostic
`<leader>e`	Show diagnostic float
`:LspInfo`	Show active LSP clients

Minimal nvim-lspconfig Setup (Lua)

local lspconfig = require('lspconfig')

-- TypeScript / JavaScript
lspconfig.ts_ls.setup({})

-- Python
lspconfig.pyright.setup({})

-- Rust
lspconfig.rust_analyzer.setup({})

-- Lua (for Neovim config)
lspconfig.lua_ls.setup({
  settings = {
    Lua = { globals = { 'vim' } }
  }
})

Tip: Use mason.nvim to automatically install language servers with :Mason.

🌐 Lua Configuration neovim native

Neovim uses Lua as its primary configuration language (as of 0.5+). Your config lives at:

~/.config/nvim/init.lua

Or as a structured module:

~/.config/nvim/lua/

Setting Options

-- vim.opt is the modern API
vim.opt.number = true
vim.opt.relativenumber = true
vim.opt.tabstop = 2
vim.opt.shiftwidth = 2
vim.opt.expandtab = true
vim.opt.smartindent = true
vim.opt.wrap = false
vim.opt.hlsearch = false
vim.opt.incsearch = true
vim.opt.termguicolors = true
vim.opt.scrolloff = 8
vim.opt.signcolumn = "yes"
vim.opt.updatetime = 50

Keymaps

-- vim.keymap.set(mode, keys, action, opts)
local map = vim.keymap.set

-- Set leader key
vim.g.mapleader = " "

-- Navigation
map("n", "<leader>pf", vim.cmd.Ex)

-- Move lines in visual
map("v", "J", ":m '>+1<CR>gv=gv")
map("v", "K", ":m '<-2<CR>gv=gv")

-- Keep cursor centered on scroll
map("n", "<C-d>", "<C-d>zz")
map("n", "<C-u>", "<C-u>zz")

Useful vim.api and vim.fn calls

`vim.api.nvim_create_autocmd`	Create autocommand
`vim.api.nvim_create_user_command`	Create user command
`vim.api.nvim_buf_get_lines`	Get buffer lines

`vim.fn.expand('%')`	Current file name
`vim.fn.getcwd()`	Working directory
`vim.notify("msg")`	Show notification

🔌 Plugin System ecosystem

The most popular plugin manager is lazy.nvim. Plugins are declared as Lua tables with lazy loading support.

lazy.nvim bootstrap + example

-- ~/.config/nvim/init.lua
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", lazypath })
end
vim.opt.rtp:prepend(lazypath)

require("lazy").setup({
  -- Fuzzy finder
  { "nvim-telescope/telescope.nvim", tag = "0.1.x",
    dependencies = { "nvim-lua/plenary.nvim" } },
  -- Syntax highlighting
  { "nvim-treesitter/nvim-treesitter",
    build = ":TSUpdate" },
  -- LSP config helpers
  { "neovim/nvim-lspconfig" },
  -- Completion
  { "hrsh7th/nvim-cmp" },
})

Essential plugins: telescope.nvim · nvim-treesitter · nvim-lspconfig · mason.nvim · nvim-cmp · null-ls / none-ls · gitsigns.nvim · which-key.nvim · lualine.nvim · oil.nvim / nvim-tree

🌳 Treesitter neovim native (0.9+)

Treesitter provides accurate, incremental syntax parsing, enabling better highlighting, indentation, and navigation than regex-based syntax files.

Commands

`:TSInstall {lang}`	Install parser for language
`:TSInstallInfo`	Show install status
`:TSUpdate`	Update all parsers
`:TSBufToggle highlight`	Toggle TS highlight
`:InspectTree`	Show syntax tree (Nvim 0.9+)

Config

require('nvim-treesitter.configs').setup({
  ensure_installed = {
    "lua", "python", "typescript",
    "rust", "go", "html", "css"
  },
  highlight = { enable = true },
  indent = { enable = true },
})

🔭 Telescope plugin

Fuzzy-finder framework for finding anything — files, grep, LSP symbols, git commits, and more.

Common Pickers

`:Telescope find_files`	Fuzzy file finder
`:Telescope live_grep`	Search file contents
`:Telescope buffers`	Open buffers
`:Telescope oldfiles`	Recent files
`:Telescope git_commits`	Git commit log
`:Telescope lsp_references`	LSP references
`:Telescope keymaps`	Browse all keymaps
`:Telescope help_tags`	Search help docs

Telescope Keymaps (in picker)

`Ctrl`+`n` / `p`	Next/prev result
`Ctrl`+`x`	Open in horizontal split
`Ctrl`+`v`	Open in vertical split
`Ctrl`+`t`	Open in new tab
`Ctrl`+`q`	Send all to quickfix
`?`	Show all mappings

◯ Autocommands Lua API

Autocommands run Lua (or Vimscript) in response to editor events.

Examples

local augroup = vim.api.nvim_create_augroup("MyGroup", {})

-- Highlight on yank
vim.api.nvim_create_autocmd("TextYankPost", {
  group = augroup,
  callback = function()
    vim.highlight.on_yank()
  end,
})

-- Remove trailing whitespace on save
vim.api.nvim_create_autocmd("BufWritePre", {
  group = augroup,
  pattern = "*",
  command = [[%s/\s\+$//e]],
})

-- Format on save (LSP)
vim.api.nvim_create_autocmd("BufWritePre", {
  group = augroup,
  callback = function() vim.lsp.buf.format() end,
})

📺 Terminal Mode neovim native

Neovim has a built-in terminal emulator — run shells and programs directly in a buffer.

Opening & Using

`:term`	Open terminal in current window
`:sp \| term`	Terminal in horizontal split
`:vsp \| term`	Terminal in vertical split
`i` / `a`	Enter terminal (insert) mode
`Ctrl`+`\` `Ctrl`+`n`	Exit to Normal mode
`Ctrl`+`w` + nav	Switch window from terminal

Tip: Map <C-\><C-n> to something easier:

map("t", "<Esc><Esc>", "<C-\\><C-n>")

⚡ Advanced Neovim Features

🆕 Registers Normal / Visual

🏵 Marks Normal

▶ Macros Normal

▩ Text Objects Operator + Object

▩ Windows & Tabs Normal

⚡ LSP (Language Server Protocol) neovim native

🌐 Lua Configuration neovim native

🔌 Plugin System ecosystem

🌳 Treesitter neovim native (0.9+)

🔭 Telescope plugin

◯ Autocommands Lua API

📺 Terminal Mode neovim native