vim-plug: Minimalist Plugin Manager for Vim and Neovim

Installation requires downloading plug.vim to the autoload directory

The README provides exact commands for each platform. For Vim on Unix:

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

For Neovim on Unix or Linux:

sh -c 'curl -fLo "${XDG_DATA_HOME:-$HOME/.local/share}"/nvim/site/autoload/plug.vim --create-dirs \
       https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim'

For Linux Flatpak Neovim:

curl -fLo ~/.var/app/io.neovim.nvim/data/nvim/site/autoload/plug.vim --create-dirs \
    https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

For Vim on Windows PowerShell:

iwr -useb https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim |`
    ni $HOME/vimfiles/autoload/plug.vim -Force

For Neovim on Windows PowerShell:

iwr -useb https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim |`
    ni "$(@($env:XDG_DATA_HOME, $env:LOCALAPPDATA)[$null -eq $env:XDG_DATA_HOME])/nvim-data/site/autoload/plug.vim" -Force

After installation, add a vim-plug section to your `~/.vimrc` (or `~/.config/nvim/init.vim` for Neovim):

call plug#begin()

" List your plugins here
Plug 'tpope/vim-sensible'

call plug#end()

Reload the file or restart Vim, then run `:PlugInstall` to install the plugins.

Single-file design with no external dependencies

vim-plug consists of one file, plug.vim, with no dependencies. The README describes this as a minimalist design that is super easy to set up. You download plug.vim and place it in the autoload directory. For Vim on Unix, the command is `curl -fLo ~/.vim/autoload/plug.vim --create-dirs https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim`. For Neovim on Unix, the path changes to `${XDG_DATA_HOME:-$HOME/.local/share}/nvim/site/autoload/plug.vim`. Windows PowerShell commands differ for Vim and Neovim, using `iwr -useb` and `ni` with different target paths. The Flatpak Neovim path is `~/.var/app/io.neovim.nvim/data/nvim/site/autoload/plug.vim`. This single-file approach means no package manager bootstrap is needed, but it also means updates require re-downloading the file manually or using `:PlugUpgrade`.

Parallel installation and shallow clones reduce wait time

The README highlights super-fast parallel installation and update, citing a 40-in-4 benchmark. Shallow clones minimize disk space usage and download time by fetching only the latest commit history. The `PlugInstall` and `PlugUpdate` commands accept an optional `#threads` argument to control concurrency. For example, `:PlugInstall 8` uses eight threads. The default thread count is not documented in the README. Shallow clones are created with `--depth=1` but the README does not specify whether full history is fetched later for operations like `PlugDiff`. Users with limited bandwidth or disk space benefit from this approach, but plugins requiring submodules or full history for version detection may need the `frozen` option to disable shallow clone behavior.

On-demand loading via the `on` option speeds up startup

The `on` option enables lazy loading by specifying commands, events, or filetypes that trigger plugin loading. For example, `Plug('scrooloose/nerdtree', { 'on': 'NERDTreeToggle' })` loads the plugin only when the NERDTreeToggle command is called. The `for` option loads plugins for specific filetypes: `Plug('plasticboy/vim-markdown', { 'for': 'markdown' })`. The README links to a startup time benchmark showing improved performance. However, the README does not document how on-demand loading interacts with plugin dependencies or whether the plugin's autocommands are registered before the trigger fires. The `frozen` option prevents updates for specific plugins, useful for locking known-working versions. There is no documented way to lazy-load based on custom conditions beyond commands, events, and filetypes.

Post-update hooks run arbitrary commands after install or update

The `do` option specifies a command to run after a plugin is installed or updated. The README shows examples like `Plug('junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' })` which runs the fzf install script. The command runs in the plugin's directory. For more complex hooks, you can use Vim script expressions. The README does not document whether hooks run in parallel with other plugins, whether failures halt the installation process, or how to handle hooks that require user interaction. Hooks can be any shell command or Vim function. The `PlugUpgrade` command upgrades vim-plug itself by re-downloading plug.vim from the master branch.

Rollback and review via PlugDiff and PlugSnapshot

The `PlugDiff` command examines changes from the previous update and shows pending changes, allowing you to review what changed before committing. `PlugSnapshot[!] [output path]` generates a script that restores the current snapshot of all plugins, including their commit hashes. The bang version `PlugSnapshot!` overwrites the output file without prompting. This enables rollback by sourcing the snapshot script later. The README does not document whether snapshots include submodule state, how to automate snapshot creation on every update, or the maximum number of historical snapshots retained. `PlugStatus` checks the status of plugins, showing which are installed, outdated, or not in the configuration. `PlugClean[!]` removes plugins no longer listed in the configuration, with the bang version cleaning without prompt.

Branch, tag, and commit targeting with wildcard support

The `branch`, `tag`, and `commit` options let you pin plugins to specific refs. Wildcards are allowed for tags, requiring git 1.9.2 or above. The example `Plug('fatih/vim-go', { 'tag': '*' })` uses the latest tag. Branch example: `Plug('neoclide/coc.nvim', { 'branch': 'release' })`. The `commit` option takes a full or short SHA. The README does not document how vim-plug resolves `tag: '*'` when multiple tags exist, whether it uses semantic versioning sorting or git tag date ordering. The `rtp` option specifies a subdirectory containing the Vim plugin when the repository root is not the plugin root. The `as` option lets you use a different name for the plug, useful when managing forks. The `dir` option installs a plugin in a non-default directory, as shown with fzf installing to `~/.fzf`.

Lua configuration supported but not native API

Neovim users can write configuration in Lua using `init.lua`. The example shows `local Plug = vim.fn['plug#']` and `vim.call('plug#begin')` with `Plug('repo', { options })` syntax. This works because vim-plug exposes its functions through Vim's function namespace, not a native Lua module. The `plug#begin()` function accepts an optional custom plugin directory argument, defaulting to `~/.vim/plugged` for Vim on Linux/macOS, `~/vimfiles/plugged` for Vim on Windows, and `stdpath('data') . '/plugged'` for Neovim. The README warns against using standard Vim directory names like 'plugin' for the custom directory. The README does not document any Lua-specific features, async APIs, or integration with Neovim's built-in package management. The last release was 0.14.0 on 2024-07-09; the last push was 2026-05-22, indicating maintenance activity but no new feature releases in over a year.

Editorial conclusion

Users who want a simple, stable plugin manager with broad Vim/Neovim compatibility will find vim-plug reliable. Neovim users wanting native Lua configuration or frequent feature updates should evaluate lazy.nvim or other modern alternatives first.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes