Can I use Vim keybindings in VS Code or JetBrains IDEs?

Yes. VS Code has the Vim extension (vscodevim) which emulates Vim motions, operators, text objects, and most Ex commands directly in VS Code. JetBrains IDEs (IntelliJ, PyCharm, WebStorm, etc.) have IdeaVim, which provides a similar experience. Both extensions support .vimrc-style configuration for custom mappings. This approach gives you Vim's editing efficiency combined with the IDE's code intelligence, debugging, and project management features. Many professional developers use this hybrid approach as their daily workflow.

Vim: The Complete Guide for 2026

Q: How do I exit Vim?

Press Escape to ensure you are in Normal mode, then type :q and press Enter to quit. If you have unsaved changes, use :q! to quit without saving, or :wq (or :x or ZZ) to save and quit. To save without quitting, type :w. The most common mistake is trying to quit while still in Insert mode, so always press Escape first.

Q: What are the most important Vim commands to learn first?

Start with the movement keys h, j, k, l (left, down, up, right), then learn w and b (move by word forward and backward). Learn i to enter Insert mode and Escape to return to Normal mode. Master dd (delete line), yy (yank/copy line), and p (paste). Learn / to search and u to undo. Once these are natural, learn the operator-motion pattern: d combined with a motion (dw to delete a word, d$ to delete to end of line) and text objects (diw to delete inner word, ci" to change inside quotes). This small set covers the vast majority of everyday editing.

Published February 12, 2026 · 30 min read

Vim is one of the most powerful text editors ever created, and in 2026 it remains the tool of choice for developers who value speed, precision, and efficiency. Whether you are a complete beginner who cannot figure out how to exit, or an experienced user looking to level up with Neovim and LSP, this guide covers everything from fundamental modes and motions to advanced macros, plugin management, and Lua configuration.

1. Why Learn Vim in 2026

In a world of graphical editors, AI assistants, and cloud IDEs, Vim endures because its core design principle is uniquely powerful: composable editing commands. Instead of learning hundreds of individual shortcuts, you learn a small vocabulary of operators and motions that combine in thousands of ways. d means delete, w means word, so dw deletes a word. ci" changes inside quotes. This grammar scales infinitely.

Practical reasons to learn Vim today:

Available everywhere — Vim or vi is installed on virtually every Unix, Linux, and macOS system. When you SSH into a server at 3 AM, Vim is there.
Speed — your hands never leave the home row. Editing becomes as fast as you can think.
Neovim and the modern ecosystem — Neovim brings built-in LSP, Tree-sitter, and Lua scripting, making Vim a full IDE.
Transferable skill — Vim keybindings work in VS Code, JetBrains, bash, tmux, and dozens of other tools.
Longevity — Vim has been in active development since 1991. The skills you learn today will last your entire career.

2. Vim Modes

Vim is a modal editor. Each mode assigns a different meaning to your key presses. Understanding modes is the single most important concept in Vim.

Normal Mode (default)

The mode you spend most of your time in. Every key is a command: j moves down, dd deletes a line, p pastes. Press Escape from any mode to return to Normal mode.

Insert Mode

For typing text. Enter it with i (insert before cursor), a (append after cursor), o (open new line below), I (insert at line start), A (append at line end), or O (open line above). Press Escape to return to Normal mode.

Visual Mode

For selecting text. v starts character-wise selection, V selects entire lines, Ctrl+v selects a rectangular block. Once selected, apply any operator: d to delete, y to yank, c to change, > to indent.

Command-line Mode

Enter with : for Ex commands (:w, :q, :s/old/new/g), / for forward search, or ? for backward search.

# Quick reference for entering and leaving modes
Normal mode:    Escape (from any mode)
Insert mode:    i, a, o, I, A, O, s, c (from Normal)
Visual mode:    v, V, Ctrl+v (from Normal)
Command mode:   :, /, ? (from Normal)
Replace mode:   R (from Normal) — overwrites characters as you type

3. Essential Motions

Motions move the cursor. On their own they navigate; combined with operators they define what text to act on.

# Character motions
h   Move left                l   Move right
j   Move down                k   Move up

# Word motions
w   Next word start           W   Next WORD start (whitespace-delimited)
b   Previous word start       B   Previous WORD start
e   End of word               E   End of WORD
ge  End of previous word

# Line motions
0   Start of line             ^   First non-blank character
$   End of line               g_  Last non-blank character

# Find on line
f{char}   Jump TO next {char}           F{char}   Jump TO previous {char}
t{char}   Jump UNTIL next {char}        T{char}   Jump UNTIL previous {char}
;         Repeat last f/t               ,         Repeat last f/t backward

# Screen/file motions
gg  Go to first line          G   Go to last line
{n}G or {n}gg   Go to line n
H   Top of screen             M   Middle of screen       L   Bottom of screen
Ctrl+d  Half page down        Ctrl+u  Half page up
Ctrl+f  Full page down        Ctrl+b  Full page up

# Matching and paragraphs
%   Jump to matching bracket (works with (), [], {})
{   Previous blank line       }   Next blank line
(   Previous sentence         )   Next sentence

4. Editing Commands

Vim's editing power comes from operators combined with motions. The pattern is: operator [count] motion.

# Core operators
d   Delete          c   Change (delete + enter Insert mode)
y   Yank (copy)     p   Paste after cursor    P   Paste before cursor

# Operator + motion examples
dw      Delete from cursor to start of next word
d$      Delete to end of line (also D)
d0      Delete to start of line
dG      Delete to end of file
dgg     Delete to start of file
cw      Change word (delete word, enter Insert mode)
c$      Change to end of line (also C)
yw      Yank word
y$      Yank to end of line

# Line operations (double the operator)
dd      Delete entire line
yy      Yank entire line
cc      Change entire line

# With counts
3dd     Delete 3 lines
5j      Move down 5 lines
2dw     Delete 2 words
d3w     Also delete 3 words

# Other essential editing commands
x       Delete character under cursor (like Delete key)
X       Delete character before cursor (like Backspace)
r{char} Replace single character without entering Insert mode
s       Delete character and enter Insert mode (substitute)
S       Delete line and enter Insert mode
J       Join current line with next line
u       Undo
Ctrl+r  Redo
.       Repeat last change — one of Vim's most powerful commands

The . (dot) command deserves special attention. It repeats your last change. If you type ciwhello<Esc> to change a word to "hello", pressing . on any other word will change that word to "hello" too. This makes repetitive edits extremely fast.

5. Text Objects

Text objects are Vim's secret weapon. They select structured chunks of text: words, sentences, paragraphs, and content inside delimiters. Every text object works with i (inner, excludes delimiters) and a (around, includes delimiters).

# Word text objects
diw     Delete inner word (just the word, not surrounding spaces)
daw     Delete a word (word + trailing space)
ciw     Change inner word

# Quote text objects
di"     Delete inside double quotes
ci'     Change inside single quotes
da"     Delete around double quotes (quotes included)
yi`     Yank inside backticks

# Bracket/paren text objects
di(     Delete inside parentheses        (also dib)
da)     Delete around parentheses        (also dab)
ci{     Change inside curly braces       (also ciB)
di[     Delete inside square brackets
da<     Delete around angle brackets

# Tag text objects (HTML/XML)
dit     Delete inside tag (<div>content</div> → deletes "content")
dat     Delete around tag (deletes the entire tag pair and content)
cit     Change inside tag

# Sentence and paragraph
dis     Delete inner sentence
dap     Delete a paragraph (paragraph + trailing blank line)

# Practical examples
ci"     Change the text inside quotes: "old text" → type new text
da{     Delete an entire code block including the braces
vip     Visually select the entire current paragraph
yaW     Yank the current WORD including trailing whitespace
gUiw    Uppercase the current word

6. Search and Replace

# Basic search
/pattern        Search forward for pattern
?pattern        Search backward for pattern
n               Next match
N               Previous match
*               Search forward for word under cursor
#               Search backward for word under cursor

# Search options (set in vimrc or type in command mode)
:set ignorecase     Case-insensitive search
:set smartcase      Case-insensitive unless you type uppercase
:set hlsearch       Highlight all matches
:set incsearch      Show matches as you type
:nohlsearch         Clear current highlights (often mapped to a key)

# Substitute (search and replace)
:s/old/new/         Replace first occurrence on current line
:s/old/new/g        Replace all occurrences on current line
:%s/old/new/g       Replace all occurrences in entire file
:%s/old/new/gc      Replace all with confirmation for each match
:10,20s/old/new/g   Replace on lines 10 through 20
:'<,'>s/old/new/g   Replace in visual selection

# Regex in search
:%s/\v(\w+)\s+\1/\1/g      Remove duplicate words (very magic mode)
:%s/\vfoo(bar|baz)/qux/g   Replace foobar or foobaz with qux
:%s/^\s\+//g                Remove leading whitespace
:%s/\s\+$//g                Remove trailing whitespace

# The global command (:g)
:g/pattern/d        Delete all lines matching pattern
:g!/pattern/d       Delete all lines NOT matching pattern (also :v/pattern/d)
:g/TODO/t$          Copy all lines with TODO to end of file
:g/^$/d             Delete all blank lines
:g/pattern/normal A;   Append semicolon to all matching lines

⚙ Try it: Test your regex patterns before using them in Vim with our Regex Tester.

7. Registers and Macros

Registers

Vim has 26 named registers (a-z), a default register ("), numbered registers (0-9), and several special registers. Think of them as multiple clipboards.

# Using named registers
"ayy        Yank current line into register a
"ap         Paste from register a
"Ayy        Append to register a (uppercase appends)
"bdiw       Delete word into register b

# Special registers
""          Default register (last d, c, y, or s operation)
"0          Yank register (last yank only, not deletes)
"+          System clipboard (requires +clipboard support)
"*          Primary selection (X11 middle-click clipboard)
".          Last inserted text
":          Last Ex command
"/          Last search pattern
"%          Current filename
"_          Black hole register (delete without saving)

# Practical use: delete without overwriting yank register
"_dd        Delete line without affecting any register
"_diw       Delete word without saving it

:registers  Show contents of all registers

Macros

Macros record a sequence of keystrokes and replay them. They are Vim's answer to repetitive editing tasks.

# Recording and playing macros
q{register}     Start recording into register (e.g., qa)
q               Stop recording
@{register}     Play macro (e.g., @a)
@@              Replay last macro
{count}@a       Play macro a {count} times (e.g., 100@a)

# Example: add quotes around every word on a line
# Record: qa 0 i"<Esc> ea"<Esc> j q
# This goes to start of line, inserts ", goes to end of word, appends "
# Then moves down. Now 50@a applies it to 50 lines.

# Example: convert CSV lines to SQL INSERT values
# Record: qa I('<Esc> f, s','<Esc> ;.; A'),<Esc> j q
# Play on remaining lines: 100@a

# Macros are stored in registers, so you can:
# 1. Paste a macro to edit it: "ap
# 2. Edit the text
# 3. Yank it back: "ayy (remove trailing newline)

8. Splits and Tabs

# Horizontal splits
:split              Split current window horizontally
:split filename     Open filename in horizontal split
Ctrl+w s            Same as :split

# Vertical splits
:vsplit             Split current window vertically
:vsplit filename    Open filename in vertical split
Ctrl+w v            Same as :vsplit

# Navigating splits
Ctrl+w h/j/k/l     Move to left/down/up/right split
Ctrl+w w            Cycle through splits
Ctrl+w o            Close all other splits (only keep current)

# Resizing splits
Ctrl+w =            Make all splits equal size
Ctrl+w +            Increase height
Ctrl+w -            Decrease height
Ctrl+w >            Increase width
Ctrl+w <            Decrease width
Ctrl+w _            Maximize height
Ctrl+w |            Maximize width

# Tab pages
:tabnew             Open new tab
:tabnew filename    Open file in new tab
gt                  Next tab
gT                  Previous tab
{n}gt               Go to tab n
:tabclose           Close current tab
:tabonly             Close all other tabs

9. Buffers and Argument List

A buffer is an in-memory representation of a file. Vim can have hundreds of buffers open without visible windows for each one. Buffers are the primary way to work with multiple files.

# Buffer commands
:e filename         Open file in current window
:ls                 List all buffers
:b {name or num}    Switch to buffer by name or number
:bnext (or :bn)     Next buffer
:bprev (or :bp)     Previous buffer
:bdelete (or :bd)   Close buffer
:bufdo %s/old/new/g Run command on all buffers

# Argument list
:args *.js          Set argument list to all JS files
:argdo %s/var/let/g Run substitution across all files in arglist
:next               Next file in argument list
:prev               Previous file in argument list
:first              First file
:last               Last file

# Quick file navigation
Ctrl+^              Toggle between current and alternate (last) buffer
gf                  Open file under cursor (go to file)
gd                  Go to local declaration of word under cursor

10. vimrc / init.vim Configuration

Your ~/.vimrc (or ~/.config/nvim/init.vim for Neovim) controls Vim's behavior. Here is a practical starting configuration:

" ===== Essential Settings =====
set nocompatible            " Disable vi compatibility
syntax on                   " Enable syntax highlighting
filetype plugin indent on   " Enable filetype detection and plugins

" ===== Display =====
set number                  " Show line numbers
set relativenumber          " Relative line numbers (great for motions)
set cursorline              " Highlight current line
set signcolumn=yes          " Always show sign column
set scrolloff=8             " Keep 8 lines visible above/below cursor
set colorcolumn=80          " Show column guide at 80 characters
set showcmd                 " Show partial commands in status line
set showmode                " Show current mode
set laststatus=2            " Always show status line

" ===== Search =====
set hlsearch                " Highlight search matches
set incsearch               " Show matches as you type
set ignorecase              " Case-insensitive search
set smartcase               " Unless you type uppercase

" ===== Indentation =====
set expandtab               " Use spaces instead of tabs
set tabstop=4               " Tab displays as 4 spaces
set shiftwidth=4            " Indent/dedent by 4 spaces
set softtabstop=4           " Tab inserts 4 spaces
set autoindent              " Copy indent from current line on new line
set smartindent             " Smart autoindenting for C-like code

" ===== Behavior =====
set hidden                  " Allow switching buffers without saving
set clipboard=unnamedplus   " Use system clipboard
set mouse=a                 " Enable mouse support
set undofile                " Persistent undo across sessions
set undodir=~/.vim/undodir  " Where to store undo files
set noswapfile              " Disable swap files
set nobackup                " Disable backup files
set updatetime=250          " Faster CursorHold events
set splitbelow              " Horizontal splits open below
set splitright              " Vertical splits open to the right

" ===== Key Mappings =====
let mapleader = " "         " Set leader key to Space
nnoremap <leader>h :nohlsearch<CR>
nnoremap <leader>w :w<CR>
nnoremap <leader>q :q<CR>

" Better split navigation (Ctrl+hjkl instead of Ctrl+w then hjkl)
nnoremap <C-h> <C-w>h
nnoremap <C-j> <C-w>j
nnoremap <C-k> <C-w>k
nnoremap <C-l> <C-w>l

" Move lines in Visual mode, keep cursor centered when scrolling
vnoremap J :m '>+1<CR>gv=gv
vnoremap K :m '<-2<CR>gv=gv
nnoremap <C-d> <C-d>zz
nnoremap <C-u> <C-u>zz

11. Essential Plugins

vim-plug (Vim and Neovim)

" Install vim-plug:
" curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
"   https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

call plug#begin('~/.vim/plugged')

Plug 'tpope/vim-surround'       " Change surrounding quotes/brackets
Plug 'tpope/vim-commentary'     " Toggle comments with gc
Plug 'tpope/vim-fugitive'       " Git integration
Plug 'tpope/vim-repeat'         " Make . work with plugin commands
Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
Plug 'junegunn/fzf.vim'         " Fuzzy finder for files, buffers, etc.
Plug 'airblade/vim-gitgutter'   " Show git diff in the gutter
Plug 'itchyny/lightline.vim'    " Lightweight status line

call plug#end()

" After adding plugins, run :PlugInstall

lazy.nvim (Neovim only, modern standard)

-- ~/.config/nvim/lua/plugins/init.lua
return {
    { "tpope/vim-surround" },
    { "tpope/vim-repeat" },
    { "numToStr/Comment.nvim", config = true },
    {
        "nvim-telescope/telescope.nvim",
        dependencies = { "nvim-lua/plenary.nvim" },
        keys = {
            { "<leader>ff", "<cmd>Telescope find_files<cr>" },
            { "<leader>fg", "<cmd>Telescope live_grep<cr>" },
            { "<leader>fb", "<cmd>Telescope buffers<cr>" },
        },
    },
    {
        "nvim-treesitter/nvim-treesitter",
        build = ":TSUpdate",
        config = function()
            require("nvim-treesitter.configs").setup({
                ensure_installed = { "lua", "javascript", "python", "typescript", "html", "css" },
                highlight = { enable = true },
                indent = { enable = true },
            })
        end,
    },
    { "lewis6991/gitsigns.nvim", config = true },
    {
        "nvim-lualine/lualine.nvim",
        config = function()
            require("lualine").setup({ options = { theme = "auto" } })
        end,
    },
}

Key Plugin Highlights

vim-surround — cs"' changes surrounding double quotes to single. ds( removes surrounding parentheses. ysiw] wraps a word in brackets.
vim-commentary / Comment.nvim — gcc toggles a comment on the current line. gc in Visual mode comments the selection.
Telescope / fzf — fuzzy-find files, buffers, grep results, and more. Essential for navigating large projects.
Tree-sitter — precise syntax highlighting, indentation, and code folding based on actual AST parsing.

12. Neovim and Lua Configuration

Neovim uses ~/.config/nvim/init.lua as its main configuration file. Lua is significantly faster than vimscript and has a cleaner syntax.

-- ~/.config/nvim/init.lua
vim.g.mapleader = " "

local opt = vim.opt
opt.number = true              opt.relativenumber = true
opt.expandtab = true           opt.shiftwidth = 4
opt.tabstop = 4                opt.smartindent = true
opt.cursorline = true          opt.signcolumn = "yes"
opt.scrolloff = 8              opt.hlsearch = true
opt.incsearch = true           opt.ignorecase = true
opt.smartcase = true           opt.splitbelow = true
opt.splitright = true          opt.clipboard = "unnamedplus"
opt.undofile = true            opt.updatetime = 250
opt.termguicolors = true

-- Keymaps (same as vimrc, but Lua syntax)
local map = vim.keymap.set
map("n", "<leader>h", ":nohlsearch<CR>")
map("n", "<leader>w", ":w<CR>")
map("n", "<C-h>", "<C-w>h")    map("n", "<C-j>", "<C-w>j")
map("n", "<C-k>", "<C-w>k")    map("n", "<C-l>", "<C-w>l")
map("v", "J", ":m '>+1<CR>gv=gv")
map("v", "K", ":m '<-2<CR>gv=gv")

-- Bootstrap lazy.nvim
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/ directory

13. LSP Setup for Code Completion

Neovim's built-in LSP client gives you IDE-quality code completion, go-to-definition, rename, diagnostics, and more. The standard approach uses mason.nvim to manage language servers and nvim-cmp for the completion UI.

-- lua/plugins/lsp.lua
return {
    { "williamboman/mason.nvim", config = true },
    { "williamboman/mason-lspconfig.nvim",
      config = function()
          require("mason-lspconfig").setup({
              ensure_installed = { "lua_ls", "ts_ls", "pyright", "html", "cssls" },
          })
      end },
    { "neovim/nvim-lspconfig",
      config = function()
          local lspconfig = require("lspconfig")
          for _, s in ipairs({ "lua_ls", "ts_ls", "pyright", "html", "cssls" }) do
              lspconfig[s].setup({})
          end
          vim.api.nvim_create_autocmd("LspAttach", {
              callback = function(args)
                  local m = function(k, f, d) vim.keymap.set("n", k, f, { buffer = args.buf, desc = d }) end
                  m("gd", vim.lsp.buf.definition, "Go to definition")
                  m("gr", vim.lsp.buf.references, "Find references")
                  m("K",  vim.lsp.buf.hover, "Hover docs")
                  m("<leader>rn", vim.lsp.buf.rename, "Rename symbol")
                  m("<leader>ca", vim.lsp.buf.code_action, "Code action")
              end })
      end },
    { "hrsh7th/nvim-cmp",
      dependencies = { "hrsh7th/cmp-nvim-lsp", "hrsh7th/cmp-buffer", "L3MON4D3/LuaSnip", "saadparwaiz1/cmp_luasnip" },
      config = function()
          local cmp = require("cmp")
          cmp.setup({
              snippet = { expand = function(args) require("luasnip").lsp_expand(args.body) end },
              mapping = cmp.mapping.preset.insert({
                  ["<C-Space>"] = cmp.mapping.complete(),
                  ["<CR>"] = cmp.mapping.confirm({ select = true }),
                  ["<C-n>"] = cmp.mapping.select_next_item(),
                  ["<C-p>"] = cmp.mapping.select_prev_item(),
              }),
              sources = cmp.config.sources({ { name = "nvim_lsp" }, { name = "luasnip" }, { name = "buffer" } }),
          })
      end },
}

With this setup you get autocompletion popups, signature help, go-to-definition with gd, hover docs with K, project-wide rename with <leader>rn, and inline diagnostics, all using the native Vim keybinding philosophy.

14. Vim Motions in VS Code / JetBrains

You do not need to switch to Vim full-time to use its keybindings. The most popular approach in 2026 is using Vim keybindings inside a graphical IDE.

VS Code + Vim Extension

// Install the "Vim" extension (vscodevim.vim)
// Add to settings.json:
{
    "vim.leader": "<space>",
    "vim.useSystemClipboard": true,
    "vim.hlsearch": true,
    "vim.incsearch": true,
    "vim.smartRelativeLine": true,
    "vim.normalModeKeyBindingsNonRecursive": [
        { "before": ["<leader>", "w"], "commands": ["workbench.action.files.save"] },
        { "before": ["<leader>", "f"], "commands": ["workbench.action.quickOpen"] },
        { "before": ["<leader>", "g"], "commands": ["workbench.action.findInFiles"] }
    ],
    "vim.insertModeKeyBindings": [
        { "before": ["j", "k"], "after": ["<Esc>"] }
    ]
}

JetBrains + IdeaVim

" ~/.ideavimrc
set ideajoin          " Smart line joining
set surround          " Enable vim-surround emulation
set commentary        " Enable vim-commentary emulation
set NERDTree          " Enable NERDTree emulation
set highlightedyank   " Briefly highlight yanked text

let mapleader = " "

" IDE-specific actions mapped to Vim-style keys
nmap <leader>ff <Action>(GotoFile)
nmap <leader>fg <Action>(FindInPath)
nmap <leader>rn <Action>(RenameElement)
nmap <leader>ca <Action>(ShowIntentionActions)
nmap gd <Action>(GotoDeclaration)
nmap gr <Action>(FindUsages)
nmap gi <Action>(GotoImplementation)

Both approaches give you Vim's operator-motion grammar for editing while keeping the IDE's code intelligence, debugging, and project management features. Many professional developers consider this the optimal setup.

15. Practical Workflows

Quick Editing Tasks

# Rename a variable everywhere in a file
*               " Search for word under cursor
:%s//newName/g  " Replace all (empty pattern reuses last search)

# Indent a block of code
V}              " Visual-line select to end of paragraph
>               " Indent (repeat with . for more levels)

# Sort lines
V}              " Select the block
:sort           " Sort alphabetically
:sort n         " Sort numerically
:sort u         " Sort and remove duplicates

# Delete all lines containing "debug"
:g/debug/d

# Number all lines
:%s/^/\=line('.') . '. '/

# Record a macro to wrap function arguments
# Given: myFunc(a, b, c, d, e)
# Wanted: myFunc(\n  a,\n  b,\n  c,\n  d,\n  e\n)
qa f( a<CR>  <Esc> f, a<CR>  <Esc> ;.; q
# Then @a or . to continue

Multi-file Workflow

# Open multiple files
vim file1.js file2.js file3.js

# Or use wildcards
vim src/**/*.py

# Search across files (with :vimgrep)
:vimgrep /TODO/g **/*.js
:copen              " Open quickfix list with results
:cnext              " Jump to next result
:cprev              " Jump to previous result

# Apply changes across files
:args **/*.js               " Set argument list
:argdo %s/var/const/ge | w  " Replace in all files and save

Frequently Asked Questions

How do I exit Vim?

Press Escape to ensure you are in Normal mode, then type :q and press Enter to quit. If you have unsaved changes, use :q! to quit without saving, or :wq (or :x or ZZ) to save and quit. To save without quitting, type :w. The most common mistake is trying to quit while still in Insert mode, so always press Escape first.

What is the difference between Vim and Neovim?

Neovim is a modern fork of Vim that maintains full compatibility with Vim's keybindings and vimscript while adding significant improvements. Neovim has built-in LSP support for IDE-level code completion and diagnostics, native Lua scripting for faster configuration, a built-in terminal emulator, asynchronous plugin architecture, and Tree-sitter for better syntax highlighting. Your existing vimrc will work in Neovim with minimal changes. Most new plugin development in 2026 targets Neovim first.

How long does it take to learn Vim?

You can learn basic Vim navigation and editing in about 30 minutes by running vimtutor from the command line. Within a week of daily use you will be comfortable with the core motions (hjkl, w, b, e), basic editing (d, c, y, p), and switching between Normal and Insert modes. After two to four weeks of deliberate practice, text objects and operator-motion combinations become natural. True fluency, where Vim feels faster than any other editor, typically takes two to three months of consistent use.

Can I use Vim keybindings in VS Code or JetBrains?

Yes. VS Code has the Vim extension (vscodevim) which emulates Vim motions, operators, text objects, and most Ex commands. JetBrains IDEs have IdeaVim, which provides a similar experience. Both support .vimrc-style configuration for custom mappings. This hybrid approach gives you Vim's editing efficiency combined with the IDE's code intelligence, debugging, and project management features. Many professional developers use this as their daily workflow.

What are the most important Vim commands to learn first?

Start with the movement keys h, j, k, l, then learn w and b for word navigation. Learn i to enter Insert mode and Escape to return to Normal mode. Master dd (delete line), yy (yank line), and p (paste). Learn / to search and u to undo. Once these are natural, learn the operator-motion pattern: dw to delete a word, d$ to delete to end of line, and text objects like diw and ci". This small set covers the vast majority of everyday editing.

Continue Learning

Vim is a deep editor that rewards continued practice. Once you are comfortable with the fundamentals covered here, explore marks for bookmarking positions, folds for managing large files, autocommands for automating tasks on file events, and Vim's built-in spell checking. Run :help in Vim for the most comprehensive documentation of any software ever written.

Linux Commands: The Complete Guide — master the terminal environment where Vim lives
Bash Scripting: The Complete Guide — automate tasks alongside Vim with shell scripts
VS Code Tips: The Complete Guide — use Vim keybindings inside VS Code for the best of both worlds
Git: The Complete Guide — integrate Git with Vim through fugitive and other plugins
GitHub Merge Queue CODEOWNERS Approval Deadlock Guide — practical rollback runbook when required owner approvals are unavailable
GitHub Merge Queue Expiry Extension Reapproval Guide — structured extension flow when rollback bypass windows are nearing expiry

⚙ Essential tools: Test regex patterns from Vim's search with our Regex Tester, compare file versions with the Diff Checker, and format config files with the JSON Formatter.