Provider

Nvim:help pages,generated fromsource using thetree-sitter-vimdoc parser.

Providers

Nvim delegates some features to dynamic "providers". This document describesthe providers and how to install them.E319
Use of a feature requiring a missing provider is an error:

E319: No "foo" provider found. Run ":checkhealth vim.provider"

Run the:checkhealth command, and review the sections below.

Python integrationprovider-python

Nvim supports Pythonremote-plugins and the Vim legacypython3 andpythonx interfaces (which are implemented as remote-plugins).

Note: Only the Vim 7.3 legacy interface is supported, not later features suchaspython-bindeval (Vim 7.4); use the Nvim API instead. Python 2 is notsupported.

PYTHON QUICKSTART

To use Python plugins, you need the "pynvim" module. Run:checkhealth to seeif you already have it (some package managers install the module with Nvimitself).

For Python 3 plugins:1. Make sure Python 3.9+ is available in your $PATH.2. Install the module (try "python" if "python3" is missing):

python3 -m pip install --user --upgrade pynvim

The pip--upgrade flag ensures that you get the latest version even ifa previous version was already installed.

Ruby integrationprovider-ruby

Nvim supports Rubyremote-plugins and the Vim legacyruby-vim interface(which is itself implemented as a Nvim remote-plugin).

RUBY QUICKSTART

To use Ruby plugins with Nvim, install the latest "neovim" RubyGem:

gem install neovim

Run:checkhealth to see if your system is up-to-date.

RUBY PROVIDER CONFIGURATION

g:loaded_ruby_provider
To disable Ruby support:

let g:loaded_ruby_provider = 0

g:ruby_host_prog
Command to start the Ruby host. By default this is "neovim-ruby-host". Withproject-local Ruby versions (via tools like RVM or rbenv) setting this canavoid the need to install the "neovim" gem in every project.

To use an absolute path (e.g. to an rbenv installation):

let g:ruby_host_prog = '~/.rbenv/versions/2.4.1/bin/neovim-ruby-host'

To use the RVM "system" Ruby installation:

let g:ruby_host_prog = 'rvm system do neovim-ruby-host'

Perl integrationprovider-perl

Nvim supports Perlremote-plugins on Unix platforms. Support for polling STDINon MS-Windows is currently lacking from all known event loop implementations.The Vim legacyperl-vim interface is also supported (which is itselfimplemented as a Nvim remote-plugin).https://github.com/jacquesg/p5-Neovim-Ext

Note: Only perl versions from 5.22 onward are supported.

PERL QUICKSTART

To use perl remote-plugins with Nvim, install the "Neovim::Ext" cpan package:

cpanm -n Neovim::Ext

Run:checkhealth to see if your system is up-to-date.

PERL PROVIDER CONFIGURATION

g:loaded_perl_provider
To disable Perl support:

:let g:loaded_perl_provider = 0

g:perl_host_prog
Command to start the Perl executable. Must be set before anycheck for has("perl").

let g:perl_host_prog = '/path/to/perl'

Node.js integrationprovider-nodejs

Nvim supports Node.jsremote-plugins.https://github.com/neovim/node-client/

NODEJS QUICKSTART

To use javascript remote-plugins with Nvim, install the "neovim" npm package:

npm install -g neovim

Run:checkhealth to see if your system is up-to-date.

NODEJS PROVIDER CONFIGURATION

g:loaded_node_provider
To disable Node.js support:

:let g:loaded_node_provider = 0

g:node_host_prog
Command to start the Node.js host. Setting this makes startup faster.

By default, Nvim searches for "neovim-node-host" using "npm root -g", whichcan be slow. To avoid this, set g:node_host_prog to the host path:

let g:node_host_prog = '/usr/local/bin/neovim-node-host'

Clipboard integrationprovider-clipboardclipboard

Nvim has no direct connection to the system clipboard. Instead it depends onaprovider which transparently uses shell commands to communicate with thesystem clipboard or any other clipboard "backend".

To ALWAYS use the clipboard for ALL operations (instead of interacting withthe "+" and/or "*" registers explicitly):

set clipboard+=unnamedplus

See'clipboard' for details and options.

clipboard-tool
The presence of a working clipboard tool implicitly enables the '+' and "*"registers. Nvim looks for these clipboard tools, in order of priority:

g:clipboard (unless unset orfalse)

pbcopy, pbpaste (macOS)

wl-copy, wl-paste (if $WAYLAND_DISPLAY is set)

waycopy, waypaste (if $WAYLAND_DISPLAY is set)

xsel (if $DISPLAY is set)

xclip (if $DISPLAY is set)

lemonade (for SSH)https://github.com/pocke/lemonade

doitclient (for SSH)https://www.chiark.greenend.org.uk/~sgtatham/doit/

win32yank (Windows)

putclip, getclip (Windows)https://cygwin.com/packages/summary/cygutils.html

clip, powershell (Windows)https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/clip

termux (via termux-clipboard-set, termux-clipboard-set)

tmux (if $TMUX is set)

g:clipboard
To configure a custom clipboard tool, set g:clipboard to a dictionary.For example this configuration integrates the tmux clipboard:

let g:clipboard = {      \   'name': 'myClipboard',      \   'copy': {      \      '+': ['tmux', 'load-buffer', '-'],      \      '*': ['tmux', 'load-buffer', '-'],      \    },      \   'paste': {      \      '+': ['tmux', 'save-buffer', '-'],      \      '*': ['tmux', 'save-buffer', '-'],      \   },      \   'cache_enabled': 1,      \ }

If "cache_enabled" isTRUE then when a selection is copied Nvim will cachethe selection until the copy command process dies. When pasting, if the copyprocess has not died the cached selection is applied.

g:clipboard can also use functions (seelambda) instead of strings.For example this configuration uses the g:foo variable as a fake clipboard:

let g:clipboard = {      \   'name': 'myClipboard',      \   'copy': {      \      '+': {lines, regtype -> extend(g:, {'foo': [lines, regtype]}) },      \      '*': {lines, regtype -> extend(g:, {'foo': [lines, regtype]}) },      \    },      \   'paste': {      \      '+': {-> get(g:, 'foo', [])},      \      '*': {-> get(g:, 'foo', [])},      \   },      \ }

The "copy" function stores a list of lines and the register type. The "paste"function returns the clipboard as a[lines, regtype] list, wherelines isa list of lines andregtype is a register type conforming tosetreg().

clipboard-wsl
For Windows WSL, try this g:clipboard definition:

let g:clipboard = {            \   'name': 'WslClipboard',            \   'copy': {            \      '+': 'clip.exe',            \      '*': 'clip.exe',            \    },            \   'paste': {            \      '+': 'powershell.exe -NoLogo -NoProfile -c [Console]::Out.Write($(Get-Clipboard -Raw).tostring().replace("`r", ""))',            \      '*': 'powershell.exe -NoLogo -NoProfile -c [Console]::Out.Write($(Get-Clipboard -Raw).tostring().replace("`r", ""))',            \   },            \   'cache_enabled': 0,            \ }

clipboard-osc52
Nvim bundles a clipboard provider that allows copying to the system clipboardusing OSC 52. OSC 52 is an Operating System Command control sequence thatcauses the terminal emulator to write to or read from the system clipboard.

When Nvim is running in theTUI, it will automatically attempt to determine ifthe host terminal emulator supports OSC 52. If it does, then Nvim will use OSC52 for copying and pasting if no otherclipboard-tool is found and when'clipboard' is unset. NOTE: Using a terminal multiplexer (e.g. tmux) mayinhibit automatic OSC 52 support detection.

g:termfeatures
To disable the automatic detection, set the "osc52" key ofg:termfeatures tov:false in theconfig file. Example:

local termfeatures = vim.g.termfeatures or {}termfeatures.osc52 = falsevim.g.termfeatures = termfeatures

To force Nvim to always use the OSC 52 provider you can use the followingg:clipboard definition:

vim.g.clipboard = 'osc52'

Which is equivalent to:

vim.g.clipboard = {  name = 'OSC 52',  copy = {    ['+'] = require('vim.ui.clipboard.osc52').copy('+'),    ['*'] = require('vim.ui.clipboard.osc52').copy('*'),  },  paste = {    ['+'] = require('vim.ui.clipboard.osc52').paste('+'),    ['*'] = require('vim.ui.clipboard.osc52').paste('*'),  },}

Note that not all terminal emulators support reading from the system clipboard(and even for those that do, users should be aware of the securityimplications), so using OSC 52 for pasting may not be possible (and notnecessary, because you canpaste instead using your system paste function).Users may need to configure their terminal emulator to allow reading from theclipboard.

Pasteprovider-pastepaste

"Paste" is a separate concept fromclipboard: paste means "dump a bunch oftext to the editor", whereas clipboard provides features likequote+ to getand set the OS clipboard directly. For example, middle-click orCTRL-SHIFT-v(macOS: CMD-v) in your terminal is "paste", not "clipboard": the terminalapplication (Nvim) just gets a stream of text, it does not interact with theclipboard directly.

bracketed-paste-mode
Pasting in theTUI depends on the "bracketed paste" terminal capability,which allows terminal applications to distinguish between user input andpasted text.https://cirw.in/blog/bracketed-pasteThis works automatically if your terminal supports it.

ui-paste
GUIs can paste by callingnvim_paste().

PASTE BEHAVIOR

Paste inserts text after the cursor. Lines break at<NL>,<CR>, and<CR><NL>.When pasting a huge amount of text, screen-updates are throttled and themessage area shows a "..." pulse.

In cmdline-mode only the first line is pasted, to avoid accidentally executingmany commands. Use thecmdline-window if you really want to paste multiplelines to the cmdline.

You can implement a custom paste handler by redefiningvim.paste().Example:

vim.paste = (function(lines, phase)  vim.api.nvim_put(lines, 'c', true, true)end)

X11 selection mechanismclipboard-x11x11-selection

X11 clipboard providers store text in "selections". Selections are owned by anapplication, so when the application gets closed, the selection text is lost.The contents of selections are held by the originating application (e.g., upona copy), and only passed to another application when that other applicationrequests them (e.g., upon a paste).

primary-selectionquotestarquoteplusquote+

There are three documented X11 selections: PRIMARY, SECONDARY, and CLIPBOARD.CLIPBOARD is typically used in X11 applications for copy/paste operations(CTRL-c/CTRL-v), while PRIMARY is used for the last selected text, which isgenerally inserted with the middle mouse button.

Nvim's X11 clipboard providers only use the PRIMARY and CLIPBOARD selections,for the "*" and "+" registers, respectively.

Clipboard integration

Paste

X11 selection mechanism