What it is

Neovim is a Vim-fork text editor focused on extensibility and usability, built as a modern refactoring of Vim’s codebase. It lives in the developer tools ecosystem, specifically as a terminal-based code editor that maintains compatibility with Vim’s core editing model while adding new capabilities.

The project solves the problem of Vim’s monolithic architecture, which made it difficult to integrate modern features, support concurrent development, or enable rich UIs without core modifications. Neovim decouples the core editor engine from its user interface, allowing external GUIs and tools to interact via a stable API.

Key capabilities

• Asynchronous job control for running background processes without blocking the editor
• Embedded terminal emulator with full terminal emulation support
• Lua-powered extensibility with first-class API access for scripting
• Remote API access from any language via msgpack-rpc, enabling language-agnostic plugins
• Shared undo history (shada) across multiple editor instances
• XDG base directory support for standardized configuration and data paths
• Full compatibility with most existing Vim plugins, including Ruby and Python ones

Who uses it and how

Developers use Neovim as a lightweight, scriptable alternative to full IDEs, especially in terminal-heavy or remote workflows (e.g., SSH sessions, containerized dev environments). Teams adopt it for consistent, version-controlled editor configurations shared across machines via Git. Plugin authors build Neovim-native tools using its Lua API or external clients using its remote API to integrate with IDE-like features (e.g., LSP clients, tree-sitter integrations).

Getting started

Pre-built packages are available for Windows, macOS, and Linux via GitHub Releases or system package managers (Homebrew, apt, dnf, pacman). It can also be built from source using CMake or the provided Makefile, with make CMAKE_BUILD_TYPE=RelWithDebInfo sudo make install as the standard install command.

When to use it — and when not to

Neovim replaces parts of the Vim ecosystem with a more modular, API-driven architecture, but requires manual setup of dependencies (e.g., LSP servers, tree-sitter parsers) and UI components (e.g., GUI frontends like nvim-qt). It is ideal for users comfortable with terminal workflows and configuration via Lua/Vimscript, but less suitable for those needing out-of-the-box IDE features or preferring mouse-driven interaction. Self-hosters must manage their own plugin ecosystem, configuration persistence (via ~/.config/nvim), and optional services like SMTP if email notifications are needed.

make CMAKE_BUILD_TYPE=RelWithDebInfo
sudo make install

make CMAKE_BUILD_TYPE=RelWithDebInfo CMAKE_INSTALL_PREFIX=/full/path/
make install

├─ cmake/           CMake utils
├─ cmake.config/    CMake defines
├─ cmake.deps/      subproject to fetch and build dependencies (optional)
├─ runtime/         plugins and docs
├─ src/nvim/        application source code (see src/nvim/README.md)
│  ├─ api/          API subsystem
│  ├─ eval/         Vimscript subsystem
│  ├─ event/        event-loop subsystem
│  ├─ generators/   code generation (pre-compilation)
│  ├─ lib/          generic data structures
│  ├─ lua/          Lua subsystem
│  ├─ msgpack_rpc/  RPC subsystem
│  ├─ os/           low-level platform code
│  └─ tui/          built-in UI
└─ test/            tests (see test/README.md)