Vim vs Neovim

Neovim is Vim's fork: the same modal editor with the same keys, plus Lua configuration, a built-in language server client and a plugin scene that can turn the terminal into something close to an IDE. Knowing what each one is good at tells you which to open, and why many developers keep both.

Same editor underneath

Neovim started in 2014 as a fork of Vim. Its developers took Vim's source code and set out to clean it up and make it easier to extend, rather than write a new editor from scratch. So the editing skills you learn in one carry over to the other.

The modes are the same: normal mode for moving and editing, insert mode for typing, and the colon command line for saving and quitting. dd deletes the current line in both. :wq saves and quits in both. If you are still learning those basics, the Vim video page walks through them, and every one of them works in Neovim unchanged.

They are separate programs, though. Vim runs as vim and Neovim as nvim, and you can install both on the same machine without them getting in each other's way. Running vim --version and nvim --version shows which builds you have. Each keeps its own settings in its own place, which is where the two start to differ.

Where your settings live

Vim reads its settings from ~/.vimrc, written in Vimscript, a language Vim invented for itself. Vimscript is fine for switching options on and off. It gets awkward once a config grows into real logic, such as functions or conditions, and that is the point where Neovim takes a different road.

Neovim reads ~/.config/nvim/init.lua and lets you write the whole config in Lua, a small general-purpose programming language with proper functions, tables and modules. It can still read Vimscript from an init.vim instead, but not both at once: pick one file.

Here is the same setting in each. To show line numbers, Vim's .vimrc says set number. Neovim's init.lua says vim.opt.number = true. Add set relativenumber or vim.opt.relativenumber = true and both editors number each line by its distance from the cursor, which makes jumps such as 5j easy to aim.

For two settings the difference is cosmetic. It matters once the config grows. A Lua config can be split into modules, loop over a list of servers to set up, and call the same vim.* functions that plugins use. That is why most new Neovim plugins are written in Lua.

What does not cross over

Neovim runs most Vimscript, so older plugins and tricks usually work. Two things don't:

• Vim 9 added a new dialect called Vim9 script, and Neovim does not support it. A plugin written in Vim9 script won't load in Neovim.
• Plugins written in Lua for Neovim use its Lua API, which Vim doesn't have, so they won't run in Vim.

Neovim also changes a few defaults. Syntax highlighting and filetype detection are on out of the box, and it keeps its data in standard folders under ~/.config and ~/.local rather than ~/.vim.

A language server client, built in

The biggest practical difference is the Language Server Protocol, or LSP. A language server is a separate program that understands one language: Pyright for Python, lua_ls for Lua. The editor is the client. It sends the server your code as you edit, and the server answers with errors, definitions and the places a name is used.

Neovim ships with that client. Vim can get the same features, but only through a plugin such as vim-lsp or coc.nvim. With a server running for the file you have open, Neovim can:

• underline mistakes as you type, with the message beside the line;
• jump to where a function is defined, with Ctrl-];
• show a function's signature and documentation under the cursor, with K;
• rename a function everywhere it is used, with grn.

Here a misspelt function name gets flagged as soon as the line is typed, before the file is even saved:

Play

The client is only half of it. Neovim doesn't bundle any language servers, so you install the one for your language and tell Neovim to use it. Running :checkhealth vim.lsp shows whether a server is attached to the current file, which is the first thing to check when nothing gets underlined.

Plugins and starter setups

Plugins fill in the rest of the IDE feel. Three kinds come up in almost every setup. A fuzzy finder (Telescope is a common one) lets you type a few letters of a file name and jump straight to it. A file tree shows the project's folders in a side panel. Git signs mark the lines you have added or changed since the last commit in the gutter.

Wiring dozens of plugins together by hand takes time, so most people start from a ready-made config. The two best known take opposite approaches:

• kickstart.nvim is a single, heavily commented init.lua. You read it, keep what you want and grow it yourself. It suits someone who wants to understand every line.
• LazyVim is a full setup with plugins chosen and configured for you. You clone its starter into ~/.config/nvim, open nvim, and it installs everything on the first launch.

This is a LazyVim setup open on a small project, with the file tree on the left and git signs in the gutter:

The trade-off is control. LazyVim gets you a working IDE in minutes, but when a key does something odd you have to find out which plugin set it. Kickstart is slower to grow, and nothing in it is a surprise.

Why Vim is still everywhere

None of this makes Vim obsolete. Vim, or the older vi it was modelled on, is installed on almost every Linux server, so when you SSH into a machine you didn't set up, it is usually already there. Neovim usually isn't, and installing it plus your plugins on every box you visit is more trouble than it is worth.

Vim also opens instantly with no plugins to load, which is what you want for a two-line fix. And it is still developed: Vim 9.2 came out in February 2026, kept going by a team of maintainers since its creator, Bram Moolenaar, died in 2023.

Using both

A realistic day looks like this. A site on one of your servers is down because of a typo in its web server config. You SSH in, run vim on the config file, fix the line with the same normal-mode keys you always use, :wq, and restart the service. It needs no setup and no plugins.

Then you go back to your own machine and open the project in Neovim, where the language server catches the next typo before you save and the fuzzy finder gets you to any file in a few keystrokes. The keys your fingers know are the same in both places. Only the extras change.

If you would rather not use a modal editor on servers at all, Nano is usually installed too.

Common mistakes

• Expecting Neovim to read ~/.vimrc. It reads ~/.config/nvim instead, so your Vim settings seem to vanish. Copy the options you want into init.lua, or source the old file from init.vim.
• Cloning a starter setup over a config you already have. Move the existing ~/.config/nvim folder aside first, so you can go back.
• Expecting the LSP client to work on its own. It needs a language server installed for each language; :checkhealth vim.lsp tells you what is missing.
• Pasting Vim9 script into a Neovim config. It won't run there; use plain Vimscript or Lua.

Key takeaways

• Neovim is a 2014 fork of Vim, so the modes and keys such as dd and :wq are the same.
• Vim uses Vimscript in ~/.vimrc; Neovim adds Lua, in ~/.config/nvim/init.lua.
• Neovim's built-in LSP client gives you errors as you type, go to definition and rename, once a language server is installed.
• Starter setups such as LazyVim and kickstart.nvim add fuzzy finding, a file tree and git signs.
• Vim is on nearly every server and still gets releases, so knowing both pays off.