Api
Nvim:help pages,generated fromsource using thetree-sitter-vimdoc parser.
Nvim exposes a powerful API that can be used by plugins and external processesvia
RPC,
Lua and Vimscript (
eval-api).
Applications can also embed libnvim to work with the C API directly.
msgpack-rpcRPC is the main way to control Nvim programmatically. Nvim implements theMessagePack-RPC protocol with these extra (out-of-spec) constraints:
1. Responses must be given in reverse order of requests (like "unwinding a stack").2. Nvim processes all messages (requests and notifications) in the order they are received.
Many clients use the API: user interfaces (GUIs), remote plugins, scripts like"nvr" (
https://github.com/mhinz/neovim-remote). Even Nvim itself can controlother Nvim instances. API clients can:
Call any API function
Listen for events
Receive remote calls from Nvim
The RPC API is like a more powerful version of Vim's "clientserver" feature.
See
channel-intro for various ways to open a channel. Channel-openingfunctions take an
rpc key in the options dict. RPC channels can also beopened by other processes connecting to TCP/IP sockets or named pipes listenedto by Nvim.
Nvim creates a default RPC socket at
startup, given by
v:servername. Tostart with a TCP/IP socket instead, use
--listen with a TCP-style address:
nvim --listen 127.0.0.1:6666
More endpoints can be started with
serverstart().
Note that localhost TCP sockets are generally less secure than named pipes,and can lead to vulnerabilities like remote code execution.
Connecting to the socket is the easiest way a programmer can test the API,which can be done through any msgpack-rpc client library or full-featured
api-client. Here's a Ruby script that prints "hello world!" in the currentNvim instance:
#!/usr/bin/env ruby# Requires msgpack-rpc: gem install msgpack-rpc## To run this script, execute it from a running Nvim instance (notice the# trailing '&' which is required since Nvim won't process events while# running a blocking command):## :!./hello.rb &## Or from another shell by setting NVIM_LISTEN_ADDRESS:# $ NVIM_LISTEN_ADDRESS=[address] ./hello.rbrequire 'msgpack/rpc'require 'msgpack/rpc/transport/unix'nvim = MessagePack::RPC::Client.new(MessagePack::RPC::UNIXTransport.new, ENV['NVIM_LISTEN_ADDRESS'])result = nvim.call(:nvim_command, 'echo "hello world!"')
A better way is to use the Python REPL with the "pynvim" package, where APIfunctions can be called interactively:
>>> from pynvim import attach>>> nvim = attach('socket', path='[address]')>>> nvim.command('echo "hello world!"')You can also embed Nvim via
jobstart(), and communicate using
rpcrequest()and
rpcnotify():
let nvim = jobstart(['nvim', '--embed'], {'rpc': v:true})echo rpcrequest(nvim, 'nvim_eval', '"Hello " . "world!"')call jobstop(nvim)
api-typesThe Nvim C API defines custom types for all function parameters. Some are justtypedefs around C99 standard types, others are Nvim-defined data structures.
Basic types
API Type C type------------------------------------------------------------------------NilBoolean boolInteger (signed 64-bit integer) int64_tFloat (IEEE 754 double precision) doubleString {char* data, size_t size} structArray kvecDict (msgpack: map) kvecObject any of the above Note: Empty Array is accepted as a valid Dictionary parameter.
Functions cannot cross RPC boundaries. But API functions (e.g.
nvim_create_autocmd()) may support Lua function parameters for non-RPC invocations.
Special types (msgpack EXT)
These are integer typedefs discriminated as separate Object subtypes. They can be treated as opaque integers, but are mutually incompatible: Buffer may be passed as an integer but not as Window or Tabpage.
The EXT object data is the (integer) object handle. The EXT type codes given in the
api-metadatatypes key are stable: they will not change and are thus forward-compatible.
EXT Type C type Data------------------------------------------------------------------------Buffer enum value kObjectTypeBuffer |bufnr()|Window enum value kObjectTypeWindow |window-ID|Tabpage enum value kObjectTypeTabpage internal handle
api-indexingMost of the API uses 0-based indices, and ranges are end-exclusive. For theend of a range, -1 denotes the last line/column.
Exception: the following API functions use "mark-like" indexing (1-basedlines, 0-based columns):
Exception: the following API functions use
extmarks indexing (0-basedindices, end-inclusive):
api-fastMost API functions are "deferred": they are queued on the main loop andprocessed sequentially with normal input. So if the editor is waiting foruser input in a "modal" fashion (e.g. the
hit-enter-prompt), the requestwill block. Non-deferred (fast) functions such as
nvim_get_mode() and
nvim_input() are served immediately (i.e. without waiting in the inputqueue). Lua code can use
vim.in_fast_event() to detect a fast context.
The Nvim C API is automatically exposed to RPC by the build system, whichparses headers in src/nvim/api/* and generates dispatch-functions mapping RPCAPI method names to public C API functions, converting/validating argumentsand return values.
Nvim exposes its API metadata as a Dictionary with these items:
version Nvim version, API level/compatibility
version.api_level API version integer
api-level version.api_compatible API is backwards-compatible with this level
version.api_prerelease Declares the API as unstable/unreleased(version.api_prerelease && fn.since == version.api_level)
functions API function signatures, containing
api-types info describing the return value and parameters.
ui_events
UI event signatures
{fn}.since API level where function{fn} was introduced
{fn}.deprecated_since API level where function{fn} was deprecated
types Custom handle types defined by Nvim
error_types Possible error types returned by API functions
About thefunctions map:
Container types may be decorated with type/size constraints, e.g. ArrayOf(Buffer) or ArrayOf(Integer, 2).
Functions considered to be methods that operate on instances of Nvim special types (msgpack EXT) have the "method=true" flag. The receiver type is that of the first argument. Method names are prefixed with
nvim_ plus a type name, e.g.
nvim_buf_get_lines is the
get_lines method of a Buffer instance.
dev-api Global functions have the "method=false" flag and are prefixed with justnvim_, e.g.nvim_list_bufs.
api-mappingExternal programs (clients) can use the metadata to discover the API, usingany of these approaches:
1. Connect to a running Nvim instance and call
nvim_get_api_info() via msgpack-RPC. This is best for clients written in dynamic languages which can define functions at runtime.
2. Start Nvim with
--api-info. Useful for statically-compiled clients. Example (requires Python "pyyaml" and "msgpack-python" modules):
nvim --api-info | python -c 'import msgpack, sys, yaml; yaml.dump(msgpack.unpackb(sys.stdin.buffer.read()), sys.stdout)'
3. Use the
api_info() Vimscript function.
:lua vim.print(vim.fn.api_info())
Example using
filter() to exclude non-deprecated API functions:
:new|put =map(filter(api_info().functions, '!has_key(v:val,''deprecated_since'')'), 'v:val.name')
The Nvim API is composed of functions and events.
Clients call functions like those described at
api-global.
API function names are prefixed with "nvim_".
API event names are prefixed with "nvim_" and suffixed with "_event".
As Nvim evolves the API may change in compliance with this CONTRACT:
New functions and events may be added.
Any such extensions are OPTIONAL: old clients may ignore them.
New functions MAY CHANGE before release. Clients can dynamically check
api_prerelease,
api-metadata.
Function signatures will NOT CHANGE after release, except as follows:
Map/list parameters/results may be EXTENDED (new fields may be added).
Such new fields are OPTIONAL: old clients MAY ignore them.
Existing fields will not be removed.
Return type MAY CHANGE from void to non-void. Old clients MAY ignore the new return value.
An optionalopts parameter may be ADDED.
Optional parameters may be ADDED following anopts parameter.
Event parameters will not be removed or reordered (after release).
Events may be EXTENDED: new parameters may be added.
Deprecated functions will not be removed until Nvim 2.0.
"Private" interfaces are NOT covered by this contract:
Undocumented (not in :help) functions or events of any kind
nvim__x ("double underscore") functions
The idea is "versionless evolution", in the words of Rich Hickey:
Relaxing a requirement should be a compatible change.
Strengthening a promise should be a compatible change.
When a client invokes an API request as an async notification, it is notpossible for Nvim to send an error response. Instead, in case of error, thefollowing notification will be sent to the client:
{type} is a numeric id as defined byapi_info().error_types, and{message} isa string with the error message.
API clients can "attach" to Nvim buffers to subscribe to buffer update events.This is similar to
TextChanged but more powerful and granular.
nvim_buf_lines_eventnvim_buf_lines_event[
{buf},
{changedtick},
{firstline},
{lastline},
{linedata},
{more}]
When the buffer text between{firstline} and{lastline} (end-exclusive, zero-indexed) were changed to the new text in the{linedata} list. The granularity is a line, i.e. if a single character is changed in the editor, the entire line is sent.
When
{changedtick} is
v:null this means the screen lines (display) changed but not the buffer contents.
{linedata} contains the changed screen lines. This happens when
'inccommand' shows a buffer preview.
Properties:
{buf} API buffer handle (buffer number)
{changedtick} value of
b:changedtick for the buffer. If you send an API command back to nvim you can check the value of
b:changedtick as part of your request to ensure that no other changes have been made.
{firstline} integer line number of the first line that was replaced. Zero-indexed: if line 1 was replaced then{firstline} will be 0, not 1.{firstline} is always less than or equal to the number of lines that were in the buffer before the lines were replaced.
{lastline} integer line number of the first line that was not replaced (i.e. the range{firstline},{lastline} is end-exclusive). Zero-indexed: if line numbers 2 to 5 were replaced, this will be 5 instead of 6.{lastline} is always be less than or equal to the number of lines that were in the buffer before the lines were replaced.{lastline} will be -1 if the event is part of the initial update after attaching.
{linedata} list of strings containing the contents of the new buffer lines. Newline characters are omitted; empty lines are sent as empty strings.
{more} boolean, true for a "multipart" change notification: the current change was chunked into multiple
nvim_buf_lines_event notifications (e.g. because it was too big).
When
b:changedtick was incremented but no text was changed. Relevant for undo/redo.
Properties:
{buf} API buffer handle (buffer number)
{changedtick} new value of
b:changedtick for the buffer
When buffer is detached (i.e. updates are disabled). Triggered explicitly by
nvim_buf_detach() or implicitly in these cases:
Generally: whenever the buffer contents are unloaded from memory.
Properties:
{buf} API buffer handle (buffer number)
Calling
nvim_buf_attach() with send_buffer=true on an empty buffer, emits:
nvim_buf_lines_event[{buf}, {changedtick}, 0, -1, [""], v:false]User adds two lines to the buffer, emits:
nvim_buf_lines_event[{buf}, {changedtick}, 0, 0, ["line1", "line2"], v:false]User moves to a line containing the text "Hello world" and inserts "!", emits:
nvim_buf_lines_event[{buf}, {changedtick}, {linenr}, {linenr} + 1, ["Hello world!"], v:false]User moves to line 3 and deletes 20 lines using "20dd", emits:
nvim_buf_lines_event[{buf}, {changedtick}, 2, 22, [], v:false]User selects lines 3-5 using
linewise-visual mode and then types "p" topaste a block of 6 lines, emits:
nvim_buf_lines_event[{buf}, {changedtick}, 2, 5, ['pasted line 1', 'pasted line 2', 'pasted line 3', 'pasted line 4', 'pasted line 5', 'pasted line 6'], v:false]User reloads the buffer with ":edit", emits:
nvim_buf_detach_event[{buf}]LUA
api-buffer-updates-luaIn-process Lua plugins can receive buffer updates in the form of Luacallbacks. These callbacks are called frequently in various contexts;
textlock prevents changing buffer contents and window layout (use
vim.schedule() to defer such operations to the main loop instead).Moving the cursor is allowed, but it is restored afterwards.
nvim_buf_attach() will take keyword args for the callbacks. "on_lines" willreceive parameters ("lines",
{buf},
{changedtick},
{firstline},
{lastline},
{new_lastline},
{old_byte_size} [,
{old_utf32_size},
{old_utf16_size}]).Unlike remote channel events the text contents are not passed. The new text canbe accessed inside the callback as
vim.api.nvim_buf_get_lines(buf, firstline, new_lastline, true)
{old_byte_size} is the total size of the replaced region
{firstline} to
{lastline} in bytes, including the final newline after
{lastline}. if
utf_sizes is set to true in
nvim_buf_attach() keyword args, then theUTF-32 and UTF-16 sizes of the deleted region is also passed as additionalarguments
{old_utf32_size} and
{old_utf16_size}.
"on_changedtick" is invoked when
b:changedtick was incremented but no textwas changed. The parameters received are ("changedtick",
{buf},
{changedtick}).
Nvim allows plugins to add position-based highlights to buffers. This issimilar to
matchaddpos() but with some key differences. The added highlightsare associated with a buffer and adapts to line insertions and deletions,similar to signs. It is also possible to manage a set of highlights as a groupand delete or replace all at once.
The intended use case are linter or semantic highlighter plugins that monitora buffer for changes, and in the background compute highlights to the buffer.Another use case are plugins that show output in an append-only buffer, andwant to add highlights to the outputs. Highlight data cannot be preservedon writing and loading a buffer to file, nor in undo/redo cycles.
Highlights are registered using the
nvim_buf_set_extmark() function, whichadds highlights as
extmarks. If highlights need to be tracked or manipulatedafter adding them, the returned
extmark id can be used.
-- create the highlight through an extmarkextid = vim.api.nvim_buf_set_extmark(buf, ns_id, line, col_start, {end_col = col_end, hl_group = hl_group})-- example: modify the extmark's highlight groupvim.api.nvim_buf_set_extmark(buf, ns_id, line, col_start, {end_col = col_end, hl_group = NEW_HL_GROUP, id = extid})-- example: change the highlight's positionvim.api.nvim_buf_set_extmark(buf, ns_id, NEW_LINE, col_start, {end_col = col_end, hl_group = NEW_HL_GROUP, id = extid})
Floating windows ("floats") are displayed on top of normal windows. This isuseful to implement simple widgets, such as tooltips displayed next to thecursor. Floats are fully functional windows supporting user editing, common
api-window calls, and most window options (except
'statusline').
Two ways to create a floating window:
To check whether a window is floating, check whether the
relative option inits config is non-empty:
if vim.api.nvim_win_get_config(window_id).relative ~= '' then -- window with this window_id is floatingend
Buffer text can be highlighted by typical mechanisms (syntax highlighting,
api-highlights). The
hl-NormalFloat group highlights normal text;
'winhighlight' can be used as usual to override groups locally. Floats inheritoptions from the current window; specify
style=minimal in
nvim_open_win()to disable various visual features such as the
'number' column.
Other highlight groups specific to floating windows:
Currently, floating windows don't support some widgets like scrollbar.
The output of
:mksession does not include commands for restoring floatingwindows.
Example: create a float with scratch buffer:
let buf = nvim_create_buf(v:false, v:true)call nvim_buf_set_lines(buf, 0, -1, v:true, ["test", "text"])let opts = {'relative': 'cursor', 'width': 10, 'height': 2, 'col': 0, \ 'row': 1, 'anchor': 'NW', 'style': 'minimal'}let win = nvim_open_win(buf, 0, opts)" optional: change highlight, otherwise Pmenu is usedcall nvim_set_option_value('winhl', 'Normal:MyHighlight', {'win': win})
Extended marks (extmarks) represent buffer annotations that track text changesin the buffer. They can represent cursors, folds, misspelled words, anythingthat needs to track a logical location in the buffer over time.
api-indexingExtmark position works like a "vertical bar" cursor: it exists betweencharacters. Thus, the maximum extmark index on a line is 1 more than thecharacter index:
f o o b a r line contents 0 1 2 3 4 5 character positions (0-based)0 1 2 3 4 5 6 extmark positions (0-based)
Extmarks have "forward gravity": if you place the cursor directly on anextmark position and enter some text, the extmark migrates forward.
f o o|b a r line (| = cursor) 3 extmarkf o o z|b a r line (| = cursor) 4 extmark (after typing "z")
If an extmark is on the last index of a line and you input a newline at thatpoint, the extmark will accordingly migrate to the next line:
f o o z b a r| line (| = cursor) 7 extmarkf o o z b a r first line extmarks (none present)| second line (| = cursor)0 extmark (after typing <CR>)
Example:
Let's set an extmark at the first row (row=0) and third column (column=2).
api-indexing Passing id=0 creates a new mark and returns the id:
01 23456780 ex|ample.. ^ extmark position
let g:mark_ns = nvim_create_namespace('myplugin')let g:mark_id = nvim_buf_set_extmark(0, g:mark_ns, 0, 2, {})
We can get the mark by its id:
echo nvim_buf_get_extmark_by_id(0, g:mark_ns, g:mark_id, {})" => [0, 2]
We can get all marks in a buffer by
namespace (or by a range):
echo nvim_buf_get_extmarks(0, g:mark_ns, 0, -1, {})" => [[1, 0, 2]]
Deleting all surrounding text does NOT remove an extmark! To remove extmarksuse
nvim_buf_del_extmark(). Deleting "x" in our example:
0 123456780 e|ample.. ^ extmark position
echo nvim_buf_get_extmark_by_id(0, g:mark_ns, g:mark_id, {})" => [0, 1]
Namespaces allow any plugin to manage only its own extmarks, ignoring thosecreated by another plugin.
Extmark positions changed by an edit will be restored on undo/redo. Creatingand deleting extmarks is not a buffer change, thus new undo states are notcreated for extmark changes.
nvim_chan_send(
{chan},
{data})
nvim_chan_send() Send data to channel
id. For a job, it writes it to the stdin of the process. For the stdio channel
channel-stdio, it writes to Nvim's stdout. For an internal terminal instance (
nvim_open_term()) it writes directly to terminal output. See
channel-bytes for more information.
This function writes raw data, not RPC messages. If the channel was created with
rpc=true then the channel expects RPC messages, use
vim.rpcnotify() and
vim.rpcrequest() instead.
Parameters:
{chan} (integer) id of the channel
{data} (string) data to write. 8-bit clean: can contain NUL bytes.
nvim_create_buf(
{listed},
{scratch})
nvim_create_buf() Creates a new, empty, unnamed buffer.
Return:
(
integer) Buffer id, or 0 on error
See also:
buf_open_scratch
Attributes:
not allowed when
textlock is active Since: 0.1.0
Parameters:
{mode} (string)
{lhs} (string)
Note:
Lowercase name (or other buffer-local mark) is an error.
Parameters:
{name} (string) Mark name
Return:
(
boolean) true if the mark was deleted, else false.
Parameters:
{name} (string) Variable name
nvim_echo(
{chunks},
{history},
{opts})
nvim_echo() Prints a message given by a list of
[text, hl_group] "chunks".
Example:
vim.api.nvim_echo({ { 'chunk1-line1\nchunk1-line2\n' }, { 'chunk2-line1' } }, true, {})
Parameters:
{chunks} ([string, integer|string?][]) List of[text, hl_group] pairs, where each is atext string highlighted by the (optional) name or IDhl_group.
{opts} (vim.api.keyset.echo_opts) Optional parameters.
err: Treat the message like
:echoerr. Sets
hl_group to
hl-ErrorMsg by default.
kind: Set the
ui-messages kind with which this message will be emitted.
verbose: Message is controlled by the
'verbose' option. Nvim invoked with
-V3log will write the message to the "log" file instead of standard output.
Parameters:
{opts} (vim.api.keyset.eval_statusline) Optional parameters.
winid: (number)
window-ID of the window to use as context for statusline.
maxwidth: (number) Maximum width of statusline.
fillchar: (string) Character to fill blank spaces in the statusline (see
'fillchars'). Treated as single-width even if it isn't.
highlights: (boolean) Return highlight information.
use_winbar: (boolean) Evaluate winbar instead of statusline.
use_tabline: (boolean) Evaluate tabline instead of statusline. When true,{winid} is ignored. Mutually exclusive with{use_winbar}.
use_statuscol_lnum: (number) Evaluate statuscolumn for this line number instead of statusline.
Return:
(
vim.api.keyset.eval_statusline_ret) Dict containing statusline information, with these keys:
str: (string) Characters that will be displayed on the statusline.
width: (number) Display width of the statusline.
highlights: Array containing highlight information of the statusline. Only included when the "highlights" key in
{opts} is true. Each element of the array is a
Dict with these keys:
start: (number) Byte index (0-based) of first character that uses the highlight.
group: (string) Deprecated. Usegroups instead.
groups: (array) Names of stacked highlight groups (highest priority last).
nvim_exec_lua(
{code},
{args})
nvim_exec_lua() Execute Lua code. Parameters (if any) are available as
... inside the chunk. The chunk can return a value.
Only statements are executed. To evaluate an expression, prefix it withreturn: return my_function(...)
Attributes:
RPC only Since: 0.5.0
Parameters:
{code} (string) Lua code to execute
{args} (any[]) Arguments to the code
Return:
(
any) Return value of Lua code if present or NIL.
nvim_feedkeys(
{keys},
{mode},
{escape_ks})
nvim_feedkeys() Sends input-keys to Nvim, subject to various quirks controlled by
mode flags. This is a blocking call, unlike
nvim_input().
On execution error: does not fail, but updates v:errmsg.
Example:
:let key = nvim_replace_termcodes("<C-o>", v:true, v:false, v:true):call nvim_feedkeys(key, 'n', v:false)
Parameters:
{keys} (string) to be typed
{escape_ks} (
boolean) If true, escape K_SPECIAL bytes in
keys. This should be false if you already used
nvim_replace_termcodes(), and true otherwise.
See also:
feedkeys()
vim_strsave_escape_ks
Return:
(
[any, any]) 2-tuple
[{channel-id}, {api-metadata}]Parameters:
{chan} (integer) channel_id, or 0 for current channel
Return:
(
table<string,any>) Channel info dict with these keys:
"id" Channel id.
"argv" (optional) Job arguments list.
"stream" Stream underlying the channel.
"stdio" stdin and stdout of this Nvim instance
"stderr" stderr of this Nvim instance
"socket" TCP/IP socket or named pipe
"job" Job with communication over its stdio.
"mode" How data received on the channel is interpreted.
"bytes" Send and receive raw bytes.
"terminal"
terminal instance interprets ASCII sequences.
"rpc"
RPC communication on the channel is active.
"pty" (optional) Name of pseudoterminal. On a POSIX system this is a device path like "/dev/pts/1". If unknown, the key will still be present if a pty is used (e.g. for conpty on Windows).
"buffer" (optional) Buffer connected to
terminal instance.
"client" (optional) Info about the peer (client on the other end of the channel), as set by
nvim_set_client_info().
Example:
:echo nvim_get_color_by_name("Pink"):echo nvim_get_color_by_name("#cbcbcb")
Parameters:
{name} (string) Color name or "#rrggbb" string
Return:
(
integer) 24-bit RGB value, or -1 for invalid argument.
Keys are color names (e.g. "Aqua") and values are 24-bit RGB color values (e.g. 65535).
Return:
(
table<string,integer>) Map of color names and RGB values.
Parameters:
{opts} (vim.api.keyset.context) Optional parameters.
types: List of
context-types ("regs", "jumps", "bufs", "gvars", …) to gather, or empty for "all".
Return:
(
table<string,any>) map of global
context.
Return:
(
integer) Buffer id
Return:
(
string) Current line string
nvim_get_hl(
{ns_id},
{opts})
nvim_get_hl() Gets all or specific highlight groups in a namespace.
Note:
When the
link attribute is defined in the highlight definition map, other attributes will not be taking effect (see
:hi-link).
Parameters:
{opts} (vim.api.keyset.get_highlight) Options dict:
name: (string) Get a highlight definition by name.
id: (integer) Get a highlight definition by id.
link: (boolean, default true) Show linked group name instead of effective definition
:hi-link.
create: (boolean, default true) When highlight group doesn't exist create it.
Return:
(
vim.api.keyset.get_hl_info) Highlight groups as a map from group name to a highlight definition map as in
nvim_set_hl(), or only a single highlight definition map if requested by name or id.
similar to
hlID(), but allocates a new ID if not present.
Parameters:
{name} (string)
Attributes:
Since: 0.10.0
Parameters:
{opts} (vim.api.keyset.get_ns) Optional parameters
winid: (number)
window-ID for retrieving a window's highlight namespace. A value of -1 is returned when
nvim_win_set_hl_ns() has not been called for the window (or was called with a namespace of -1).
Return:
(
integer) Namespace id, or -1
Parameters:
{mode} (string) Mode short-name ("n", "i", "v", ...)
Return:
(
vim.api.keyset.get_keymap[]) Array of
maparg()-like dictionaries describing mappings. The "buffer" key is always zero.
nvim_get_mark(
{name},
{opts})
nvim_get_mark() Returns a
(row, col, buffer, buffername) tuple representing the position of the uppercase/file named mark. "End of line" column position is returned as
v:maxcol (big number). See
mark-motions.
Note:
Lowercase name (or other buffer-local mark) is an error.
Parameters:
{name} (string) Mark name
{opts} (vim.api.keyset.empty) Optional parameters. Reserved for future use.
Return:
(
[integer, integer, integer, string]) 4-tuple (row, col, buffer, buffername), (0, 0, 0, '') if the mark is not set.
nvim_get_mode()
nvim_get_mode() Gets the current mode.
mode() "blocking" is true if Nvim is waiting for input.
Return:
(
vim.api.keyset.get_mode) Dict { "mode": String, "blocking": Boolean }
Parameters:
{pid} (integer)
Return:
(
any) Map of process properties, or NIL if process not found.
Parameters:
{pid} (integer)
Return:
(
any[]) Array of child process ids, empty if process not found.
"name" can contain wildcards. For examplenvim_get_runtime_file("colors/*.{vim,lua}", true) will return all color scheme files. Always use forward slashes (/) in the search pattern for subdirectories regardless of platform.
It is not an error to not find any files. An empty array is returned then.
Parameters:
{name} (string) pattern of files to search for
{all} (boolean) whether to return all matches or only the first
Return:
(
string[]) list of absolute paths to the found files
Parameters:
{name} (string) Variable name
Return:
(
any) Variable value
Parameters:
{name} (string) Variable name
Return:
(
any) Variable value
nvim_input(
{keys})
nvim_input() Queues raw user-input. Unlike
nvim_feedkeys(), this uses a low-level input buffer and the call is non-blocking (input is processed asynchronously by the eventloop).
To input blocks of text,
nvim_paste() is much faster and should be preferred.
On execution error: does not fail, but updates v:errmsg.
Note:
keycodes like
<CR> are translated, so "<" is special. To input a literal "<", send
<LT>.
Parameters:
{keys} (string) to be typed
Return:
(
integer) Number of bytes actually written (can be fewer than requested if the buffer becomes full).
nvim_input_mouse()nvim_input_mouse(
{button},
{action},
{modifier},
{grid},
{row},
{col}) Send mouse event from GUI.
Non-blocking: does not wait on any result, but queues the event to be processed soon by the event loop.
Note:
Currently this doesn't support "scripting" multiple mouse events by calling it multiple times in a loop: the intermediate mouse positions will be ignored. It should be used to implement real-time mouse input in a GUI. The deprecated pseudokey form (
<LeftMouse><col,row>) of
nvim_input() has the same limitation.
Parameters:
{button} (string) Mouse button: one of "left", "right", "middle", "wheel", "move", "x1", "x2".
{action} (string) For ordinary buttons, one of "press", "drag", "release". For the wheel, one of "up", "down", "left", "right". Ignored for "move".
{modifier} (string) String of modifiers each represented by a single char. The same specifiers are used as for a key press, except that the "-" separator is optional, so "C-A-", "c-a" and "CA" can all be used to specify Ctrl+Alt+click.
{grid} (
integer) Grid number if the client uses
ui-multigrid, else 0.
{row} (integer) Mouse row-position (zero-based, like redraw events)
{col} (integer) Mouse column-position (zero-based, like redraw events)
Includes unlisted (unloaded/deleted) buffers, like
:ls!. Use
nvim_buf_is_loaded() to check if a buffer is loaded.
Return:
(
integer[]) List of buffer ids
Return:
(
table<string,any>[]) Array of Dictionaries, each describing a channel with the format specified at
nvim_get_chan_info().
Return:
(
string[]) List of paths
Return:
(
integer[]) List of
tab-IDs
nvim_list_uis()
nvim_list_uis() Gets a list of dictionaries representing attached UIs.
Example: The Nvim builtin
TUI sets its channel info as described in
startup-tui. In particular, it sets
client.name to "nvim-tui". So you can check if the TUI is running by inspecting the client name of each UI:
vim.print(vim.api.nvim_get_chan_info(vim.api.nvim_list_uis()[1].chan).client.name)
Return:
(
table<string,any>[]) Array of UI dictionaries, each with these keys:
"height" Requested height of the UI
"width" Requested width of the UI
"rgb" true if the UI uses RGB colors (false implies
cterm-colors)
"ext_..." Requested UI extensions, see
ui-optionParameters:
{dict} (
table<string,any>)
Context map.
nvim_open_term(
{buffer},
{opts})
nvim_open_term() Open a terminal instance in a buffer
By default (and currently the only option) the terminal will not be connected to an external process. Instead, input sent on the channel will be echoed directly by the terminal. This is useful to display ANSI terminal sequences returned as part of an RPC message, or similar.
Note: to directly initiate the terminal using the right size, display the buffer in a configured window before calling this. For instance, for a floating display, first create an empty buffer using
nvim_create_buf(), then display it using
nvim_open_win(), and then call this function. Then
nvim_chan_send() can be called immediately to process sequences in a virtual terminal having the intended size.
Example: this
TermHl command can be used to display and highlight raw ANSI termcodes, so you can use Nvim as a "scrollback pager" (for terminals like kitty):
ansi-colorizeterminal-scrollback-pagervim.api.nvim_create_user_command('TermHl', function() vim.api.nvim_open_term(0, {})end, { desc = 'Highlights ANSI termcodes in curbuf' })
Attributes:
not allowed when
textlock is active Since: 0.5.0
Parameters:
{buffer} (integer) Buffer to use. Buffer contents (if any) will be written to the PTY.
{opts} (vim.api.keyset.open_term) Optional parameters.
on_input: Lua callback for input sent, i e keypresses in terminal mode.
Note: keypresses are sent raw as they would be to the pty master end. For instance, a carriage return is sent as a "\r", not as a "\n".
textlock applies. It is possible to call
nvim_chan_send() directly in the callback however.
["input", term, bufnr, data] force_crlf: (boolean, default true) Convert "\n" to "\r\n".
Return:
(
integer) Channel id, or 0 on error
nvim_paste(
{data},
{crlf},
{phase})
nvim_paste() Pastes at cursor (in any mode), and sets "redo" so dot (
.) will repeat the input. UIs call this to implement "paste", but it's also intended for use by scripts to input large, dot-repeatable blocks of text (as opposed to
nvim_input() which is subject to mappings/events and is thus much slower).
Invokes the
vim.paste() handler, which handles each mode appropriately.
Errors (
'nomodifiable',
vim.paste() failure, …) are reflected in
err but do not affect the return value (which is strictly decided by
vim.paste()). On error or cancel, subsequent calls are ignored ("drained") until the next paste is initiated (phase 1 or -1).
Useful in mappings and scripts to insert multiline text. Example:
vim.keymap.set('n', 'x', function() vim.api.nvim_paste([[ line1 line2 line3 ]], false, -1)end, { buffer = true })
Attributes:
not allowed when
textlock is active Since: 0.4.0
Parameters:
{data} (string) Multiline input. Lines break at LF ("\n"). May be binary (containing NUL bytes).
{crlf} (boolean) Also break lines at CR and CRLF.
{phase} (integer) -1: paste in a single call (i.e. without streaming). To "stream" a paste, callnvim_paste sequentially with thesephase values:
1: starts the paste (exactly once)
2: continues the paste (zero or more times)
3: ends the paste (exactly once)
Return:
(
boolean)
true: Client may continue pasting.
false: Client should cancel the paste.
nvim_put(
{lines},
{type},
{after},
{follow})
nvim_put() Puts text at cursor, in any mode. For dot-repeatable input, use
nvim_paste().
Compare
:put and
p which are always linewise.
Attributes:
not allowed when
textlock is active Since: 0.4.0
Parameters:
{after} (
boolean) If true insert after cursor (like
p), or before (like
P).
{follow} (boolean) If true place cursor at end of inserted text.
nvim_replace_termcodes()nvim_replace_termcodes(
{str},
{from_part},
{do_lt},
{special}) Replaces terminal codes and
keycodes (
<CR>,
<Esc>, ...) in a string with the internal representation.
Parameters:
{str} (string) String to be converted.
{from_part} (boolean) Legacy Vim parameter. Usually true.
{do_lt} (boolean) Also translate<lt>. Ignored ifspecial is false.
{special} (
boolean) Replace
keycodes, e.g.
<CR> becomes a "\r" char.
See also:
replace_termcodes
cpoptions
If neither
ins-completion nor
cmdline-completion popup menu is active this API call is silently ignored. Useful for an external UI using
ui-popupmenu to control the popup menu with the mouse. Can also be used in a mapping; use
<Cmd>:map-cmd or a Lua mapping to ensure the mapping doesn't end completion mode.
Parameters:
{item} (integer) Index (zero-based) of the item to select. Value of -1 selects nothing and restores the original text.
{finish} (boolean) Finish the completion and dismiss the popup menu. Implies{insert}.
{opts} (vim.api.keyset.empty) Optional parameters. Reserved for future use.
nvim_set_client_info()nvim_set_client_info(
{name},
{version},
{type},
{methods},
{attributes}) Self-identifies the client, and sets optional flags on the channel. Defines the
client object returned by
nvim_get_chan_info().
Clients should call this just after connecting, to provide hints for debugging and orchestration. (Note: Something is better than nothing! Fields are optional, but at least setname.)
Can be called more than once; the caller should merge old info if appropriate. Example: library first identifies the channel, then a plugin using that library later identifies itself.
Attributes:
RPC only Since: 0.3.0
Parameters:
{version} (table<string,any>) Dict describing the version, with these (optional) keys:
"major" major version (defaults to 0 if not set, for no release yet)
"minor" minor version
"patch" patch number
"prerelease" string describing a prerelease, like "dev" or "beta1"
"commit" hash or similar identifier of commit
{type} (string) Must be one of the following values. Client libraries should default to "remote" unless overridden by the user.
"remote" remote client connected "Nvim flavored" MessagePack-RPC (responses must be in reverse order of requests).
msgpack-rpc "msgpack-rpc" remote client connected to Nvim via fully MessagePack-RPC compliant protocol.
"ui" gui frontend
"embedder" application using Nvim as a component (for example, IDE/editor implementing a vim mode).
"host" plugin host, typically started by nvim
"plugin" single plugin, started by nvim
{methods} (table<string,any>) Builtin methods in the client. For a host, this does not include plugin methods which will be discovered later. The key should be the method name, the values are dicts with these (optional) keys (more keys may be added in future versions of Nvim, thus unknown keys are ignored. Clients must only use keys defined in this or later versions of Nvim):
"async" if true, send as a notification. If false or unspecified, use a blocking request
"nargs" Number of arguments. Could be a single integer or an array of two integers, minimum and maximum inclusive.
{attributes} (table<string,any>) Arbitrary string:string map of informal client properties. Suggested keys:
"pid": Process id.
"website": Client homepage URL (e.g. GitHub repository)
"license": License description ("Apache 2", "GPLv3", "MIT", …)
"logo": URI or path to image, preferably small logo or icon. .png or .svg format is preferred.
Attributes:
not allowed when
textlock is active or in the
cmdwin Since: 0.1.0
Parameters:
{buffer} (integer) Buffer id
Parameters:
{dir} (string) Directory path
Attributes:
not allowed when
textlock is active Since: 0.1.0
Parameters:
{line} (string) Line contents
Attributes:
not allowed when
textlock is active or in the
cmdwin Since: 0.1.0
Parameters:
{tabpage} (
integer)
tab-ID to focus
Attributes:
not allowed when
textlock is active or in the
cmdwin Since: 0.1.0
nvim_set_hl(
{ns_id},
{name},
{val})
nvim_set_hl() Sets a highlight group.
Note:
Unlike the:highlight command which can update a highlight group, this function completely replaces the definition. For example:nvim_set_hl(0, 'Visual', {}) will clear the highlight group 'Visual'.
The fg and bg keys also accept the string values"fg" or"bg" which act as aliases to the corresponding foreground and background values of the Normal group. If the Normal group has not been defined, using these values results in an error.
If
link is used in combination with other attributes; only the
link will take effect (see
:hi-link).
Parameters:
{name} (string) Highlight group name, e.g. "ErrorMsg"
{val} (vim.api.keyset.highlight) Highlight definition map, accepts the following keys:
fg: color name or "#RRGGBB", see note.
bg: color name or "#RRGGBB", see note.
sp: color name or "#RRGGBB"
blend: integer between 0 and 100
bold: boolean
standout: boolean
underline: boolean
undercurl: boolean
underdouble: boolean
underdotted: boolean
underdashed: boolean
strikethrough: boolean
italic: boolean
reverse: boolean
nocombine: boolean
link: name of another highlight group to link to, see
:hi-link.
ctermfg: Sets foreground of cterm color
ctermfg ctermbg: Sets background of cterm color
ctermbg cterm: cterm attribute map, like
highlight-args. If not set, cterm attributes will match those from the attribute map documented above.
force: if true force update the highlight group when it exists.
Parameters:
{ns_id} (integer) the namespace to use
This function meant to be called while redrawing, primarily from
nvim_set_decoration_provider() on_win and on_line callbacks, which are allowed to change the namespace during a redraw cycle.
Parameters:
{ns_id} (integer) the namespace to activate
Unlike
:map, leading/trailing whitespace is accepted as part of the
{lhs} or
{rhs}. Empty
{rhs} is
<Nop>.
keycodes are replaced as usual.
Example:
call nvim_set_keymap('n', ' <NL>', '', {'nowait': v:true})
is equivalent to:
nmap <nowait> <Space><NL> <Nop>
Parameters:
{mode} (
string) Mode short-name (map command prefix: "n", "i", "v", "x", …) or "!" for
:map!, or empty string for
:map. "ia", "ca" or "!a" for abbreviation in Insert mode, Cmdline mode, or both, respectively
{lhs} (
string) Left-hand-side
{lhs} of the mapping.
{rhs} (
string) Right-hand-side
{rhs} of the mapping.
{opts} (
vim.api.keyset.keymap) Optional parameters map: Accepts all
:map-arguments as keys except
<buffer>, values are booleans (default false). Also:
"desc" human-readable description.
"callback" Lua function called in place of{rhs}.
"replace_keycodes" (boolean) When "expr" is true, replace keycodes in the resulting string (see
nvim_replace_termcodes()). Returning nil from the Lua "callback" is equivalent to returning an empty string.
nvim_set_var(
{name},
{value})
nvim_set_var() Sets a global (g:) variable.
Parameters:
{name} (string) Variable name
{value} (any) Variable value
nvim_set_vvar(
{name},
{value})
nvim_set_vvar() Sets a v: variable, if it is not readonly.
Parameters:
{name} (string) Variable name
{value} (any) Variable value
nvim_strwidth(
{text})
nvim_strwidth() Calculates the number of display cells occupied by
text. Control characters including
<Tab> count as one cell.
Parameters:
{text} (string) Some text
Return:
(
integer) Number of cells
nvim__complete_set(
{index},
{opts})
nvim__complete_set() EXPERIMENTAL: this API may change in the future.
Sets info for the completion item at the given index. If the info text was shown in a window, returns the window and buffer ids, or empty dict if not shown.
Parameters:
{index} (integer) Completion candidate index
{opts} (vim.api.keyset.complete_set) Optional parameters.
info: (string) info text.
Return:
(
table<string,number>) Dict containing these keys:
winid: (number) floating window id
bufnr: (number) buffer id in floating window
Parameters:
{pat} (string[]) pattern of files to search for
{all} (boolean) whether to return all matches or only the first
{opts} (vim.api.keyset.runtime) is_lua: only search Lua subdirs
Return:
(
string[]) list of absolute paths to the found files
nvim__id(
{obj})
nvim__id() Returns object given as argument.
This API function is used for testing. One should not rely on its presence in plugins.
Parameters:
{obj} (any) Object to return.
Return:
(
any) its argument.
This API function is used for testing. One should not rely on its presence in plugins.
Parameters:
{arr} (any[]) Array to return.
Return:
(
any[]) its argument.
This API function is used for testing. One should not rely on its presence in plugins.
Parameters:
{dct} (table<string,any>) Dict to return.
Return:
(
table<string,any>) its argument.
nvim__id_float(
{flt})
nvim__id_float() Returns floating-point value given as argument.
This API function is used for testing. One should not rely on its presence in plugins.
Parameters:
{flt} (number) Value to return.
Return:
(
number) its argument.
nvim__inspect_cell(
{grid},
{row},
{col})
nvim__inspect_cell() NB: if your UI doesn't use hlstate, this will not return hlstate first time.
Parameters:
{grid} (integer)
{row} (integer)
{col} (integer)
nvim__invalidate_glyph_cache()
nvim__invalidate_glyph_cache() For testing. The condition in schar_cache_clear_if_full is hard to reach, so this function can be used to force a cache clear in a test.
nvim__redraw(
{opts})
nvim__redraw() EXPERIMENTAL: this API may change in the future.
Instruct Nvim to redraw various components.
Attributes:
Since: 0.10.0
Parameters:
{opts} (vim.api.keyset.redraw) Optional parameters.
win: Target a specific
window-ID as described below.
buf: Target a specific buffer number as described below.
flush: Update the screen with pending updates.
valid: When present markwin,buf, or all windows for redraw. Whentrue, only redraw changed lines (useful for decoration providers). Whenfalse, forcefully redraw.
range: Redraw a range in
buf, the buffer in
win or the current buffer (useful for decoration providers). Expects a tuple
[first, last] with the first and last line number of the range, 0-based end-exclusive
api-indexing.
cursor: Immediately update cursor position on the screen inwin or the current window.
statusline: Redraw the
'statusline' in
buf,
win or all windows.
winbar: Redraw the
'winbar' in
buf,
win or all windows.
Return:
(
table<string,any>) Map of various internal stats.
On execution error: fails with Vimscript error, updates v:errmsg.
Parameters:
{dict} (
any) Dict, or String evaluating to a Vimscript
self dict
{fn} (string) Name of the function defined on the Vimscript dict
{args} (any[]) Function arguments packed in an Array
Return:
(
any) Result of the function call
nvim_call_function(
{fn},
{args})
nvim_call_function() Calls a Vimscript function with the given arguments.
On execution error: fails with Vimscript error, updates v:errmsg.
Parameters:
{fn} (string) Function to call
{args} (any[]) Function arguments packed in an Array
Return:
(
any) Result of the function call
On execution error: fails with Vimscript error, updates v:errmsg.
Parameters:
{command} (string) Ex command string
On execution error: fails with Vimscript error, updates v:errmsg.
Parameters:
{expr} (string) Vimscript expression string
Return:
(
any) Evaluation result or expanded object
nvim_exec2(
{src},
{opts})
nvim_exec2() Executes Vimscript (multiline block of Ex commands), like anonymous
:source.
Unlike
nvim_command() this function supports heredocs, script-scope (s:), etc.
On execution error: fails with Vimscript error, updates v:errmsg.
Parameters:
{src} (string) Vimscript code
{opts} (vim.api.keyset.exec_opts) Optional parameters.
output: (boolean, default false) Whether to capture and return all (non-error, non-shell
:!) output.
Return:
(
table<string,any>) Dict containing information about execution, with these keys:
output: (string|nil) Output ifopts.output is true.
Parameters:
{expr} (string) Expression to parse. Always treated as a single line.
{flags} (string) Flags:
"m" if multiple expressions in a row are allowed (only the first one will be parsed),
"E" if EOC tokens are not allowed (determines whether they will stop parsing process or be recognized as an operator/space, though also yielding an error).
"l" when needing to start parsing with lvalues for ":let" or ":for". Common flag sets:
"m" to parse like for":echo".
"E" to parse like for"<C-r>=".
empty string for ":call".
"lm" to parse for ":let".
{highlight} (boolean) If true, return value will also include "highlight" key containing array of 4-tuples (arrays) (Integer, Integer, Integer, String), where first three numbers define the highlighted region and represent line, starting column and ending column (latter exclusive: one should highlight region [start_col, end_col)).
Return:
(
table<string,any>)
AST: top-level dict with these keys:
"error": Dict with error, present only if parser saw some error. Contains the following keys:
"message": String, error message in printf format, translated. Must contain exactly one "%.*s".
"arg": String, error message argument.
"len": Amount of bytes successfully parsed. With flags equal to "" that should be equal to the length of expr string. ("Successfully parsed" here means "participated in AST creation", not "till the first error".)
"ast": AST, either nil or a dict with these keys:
"type": node type, one of the value names from ExprASTNodeType stringified without "kExprNode" prefix.
"start": a pair[line, column] describing where node is "started" where "line" is always 0 (will not be 0 if you will be using this API on e.g. ":let", but that is not present yet). Both elements are Integers.
"len": “length” of the node. This and "start" are there for debugging purposes primary (debugging parser and providing debug information).
"children": a list of nodes described in top/"ast". There always is zero, one or two children, key will not be present if node has no children. Maximum number of children may be found in node_maxchildren array.
Local values (present only for certain nodes):
"scope": a single Integer, specifies scope for "Option" and "PlainIdentifier" nodes. For "Option" it is one of ExprOptScope values, for "PlainIdentifier" it is one of ExprVarScope values.
"ident": identifier (without scope, if any), present for "Option", "PlainIdentifier", "PlainKey" and "Environment" nodes.
"name": Integer, register name (one character) or -1. Only present for "Register" nodes.
"cmp_type": String, comparison type, one of the value names from ExprComparisonType, stringified without "kExprCmp" prefix. Only present for "Comparison" nodes.
"ccs_strategy": String, case comparison strategy, one of the value names from ExprCaseCompareStrategy, stringified without "kCCStrategy" prefix. Only present for "Comparison" nodes.
"augmentation": String, augmentation type for "Assignment" nodes. Is either an empty string, "Add", "Subtract" or "Concat" for "=", "+=", "-=" or ".=" respectively.
"invert": Boolean, true if result of comparison needs to be inverted. Only present for "Comparison" nodes.
"ivalue": Integer, integer value for "Integer" nodes.
"fvalue": Float, floating-point value for "Float" nodes.
"svalue": String, value for "SingleQuotedString" and "DoubleQuotedString" nodes.
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer.
{name} (string)
{command} (any)
{opts} (vim.api.keyset.user_command)
See also:
nvim_create_user_command
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer.
{name} (string) Name of the command to delete.
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{opts} (vim.api.keyset.get_commands) Optional parameters. Currently not used.
Return:
(
vim.api.keyset.command_info) Map of maps describing commands.
nvim_cmd(
{cmd},
{opts})
nvim_cmd() Executes an Ex command.
Unlike
nvim_command() this command takes a structured Dict instead of a String. This allows for easier construction and manipulation of an Ex command. This also allows for things such as having spaces inside a command argument, expanding filenames in a command that otherwise doesn't expand filenames, etc. Command arguments may also be Number, Boolean or String.
The first argument may also be used instead of count for commands that support it in order to make their usage simpler with
vim.cmd(). For example, instead of
vim.cmd.bdelete{ count = 2 }, you may do
vim.cmd.bdelete(2).
On execution error: fails with Vimscript error, updates v:errmsg.
Parameters:
{cmd} (
vim.api.keyset.cmd) Command to execute. Must be a Dict that can contain the same values as the return value of
nvim_parse_cmd() except "addr", "nargs" and "nextcmd" which are ignored if provided. All values except for "cmd" are optional.
{opts} (vim.api.keyset.cmd_opts) Optional parameters.
output: (boolean, default false) Whether to return command output.
Return:
(
string) Command output (non-error, non-shell
:!) if
output is true, else empty string.
Example:
:call nvim_create_user_command('SayHello', 'echo "Hello world!"', {'bang': v:true}):SayHelloHello world!
Parameters:
{name} (string) Name of the new user command. Must begin with an uppercase letter.
{command} (string|fun(args: vim.api.keyset.create_user_command.command_args)) Replacement command to execute when this user command is executed. When called from Lua, the command can also be a Lua function. The function is called with a single table argument that contains the following keys:
name: (string) Command name
args: (string) The args passed to the command, if any<args>
fargs: (table) The args split by unescaped whitespace (when more than one argument is allowed), if any<f-args>
bang: (boolean) "true" if the command was executed with a ! modifier<bang>
line1: (number) The starting line of the command range<line1>
line2: (number) The final line of the command range<line2>
range: (number) The number of items in the command range: 0, 1, or 2<range>
count: (number) Any count supplied<count>
reg: (string) The optional register, if specified<reg>
mods: (string) Command modifiers, if any<mods>
smods: (table) Command modifiers in a structured format. Has the same structure as the "mods" key of
nvim_parse_cmd().
Other parameters:
desc: (string) Used for listing the command when a Lua function is used for{command}.
force: (boolean, default true) Override any previous definition.
Parameters:
{name} (string) Name of the command to delete.
nvim_get_commands(
{opts})
nvim_get_commands() Gets a map of global (non-buffer-local) Ex commands.
Currently only
user-commands are supported, not builtin Ex commands.
Parameters:
{opts} (vim.api.keyset.get_commands) Optional parameters. Currently only supports{"builtin":false}
Return:
(
table<string,vim.api.keyset.command_info>) Map of maps describing commands.
Doesn't check the validity of command arguments.
Parameters:
{str} (string) Command line string to parse. Cannot contain "\n".
{opts} (vim.api.keyset.empty) Optional parameters. Reserved for future use.
Return:
(
vim.api.keyset.cmd) Dict containing command information, with these keys:
cmd: (string) Command name.
range: (array) (optional) Command range (<line1><line2>). Omitted if command doesn't accept a range. Otherwise, has no elements if no range was specified, one element if only a single range item was specified, or two elements if both range items were specified.
count: (number) (optional) Command<count>. Omitted if command cannot take a count.
reg: (string) (optional) Command<register>. Omitted if command cannot take a register.
bang: (boolean) Whether command contains a<bang> (!) modifier.
args: (array) Command arguments.
addr: (string) Value of
:command-addr. Uses short name or "line" for -addr=lines.
nextcmd: (string) Next command if there are multiple commands separated by a
:bar. Empty if there isn't a next command.
magic: (dict) Which characters have special meaning in the command arguments.
file: (boolean) The command expands filenames. Which means characters such as "%", "#" and wildcards are expanded.
bar: (boolean) The "|" character is treated as a command separator and the double quote character (") is treated as the start of a comment.
pattern: (string) Filter pattern. Empty string if there is no filter.
force: (boolean) Whether filter is inverted or not.
tab: (integer)
:tab. -1 when omitted.
verbose: (integer)
:verbose. -1 when omitted.
split: (string) Split modifier string, is an empty string when there's no split modifier. If there is a split modifier it can be one of:
Return:
(
table<string,any>) dict of all options
nvim_get_option_info2(
{name},
{opts})
nvim_get_option_info2() Gets the option information for one option from arbitrary buffer or window
Resulting dict has keys:
shortname: Shortened name of the option (like
'ft')
type: type of option ("string", "number" or "boolean")
default: The default value for the option
was_set: Whether the option was set.
last_set_sid: Last set script id (if any)
last_set_linenr: line number where option was set
last_set_chan: Channel where option was set (0 for local)
scope: one of "global", "win", or "buf"
global_local: whether win or buf option has a global value
commalist: List of comma separated values
flaglist: List of single char flags
When{scope} is not provided, the last set information applies to the local value in the current buffer or window if it is available, otherwise the global value information is returned. This behavior can be disabled by explicitly specifying{scope} in the{opts} table.
Parameters:
{name} (string) Option name
{opts} (vim.api.keyset.option) Optional parameters
win:
window-ID. Used for getting window local options.
buf: Buffer number. Used for getting buffer local options. Implies{scope} is "local".
Return:
(
vim.api.keyset.get_option_info) Option Information
nvim_get_option_value(
{name},
{opts})
nvim_get_option_value() Gets the value of an option. The behavior of this function matches that of
:set: the local value of an option is returned if it exists; otherwise, the global value is returned. Local values always correspond to the current buffer or window, unless "buf" or "win" is set in
{opts}.
Parameters:
{name} (string) Option name
{opts} (vim.api.keyset.option) Optional parameters
win:
window-ID. Used for getting window local options.
buf: Buffer number. Used for getting buffer local options. Implies{scope} is "local".
filetype:
filetype. Used to get the default option for a specific filetype. Cannot be used with any other option.
Note: this will trigger
ftplugin and all
FileType autocommands for the corresponding filetype.
Return:
(
any) Option value
nvim_set_option_value()nvim_set_option_value(
{name},
{value},
{opts}) Sets the value of an option. The behavior of this function matches that of
:set: for global-local options, both the global and local value are set unless otherwise specified with
{scope}.
Note the options{win} and{buf} cannot be used together.
Parameters:
{name} (string) Option name
{value} (any) New option value
{opts} (vim.api.keyset.option) Optional parameters
win:
window-ID. Used for setting window local option.
buf: Buffer number. Used for setting buffer local option.
For more information on buffers, see
buffers.
Buffers may be unloaded by the
:bunload command or the buffer's
'bufhidden' option. When a buffer is unloaded its file contents are freedfrom memory and vim cannot operate on the buffer lines until it is reloaded(usually by opening the buffer again in a new window). API methods such as
nvim_buf_get_lines() and
nvim_buf_line_count() will be affected.
Example (Lua): capture buffer updates in a global
events variable (use "vim.print(events)" to see its contents):
events = {}vim.api.nvim_buf_attach(0, false, { on_lines = function(...) table.insert(events, {...}) end,})
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{send_buffer} (boolean) True if the initial notification should contain the whole buffer: first notification will benvim_buf_lines_event. Else the first notification will benvim_buf_changedtick_event. Not for Lua callbacks.
{opts} (vim.api.keyset.buf_attach) Optional parameters.
on_lines: Lua callback invoked on change. Return a truthy value (notfalse ornil) to detach. Args:
the string "lines"
buffer id
b:changedtick
first line that changed (zero-indexed)
last line that was changed
last line in the updated range
byte count of previous contents
deleted_codepoints (ifutf_sizes is true)
deleted_codeunits (ifutf_sizes is true)
on_bytes: Lua callback invoked on change. This callback receives more granular information about the change compared to on_lines. Return a truthy value (notfalse ornil) to detach. Args:
the string "bytes"
buffer id
b:changedtick
start row of the changed text (zero-indexed)
start column of the changed text
byte offset of the changed text (from the start of the buffer)
old end row of the changed text (offset from start row)
old end column of the changed text (if old end row = 0, offset from start column)
old end byte length of the changed text
new end row of the changed text (offset from start row)
new end column of the changed text (if new end row = 0, offset from start column)
new end byte length of the changed text
on_changedtick: Lua callback invoked on changedtick increment without text change. Args:
the string "changedtick"
buffer id
b:changedtick
on_detach: Lua callback invoked on detach. Args:
the string "detach"
buffer id
on_reload: Lua callback invoked on reload. The entire buffer content should be considered changed. Args:
the string "reload"
buffer id
utf_sizes: include UTF-32 and UTF-16 size of the replaced region, as args toon_lines.
preview: also attach to command preview (i.e.
'inccommand') events.
Return:
(
boolean) False if attach failed (invalid parameter, or buffer isn't loaded); otherwise True. TODO: LUA_API_NO_EVAL
nvim_buf_call(
{buffer},
{fun})
nvim_buf_call() Call a function with buffer as temporary current buffer.
This temporarily switches current buffer to "buffer". If the current window already shows "buffer", the window is not switched. If a window inside the current tabpage (including a float) already shows the buffer, then one of those windows will be set as current window temporarily. Otherwise a temporary scratch window (called the "autocmd window" for historical reasons) will be used.
This is useful e.g. to call Vimscript functions that only work with the current buffer/window currently, likejobstart(…, {'term': v:true}).
Attributes:
Lua
vim.api only Since: 0.5.0
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{fun} (function) Function to call inside the buffer (currently Lua callable only)
Return:
(
any) Return value of function.
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{mode} (string)
{lhs} (string)
Note:
only deletes marks set in the buffer, if the mark is not set in the buffer it will return false.
Parameters:
{buffer} (integer) Buffer to set the mark on
{name} (string) Mark name
Return:
(
boolean) true if the mark was deleted, else false.
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{name} (string) Variable name
To get
:bdelete behavior, reset
'buflisted' and pass
unload=true:
vim.bo.buflisted = falsevim.api.nvim_buf_delete(0, { unload = true })
Attributes:
not allowed when
textlock is active or in the
cmdwin Since: 0.5.0
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{opts} (vim.api.keyset.buf_delete) Optional parameters. Keys:
force: Force deletion, ignore unsaved changes.
unload: Unloaded only (
:bunload), do not delete.
nvim_buf_detach(
{buffer})
nvim_buf_detach() Deactivates buffer-update events on the channel.
Attributes:
RPC only Since: 0.3.0
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
Return:
(
boolean) False if detach failed (because the buffer isn't loaded); otherwise True.
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
Return:
(
integer)
b:changedtick value.
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{mode} (string) Mode short-name ("n", "i", "v", ...)
Return:
(
vim.api.keyset.get_keymap[]) Array of
maparg()-like dictionaries describing mappings. The "buffer" key holds the associated buffer id.
nvim_buf_get_lines()nvim_buf_get_lines(
{buffer},
{start},
{end},
{strict_indexing}) Gets a line-range from the buffer.
Indexing is zero-based, end-exclusive. Negative indices are interpreted as length+1+index: -1 refers to the index past the end. So to get the last element use start=-2 and end=-1.
Out-of-bounds indices are clamped to the nearest valid value, unlessstrict_indexing is set.
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{start} (integer) First line index
{end} (integer) Last line index, exclusive
{strict_indexing} (boolean) Whether out-of-bounds should be an error.
Return:
(
string[]) Array of lines, or empty array for unloaded buffer.
nvim_buf_get_mark(
{buffer},
{name})
nvim_buf_get_mark() Returns a
(row,col) tuple representing the position of the named mark. "End of line" column position is returned as
v:maxcol (big number). See
mark-motions.
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{name} (string) Mark name
Return:
(
[integer, integer]) (row, col) tuple, (0, 0) if the mark is not set, or is an uppercase/file mark set in another buffer.
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
Return:
(
string) Buffer name
Line 1 (index=0) has offset 0. UTF-8 bytes are counted. EOL is one byte.
'fileformat' and
'fileencoding' are ignored. The line index just after the last line gives the total byte-count of the buffer. A final EOL byte is counted if it would be written, see
'eol'.
Unlike
line2byte(), throws error for out-of-bounds indexing. Returns -1 for unloaded buffer.
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{index} (integer) Line index
Return:
(
integer) Integer byte offset, or -1 for unloaded buffer.
Indexing is zero-based. Row indices are end-inclusive, and column indices are end-exclusive.
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{start_row} (integer) First line index
{start_col} (integer) Starting column (byte offset) on first line
{end_row} (integer) Last line index, inclusive
{end_col} (integer) Ending column (byte offset) on last line, exclusive
{opts} (vim.api.keyset.empty) Optional parameters. Currently unused.
Return:
(
string[]) Array of lines, or empty array for unloaded buffer.
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{name} (string) Variable name
Return:
(
any) Variable value
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
Return:
(
boolean) true if the buffer is valid and loaded, false otherwise.
Note:
Even if a buffer is valid it may have been unloaded. See
api-buffer for more info about unloaded buffers.
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
Return:
(
boolean) true if the buffer is valid, false otherwise.
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
Return:
(
integer) Line count, or 0 for unloaded buffer.
api-bufferParameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{mode} (string)
{lhs} (string)
{rhs} (string)
{opts} (vim.api.keyset.keymap)
nvim_buf_set_lines()nvim_buf_set_lines(
{buffer},
{start},
{end},
{strict_indexing},
{replacement}) Sets (replaces) a line-range in the buffer.
Indexing is zero-based, end-exclusive. Negative indices are interpreted as length+1+index: -1 refers to the index past the end. So to change or delete the last line use start=-2 and end=-1.
To insert lines at a given index, setstart andend to the same index. To delete a range of lines, setreplacement to an empty array.
Out-of-bounds indices are clamped to the nearest valid value, unlessstrict_indexing is set.
Attributes:
not allowed when
textlock is active Since: 0.1.0
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{start} (integer) First line index
{end} (integer) Last line index, exclusive
{strict_indexing} (boolean) Whether out-of-bounds should be an error.
{replacement} (string[]) Array of lines to use as replacement
nvim_buf_set_mark()nvim_buf_set_mark(
{buffer},
{name},
{line},
{col},
{opts}) Sets a named mark in the given buffer, all marks are allowed file/uppercase, visual, last change, etc. See
mark-motions.
Note:
Passing 0 as line deletes the mark
Parameters:
{buffer} (integer) Buffer to set the mark on
{name} (string) Mark name
{line} (integer) Line number
{col} (integer) Column/row number
{opts} (vim.api.keyset.empty) Optional parameters. Reserved for future use.
Return:
(
boolean) true if the mark was set, else false.
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{name} (string) Buffer name
nvim_buf_set_text()nvim_buf_set_text(
{buffer},
{start_row},
{start_col},
{end_row},
{end_col},
{replacement}) Sets (replaces) a range in the buffer
This is recommended over
nvim_buf_set_lines() when only modifying parts of a line, as extmarks will be preserved on non-modified parts of the touched lines.
Indexing is zero-based. Row indices are end-inclusive, and column indices are end-exclusive.
To insert text at a given(row, column) location, usestart_row = end_row = row andstart_col = end_col = col. To delete the text in a range, usereplacement = {}.
Attributes:
not allowed when
textlock is active Since: 0.5.0
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{start_row} (integer) First line index
{start_col} (integer) Starting column (byte offset) on first line
{end_row} (integer) Last line index, inclusive
{end_col} (integer) Ending column (byte offset) on last line, exclusive
{replacement} (string[]) Array of lines to use as replacement
nvim_buf_set_var(
{buffer},
{name},
{value})
nvim_buf_set_var() Sets a buffer-scoped (b:) variable
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{name} (string) Variable name
{value} (any) Variable value
Lines are 0-indexed.
api-indexing To clear the namespace in the entire buffer, specify line_start=0 and line_end=-1.
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{ns_id} (integer) Namespace to clear, or -1 to clear all namespaces.
{line_start} (integer) Start of range of lines to clear
{line_end} (integer) End of range of lines to clear (exclusive) or -1 to clear to end of buffer.
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{id} (integer) Extmark id
Return:
(
boolean) true if the extmark was found, else false
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{id} (integer) Extmark id
{opts} (vim.api.keyset.get_extmark) Optional parameters. Keys:
details: Whether to include the details dict
hl_name: Whether to include highlight group name instead of id, true if omitted
Return:
(
[integer, integer, vim.api.keyset.extmark_details?]) 0-indexed (row, col) tuple or empty list () if extmark id was absent
Region can be given as (row,col) tuples, or valid extmark ids (whose positions define the bounds). 0 and -1 are understood as (0,0) and (-1,-1) respectively, thus the following are equivalent:
vim.api.nvim_buf_get_extmarks(0, my_ns, 0, -1, {})vim.api.nvim_buf_get_extmarks(0, my_ns, {0,0}, {-1,-1}, {})
Ifend is less thanstart, marks are returned in reverse order. (Useful withlimit, to get the first marks prior to a given position.)
Note: For a reverse range,limit does not actually affect the traversed range, just how many marks are returned
Note: when using extmark ranges (marks with a end_row/end_col position) theoverlap option might be useful. Otherwise only the start position of an extmark will be considered.
Note: legacy signs placed through the
:sign commands are implemented as extmarks and will show up here. Their details array will contain a
sign_name field.
Example:
local api = vim.apilocal pos = api.nvim_win_get_cursor(0)local ns = api.nvim_create_namespace('my-plugin')-- Create new extmark at line 1, column 1.local m1 = api.nvim_buf_set_extmark(0, ns, 0, 0, {})-- Create new extmark at line 3, column 1.local m2 = api.nvim_buf_set_extmark(0, ns, 2, 0, {})-- Get extmarks only from line 3.local ms = api.nvim_buf_get_extmarks(0, ns, {2,0}, {2,0}, {})-- Get all marks in this buffer + namespace.local all = api.nvim_buf_get_extmarks(0, ns, 0, -1, {})vim.print(ms)
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{start} (
any) Start of range: a 0-indexed (row, col) or valid extmark id (whose position defines the bound).
api-indexing{end} (
any) End of range (inclusive): a 0-indexed (row, col) or valid extmark id (whose position defines the bound).
api-indexing{opts} (vim.api.keyset.get_extmarks) Optional parameters. Keys:
limit: Maximum number of marks to return
details: Whether to include the details dict
hl_name: Whether to include highlight group name instead of id, true if omitted
overlap: Also include marks which overlap the range, even if their start position is less thanstart
type: Filter marks by type: "highlight", "sign", "virt_text" and "virt_lines"
Return:
(
vim.api.keyset.get_extmark_item[]) List of
[extmark_id, row, col] tuples in "traversal order".
By default a new extmark is created when no id is passed in, but it is also possible to create a new mark by passing in a previously unused id or move an existing mark by passing in its id. The caller must then keep track of existing and unused ids itself. (Useful over RPC, to avoid waiting for the return value.)
Using the optional arguments, it is possible to use this to highlight a range of text, and also to associate virtual text to the mark.
If present, the position defined byend_col andend_row should be after the start position in order for the extmark to cover a range. An earlier end position is not an error, but then it behaves like an empty range (no highlighting).
Parameters:
{buffer} (integer) Buffer id, or 0 for current buffer
{line} (
integer) Line where to place the mark, 0-based.
api-indexing{col} (
integer) Column where to place the mark, 0-based.
api-indexing{opts} (vim.api.keyset.set_extmark) Optional parameters.
id : id of the extmark to edit.
end_row : ending line of the mark, 0-based inclusive.
end_col : ending col of the mark, 0-based exclusive.
hl_group : highlight group used for the text range. This and below highlight groups can be supplied either as a string or as an integer, the latter of which can be obtained using
nvim_get_hl_id_by_name(). Multiple highlight groups can be stacked by passing an array (highest priority last).
hl_eol : when true, for a multiline highlight covering the EOL of a line, continue the highlight for the rest of the screen line (just like for diff and cursorline highlight).
virt_text :
virtual-text to link to this mark. A list of
[text, highlight] tuples, each representing a text chunk with specified highlight.
highlight element can either be a single highlight group, or an array of multiple highlight groups that will be stacked (highest priority last).
virt_text_pos : position of virtual text. Possible values:
"eol": right after eol character (default).
"eol_right_align": display right aligned in the window unless the virtual text is longer than the space available. If the virtual text is too long, it is truncated to fit in the window after the EOL character. If the line is wrapped, the virtual text is shown after the end of the line rather than the previous screen line.
"overlay": display over the specified column, without shifting the underlying text.
"right_align": display right aligned in the window.
"inline": display at the specified column, and shift the buffer text to the right as needed.
virt_text_win_col : position the virtual text at a fixed window column (starting from the first text column of the screen line) instead of "virt_text_pos".
virt_text_hide : hide the virtual text when the background text is selected or hidden because of scrolling with
'nowrap' or
'smoothscroll'. Currently only affects "overlay" virt_text.
virt_text_repeat_linebreak : repeat the virtual text on wrapped lines.
hl_mode : control how highlights are combined with the highlights of the text. Currently only affects virt_text highlights, but might affecthl_group in later versions.
"replace": only show the virt_text color. This is the default.
"combine": combine with background text color.
"blend": blend with background text color. Not supported for "inline" virt_text.
virt_lines : virtual lines to add next to this mark This should be an array over lines, where each line in turn is an array over
[text, highlight] tuples. In general, buffer and window options do not affect the display of the text. In particular
'wrap' and
'linebreak' options do not take effect, so the number of extra screen lines will always match the size of the array. However the
'tabstop' buffer option is still used for hard tabs. By default lines are placed below the buffer line containing the mark.
virt_lines_above: place virtual lines above instead.
virt_lines_leftcol: Place virtual lines in the leftmost column of the window, bypassing sign and number columns.
virt_lines_overflow: controls how to handle virtual lines wider than the window. Currently takes the one of the following values:
"trunc": truncate virtual lines on the right (default).
"scroll": virtual lines can scroll horizontally with
'nowrap', otherwise the same as "trunc".
ephemeral : for use with
nvim_set_decoration_provider() callbacks. The mark will only be used for the current redraw cycle, and not be permanently stored in the buffer.
right_gravity : boolean that indicates the direction the extmark will be shifted in when new text is inserted (true for right, false for left). Defaults to true.
end_right_gravity : boolean that indicates the direction the extmark end position (if it exists) will be shifted in when new text is inserted (true for right, false for left). Defaults to false.
undo_restore : Restore the exact position of the mark if text around the mark was deleted and then restored by undo. Defaults to true.
invalidate : boolean that indicates whether to hide the extmark if the entirety of its range is deleted. For hidden marks, an "invalid" key is added to the "details" array of
nvim_buf_get_extmarks() and family. If "undo_restore" is false, the extmark is deleted instead.
priority: a priority value for the highlight group, sign attribute or virtual text. For virtual text, item with highest priority is drawn last. For example treesitter highlighting uses a value of 100.
strict: boolean that indicates extmark should not be placed if the line or column value is past the end of the buffer or end of the line respectively. Defaults to true.
sign_text: string of length 1-2 used to display in the sign column.
sign_hl_group: highlight group used for the sign column text.
number_hl_group: highlight group used for the number column.
line_hl_group: highlight group used for the whole line.
cursorline_hl_group: highlight group used for the sign column text when the cursor is on the same line as the mark and
'cursorline' is enabled.
conceal: string which should be either empty or a single character. Enable concealing similar to
:syn-conceal. When a character is supplied it is used as
:syn-cchar. "hl_group" is used as highlight for the cchar if provided, otherwise it defaults to
hl-Conceal.
conceal_lines: string which should be empty. When provided, lines in the range are not drawn at all (according to
'conceallevel'); the next unconcealed line is drawn instead.
spell: boolean indicating that spell checking should be performed within this extmark
ui_watched: boolean that indicates the mark should be drawn by a UI. When set, the UI will receive win_extmark events. Note: the mark is positioned by virt_text attributes. Can be used together with virt_text.
url: A URL to associate with this extmark. In the TUI, the OSC 8 control sequence is used to generate a clickable hyperlink to this URL.
Return:
(
integer) Id of the created/updated extmark
Namespaces can be named or anonymous. Ifname matches an existing namespace, the associated id is returned. Ifname is an empty string a new, anonymous namespace is created.
Parameters:
{name} (string) Namespace name or empty string
Return:
(
integer) Namespace id
Return:
(
table<string,integer>) dict that maps from names to namespace ids.
This is a very general purpose interface for having Lua callbacks being triggered during the redraw code.
The expected usage is to set
extmarks for the currently redrawn buffer.
nvim_buf_set_extmark() can be called to add marks on a per-window or per-lines basis. Use the
ephemeral key to only use the mark for the current screen redraw (the callback will be called again for the next redraw).
Note: this function should not be called often. Rather, the callbacks themselves can be used to throttle unneeded callbacks. theon_start callback can returnfalse to disable the provider until the next redraw. Similarly, returnfalse inon_win will skip theon_line calls for that window (but any extmarks set inon_win will still be used). A plugin managing multiple sources of decoration should ideally only set one provider, and merge the sources internally. You can use multiplens_id for the extmarks set/modified inside the callback anyway.
Note: doing anything other than setting extmarks is considered experimental. Doing things like changing options are not explicitly forbidden, but is likely to have unexpected consequences (such as 100% CPU consumption). Doingvim.rpcnotify should be OK, butvim.rpcrequest is quite dubious for the moment.
Note: It is not allowed to remove or update extmarks inon_line callbacks.
Attributes:
Lua
vim.api only Since: 0.5.0
Parameters:
{opts} (vim.api.keyset.set_decoration_provider) Table of callbacks:
on_start: called first on each screen redraw
["start", tick]
on_buf: called for each buffer being redrawn (once per edit, before window callbacks)
["buf", bufnr, tick]
on_win: called when starting to redraw a specific window.
["win", winid, bufnr, toprow, botrow]
on_line: called for each buffer line being redrawn. (The interaction with fold lines is subject to change)
["line", winid, bufnr, row]
on_end: called at the end of a redraw cycle
["end", tick]
nvim__ns_get(
{ns_id})
nvim__ns_get() EXPERIMENTAL: this API will change in the future.
Get the properties for namespace
Parameters:
{ns_id} (integer) Namespace
Return:
(
vim.api.keyset.ns_opts) Map defining the namespace properties, see
nvim__ns_set()nvim__ns_set(
{ns_id},
{opts})
nvim__ns_set() EXPERIMENTAL: this API will change in the future.
Set some properties for namespace
Parameters:
{ns_id} (integer) Namespace
{opts} (vim.api.keyset.ns_opts) Optional parameters to set:
wins: a list of windows to be scoped in
nvim_win_call(
{window},
{fun})
nvim_win_call() Calls a function with window as temporary current window.
Attributes:
Lua
vim.api only Since: 0.5.0
Parameters:
{window} (
integer)
window-ID, or 0 for current window
{fun} (function) Function to call inside the window (currently Lua callable only)
Return:
(
any) Return value of function.
Attributes:
not allowed when
textlock is active Since: 0.4.0
Parameters:
{window} (
integer)
window-ID, or 0 for current window
{force} (
boolean) Behave like
:close! The last window of a buffer with unwritten changes can be closed. The buffer will become hidden, even if
'hidden' is not set.
Parameters:
{window} (
integer)
window-ID, or 0 for current window
{name} (string) Variable name
Parameters:
{window} (
integer)
window-ID, or 0 for current window
Return:
(
integer) Buffer id
nvim_win_get_cursor(
{window})
nvim_win_get_cursor() Gets the (1,0)-indexed, buffer-relative cursor position for a given window (different windows showing the same buffer have independent cursor positions).
api-indexingParameters:
{window} (
integer)
window-ID, or 0 for current window
Return:
(
[integer, integer]) (row, col) tuple
Parameters:
{window} (
integer)
window-ID, or 0 for current window
Return:
(
integer) Height as a count of rows
Parameters:
{window} (
integer)
window-ID, or 0 for current window
Return:
(
integer) Window number
nvim_win_get_position(
{window})
nvim_win_get_position() Gets the window position in display cells. First position is zero.
Parameters:
{window} (
integer)
window-ID, or 0 for current window
Return:
(
[integer, integer]) (row, col) tuple with the window position
Parameters:
{window} (
integer)
window-ID, or 0 for current window
Return:
(
integer) Tabpage that contains the window
Parameters:
{window} (
integer)
window-ID, or 0 for current window
{name} (string) Variable name
Return:
(
any) Variable value
Parameters:
{window} (
integer)
window-ID, or 0 for current window
Return:
(
integer) Width as a count of columns
Attributes:
not allowed when
textlock is active Since: 0.5.0
Parameters:
{window} (
integer)
window-ID, or 0 for current window
Parameters:
{window} (
integer)
window-ID, or 0 for current window
Return:
(
boolean) true if the window is valid, false otherwise
nvim_win_set_buf(
{window},
{buffer})
nvim_win_set_buf() Sets the current buffer in a window, without side effects
Attributes:
not allowed when
textlock is active Since: 0.3.2
Parameters:
{window} (
integer)
window-ID, or 0 for current window
{buffer} (integer) Buffer id
nvim_win_set_cursor(
{window},
{pos})
nvim_win_set_cursor() Sets the (1,0)-indexed cursor position in the window.
api-indexing This scrolls the window even if it is not the current one.
Parameters:
{window} (
integer)
window-ID, or 0 for current window
{pos} ([integer, integer]) (row, col) tuple representing the new position
Parameters:
{window} (
integer)
window-ID, or 0 for current window
{height} (integer) Height as a count of rows
nvim_win_set_hl_ns(
{window},
{ns_id})
nvim_win_set_hl_ns() Set highlight namespace for a window. This will use highlights defined with
nvim_set_hl() for this namespace, but fall back to global highlights (ns=0) when missing.
Parameters:
{window} (integer)
{ns_id} (integer) the namespace to use
nvim_win_set_var(
{window},
{name},
{value})
nvim_win_set_var() Sets a window-scoped (w:) variable
Parameters:
{window} (
integer)
window-ID, or 0 for current window
{name} (string) Variable name
{value} (any) Variable value
nvim_win_set_width(
{window},
{width})
nvim_win_set_width() Sets the window width. This will only succeed if the screen is split vertically.
Parameters:
{window} (
integer)
window-ID, or 0 for current window
{width} (integer) Width as a count of columns
nvim_win_text_height(
{window},
{opts})
nvim_win_text_height() Computes the number of screen lines occupied by a range of text in a given window. Works for off-screen text and takes folds into account.
Diff filler or virtual lines above a line are counted as a part of that line, unless the line is on "start_row" and "start_vcol" is specified.
Diff filler or virtual lines below the last buffer line are counted in the result when "end_row" is omitted.
Attributes:
Since: 0.10.0
Parameters:
{window} (
integer)
window-ID, or 0 for current window.
{opts} (vim.api.keyset.win_text_height) Optional parameters:
start_row: Starting line index, 0-based inclusive. When omitted start at the very top.
end_row: Ending line index, 0-based inclusive. When omitted end at the very bottom.
start_vcol: Starting virtual column index on "start_row", 0-based inclusive, rounded down to full screen lines. When omitted include the whole line.
end_vcol: Ending virtual column index on "end_row", 0-based exclusive, rounded up to full screen lines. When 0 only include diff filler and virtual lines above "end_row". When omitted include the whole line.
max_height: Don't add the height of lines below the row for which this height is reached. Useful to e.g. limit the height to the window height, avoiding unnecessary work. Or to find out how many buffer lines beyond "start_row" take up a certain number of logical lines (returned in "end_row" and "end_vcol").
Return:
(
vim.api.keyset.win_text_height_ret) Dict containing text height information, with these keys:
all: The total number of screen lines occupied by the range.
fill: The number of diff filler or virtual lines among them.
end_row: The row on which the returned height is reached (first row of a closed fold).
end_vcol: Ending virtual column in "end_row" where "max_height" or the returned height is reached. 0 if "end_row" is a closed fold.
nvim_open_win(
{buffer},
{enter},
{config})
nvim_open_win() Opens a new split window, or a floating window if
relative is specified, or an external window (managed by the UI) if
external is specified.
Floats are windows that are drawn above the split layout, at some anchor position in some other window. Floats can be drawn internally or by external GUI with the
ui-multigrid extension. External windows are only supported with multigrid GUIs, and are displayed as separate top-level windows.
Thewidth andheight of the new window must be specified when opening a floating window, but are optional for normal windows.
If
relative and
external are omitted, a normal "split" window is created. The
win property determines which window will be split. If no
win is provided or
win == 0, a window will be created adjacent to the current window. If -1 is provided, a top-level split will be created.
vertical and
split are only valid for normal windows, and are used to control split direction. For
vertical, the exact direction is determined by
'splitright' and
'splitbelow'. Split windows cannot have
bufpos/`row`/`col`/`border`/`title`/`footer` properties.
With relative=editor (row=0,col=0) refers to the top-left corner of the screen-grid and (row=Lines-1,col=Columns-1) refers to the bottom-right corner. Fractional values are allowed, but the builtin implementation (used by non-multigrid UIs) will always round down to nearest integer.
Out-of-bounds values, and configurations that make the float not fit inside the main editor, are allowed. The builtin implementation truncates values so floats are fully within the main screen grid. External GUIs could let floats hover outside of the main window like a tooltip, but this should not be used to specify arbitrary WM screen positions.
Example (Lua): window-relative float
vim.api.nvim_open_win(0, false, {relative='win', row=3, col=3, width=12, height=3})
Example (Lua): buffer-relative float (travels as buffer is scrolled)
vim.api.nvim_open_win(0, false, {relative='win', width=12, height=3, bufpos={100,10}})
Example (Lua): vertical split left of the current window
vim.api.nvim_open_win(0, false, { split = 'left', win = 0})
Attributes:
not allowed when
textlock is active Since: 0.4.0
Parameters:
{buffer} (integer) Buffer to display, or 0 for current buffer
{enter} (boolean) Enter the window (make it the current window)
{config} (vim.api.keyset.win_config) Map defining the window configuration. Keys:
relative: Sets the window layout to "floating", placed at (row,col) coordinates relative to:
"cursor" Cursor position in current window.
"editor" The global editor grid.
"mouse" Mouse position.
"tabline" Tabline if present, or first row.
"win" Window given by thewin field, or current window.
win:
window-ID window to split, or relative window when creating a float (relative="win").
anchor: Decides which corner of the float to place at (row,col):
"NW" northwest (default)
"NE" northeast
"SW" southwest
"SE" southeast
width: Window width (in character cells). Minimum of 1.
height: Window height (in character cells). Minimum of 1.
bufpos: Places float relative to buffer text (only when relative="win"). Takes a tuple of zero-indexed[line, column].row andcol if given are applied relative to this position, else they default to:
row=1 andcol=0 ifanchor is "NW" or "NE"
row=0 andcol=0 ifanchor is "SW" or "SE" (thus like a tooltip near the buffer text).
row: Row position in units of "screen cell height", may be fractional.
col: Column position in units of screen cell width, may be fractional.
focusable: Enable focus by user actions (wincmds, mouse events). Defaults to true. Non-focusable windows can be entered by
nvim_set_current_win(), or, when the
mouse field is set to true, by mouse events. See
focusable.
mouse: Specify how this window interacts with mouse events. Defaults tofocusable value.
If false, mouse events pass through this window.
If true, mouse events interact with this window normally.
external: GUI should display the window as an external top-level window. Currently accepts no other positioning configuration together with this.
zindex: Stacking order. floats with higherzindex go on top on floats with lower indices. Must be larger than zero. The following screen elements have hard-coded z-indices:
100: insert completion popupmenu
200: message scrollback
250: cmdline completion popupmenu (when wildoptions+=pum) The default value for floats are 50. In general, values below 100 are recommended, unless there is a good reason to overshadow builtin elements.
style: (optional) Configure the appearance of the window. Currently only supports one value:
border: (
string|string[]) (defaults to
'winborder' option) Window border. The string form accepts the same values as the
'winborder' option. The array form must have a length of eight or any divisor of eight, specifying the chars that form the border in a clockwise fashion starting from the top-left corner. For example, the double-box style can be specified as:
[ "╔", "═" ,"╗", "║", "╝", "═", "╚", "║" ].
If fewer than eight chars are given, they will be repeated. An ASCII border could be specified as:
[ "/", "-", \"\\\\\", "|" ],
Or one char for all sides:
[ "x" ].
Empty string can be used to hide a specific border. This example will show only vertical borders, not horizontal:
[ "", "", "", ">", "", "", "", "<" ]
By default,
hl-FloatBorder highlight is used, which links to
hl-WinSeparator when not defined. Each border side can specify an optional highlight:
[ ["+", "MyCorner"], ["x", "MyBorder"] ].
title: (optional) Title in window border, string or list. List should consist of[text, highlight] tuples. If string, or a tuple lacks a highlight, the default highlight group isFloatTitle.
title_pos: Title position. Must be set withtitle option. Value can be one of "left", "center", or "right". Default is"left".
footer: (optional) Footer in window border, string or list. List should consist of[text, highlight] tuples. If string, or a tuple lacks a highlight, the default highlight group isFloatFooter.
footer_pos: Footer position. Must be set withfooter option. Value can be one of "left", "center", or "right". Default is"left".
noautocmd: If true then all autocommands are blocked for the duration of the call.
fixed: If true when anchor is NW or SW, the float window would be kept fixed even if the window would be truncated.
hide: If true the floating window will be hidden and the cursor will be invisible when focused on it.
split: Split direction: "left", "right", "above", "below".
_cmdline_offset: (EXPERIMENTAL) When provided, anchor the
cmdline-completion popupmenu to this window, with an offset in screen cell width.
relative is empty for normal windows.
Parameters:
{window} (
integer)
window-ID, or 0 for current window
Return:
(
vim.api.keyset.win_config) Map defining the window configuration, see
nvim_open_win()nvim_win_set_config(
{window},
{config})
nvim_win_set_config() Configures window layout. Cannot be used to move the last window in a tabpage to a different one.
When reconfiguring a window, absent option keys will not be changed.row/`col` andrelative must be reconfigured together.
Parameters:
{window} (
integer)
window-ID, or 0 for current window
{config} (
vim.api.keyset.win_config) Map defining the window configuration, see
nvim_open_win()Parameters:
{tabpage} (
integer)
tab-ID, or 0 for current tabpage
{name} (string) Variable name
Parameters:
{tabpage} (
integer)
tab-ID, or 0 for current tabpage
Return:
(
integer) Tabpage number
Parameters:
{tabpage} (
integer)
tab-ID, or 0 for current tabpage
{name} (string) Variable name
Return:
(
any) Variable value
Parameters:
{tabpage} (
integer)
tab-ID, or 0 for current tabpage
Parameters:
{tabpage} (
integer)
tab-ID, or 0 for current tabpage
Return:
(
boolean) true if the tabpage is valid, false otherwise
Parameters:
{tabpage} (
integer)
tab-ID, or 0 for current tabpage
Return:
(
integer[]) List of windows in
tabpageParameters:
{tabpage} (
integer)
tab-ID, or 0 for current tabpage
{name} (string) Variable name
{value} (any) Variable value
Attributes:
Since: 0.10.0
Parameters:
{tabpage} (
integer)
tab-ID, or 0 for current tabpage
{win} (
integer)
window-ID, must already belong to
{tabpage}Parameters:
{opts} (vim.api.keyset.clear_autocmds) Parameters
event: (string|table) Examples:
event: "pat1"
event: { "pat1" }
event: { "pat1", "pat2", "pat3" }
pattern: (string|table)
pattern or patterns to match exactly.
For example, if you have*.py as that pattern for the autocmd, you must pass*.py exactly to clear it.test.py will not match the pattern.
defaults to clearing all patterns.
NOTE: Cannot be used with{buffer}
buffer: (bufnr)
NOTE: Cannot be used with{pattern}
group: (string|int) The augroup name or id.
NOTE: If not passed, will only delete autocmds not in any group.
To get an existing group id, do:
local id = vim.api.nvim_create_augroup('my.lsp.config', { clear = false})
Parameters:
{name} (string) String: The name of the group
{opts} (vim.api.keyset.create_augroup) Dict Parameters
clear (bool) optional: defaults to true. Clear existing commands if the group already exists
autocmd-groups.
Return:
(
integer) Integer id of the created group.
nvim_create_autocmd(
{event},
{opts})
nvim_create_autocmd() Creates an
autocommand event handler, defined by
callback (Lua function or Vimscript function name string) or
command (Ex command string).
Example using Lua callback:
vim.api.nvim_create_autocmd({'BufEnter', 'BufWinEnter'}, { pattern = {'*.c', '*.h'}, callback = function(ev) print(string.format('event fired: %s', vim.inspect(ev))) end})
Example using an Ex command as the handler:
vim.api.nvim_create_autocmd({'BufEnter', 'BufWinEnter'}, { pattern = {'*.c', '*.h'}, command = "echo 'Entering a C or C++ file'",})
Note:pattern is NOT automatically expanded (unlike with
:autocmd), thus names like "$HOME" and "~" must be expanded explicitly:
pattern = vim.fn.expand('~') .. '/some/path/*.py'
Parameters:
{event} (any) (string|array) Event(s) that will trigger the handler (callback orcommand).
{opts} (vim.api.keyset.create_autocmd) Options dict:
group (string|integer) optional: autocommand group name or id to match against.
pattern (string|array) optional: pattern(s) to match literally
autocmd-pattern.
buffer (integer) optional: buffer number for buffer-local autocommands
autocmd-buflocal. Cannot be used with
{pattern}.
desc (string) optional: description (for documentation and troubleshooting).
callback (function|string) optional: Lua function (or Vimscript function name, if string) called when the event(s) is triggered. Lua callback can return a truthy value (not
false or
nil) to delete the autocommand, and receives one argument, a table with these keys:
event-args id: (number) autocommand id
group: (number|nil) autocommand group id, if any
file: (string)<afile> (not expanded to a full path)
match: (string)<amatch> (expanded to a full path)
buf: (number)<abuf>
command (string) optional: Vim command to execute on event. Cannot be used with{callback}
once (boolean) optional: defaults to false. Run the autocommand only once
autocmd-once.
nested (boolean) optional: defaults to false. Run nested autocommands
autocmd-nested.
Return:
(
integer) Autocommand id (number)
NOTE: behavior differs from
:augroup-delete. When deleting a group, autocommands contained in this group will also be deleted and cleared. This group will no longer exist.
Parameters:
{id} (integer) Integer The id of the group.
NOTE: behavior differs from
:augroup-delete. When deleting a group, autocommands contained in this group will also be deleted and cleared. This group will no longer exist.
Parameters:
{name} (string) String The name of the group.
Parameters:
{event} (any) (String|Array) The event or events to execute
{opts} (vim.api.keyset.exec_autocmds) Dict of autocommand options:
group (string|integer) optional: the autocommand group name or id to match against.
autocmd-groups.
pattern (string|array) optional: defaults to "*"
autocmd-pattern. Cannot be used with
{buffer}.
buffer (integer) optional: buffer number
autocmd-buflocal. Cannot be used with
{pattern}.
modeline (bool) optional: defaults to true. Process the modeline after the autocommands<nomodeline>.
nvim_get_autocmds(
{opts})
nvim_get_autocmds() Get all autocommands that match the corresponding
{opts}.
These examples will get autocommands matching ALL the given criteria:
-- Matches all criteriaautocommands = vim.api.nvim_get_autocmds({ group = 'MyGroup', event = {'BufEnter', 'BufWinEnter'}, pattern = {'*.c', '*.h'}})-- All commands from one groupautocommands = vim.api.nvim_get_autocmds({ group = 'MyGroup',})
NOTE: When multiple patterns or events are provided, it will find all the autocommands that match any combination of them.
Parameters:
{opts} (vim.api.keyset.get_autocmds) Dict with at least one of the following:
buffer: (integer) Buffer number or list of buffer numbers for buffer local autocommands
autocmd-buflocal. Cannot be used with
{pattern} id: (integer) Autocommand ID to match.
group: (string|table) the autocommand group name or id to match against.
pattern: (string|table) pattern or patterns to match against
autocmd-pattern. Cannot be used with
{buffer}Return:
(
vim.api.keyset.get_autocmds.ret[]) Array of autocommands matching the criteria, with each item containing the following fields:
buffer: (integer) the buffer number.
buflocal: (boolean) true if the autocommand is buffer local.
command: (string) the autocommand command. Note: this will be empty if a callback is set.
callback: (function|string|nil): Lua function or name of a Vim script function which is executed when this autocommand is triggered.
desc: (string) the autocommand description.
event: (string) the autocommand event.
id: (integer) the autocommand id (only when defined with the API).
group: (integer) the autocommand group id.
group_name: (string) the autocommand group name.
once: (boolean) whether the autocommand is only run once.
nvim_ui_attach(
{width},
{height},
{options})
nvim_ui_attach() Activates UI events on the channel.
Entry point of all UI clients. Allows
--embed to continue startup. Implies that the client is ready to show the UI. Adds the client to the list of UIs.
nvim_list_uis() Note:
If multiple UI clients are attached, the global screen dimensions degrade to the smallest client. E.g. if client A requests 80x40 but client B requests 200x100, the global screen has size 80x40.
Attributes:
RPC only Since: 0.1.0
Parameters:
{width} (integer) Requested screen columns
{height} (integer) Requested screen rows
Attributes:
RPC only Since: 0.1.0
nvim_ui_pum_set_bounds()nvim_ui_pum_set_bounds(
{width},
{height},
{row},
{col}) Tells Nvim the geometry of the popupmenu, to align floating windows with an external popup menu.
Note that this method is not to be confused with
nvim_ui_pum_set_height(), which sets the number of visible items in the popup menu, while this function sets the bounding box of the popup menu, including visual elements such as borders and sliders. Floats need not use the same font size, nor be anchored to exact grid corners, so one can set floating-point numbers to the popup menu geometry.
Attributes:
RPC only Since: 0.5.0
Parameters:
{width} (number) Popupmenu width.
{height} (number) Popupmenu height.
{row} (number) Popupmenu row.
{col} (number) Popupmenu height.
nvim_ui_pum_set_height(
{height})
nvim_ui_pum_set_height() Tells Nvim the number of elements displaying in the popupmenu, to decide
<PageUp> and
<PageDown> movement.
Attributes:
RPC only Since: 0.4.0
Parameters:
{height} (integer) Popupmenu height, must be greater than zero.
nvim_ui_set_focus(
{gained})
nvim_ui_set_focus() Tells the nvim server if focus was gained or lost by the GUI
Attributes:
RPC only Since: 0.9.0
Parameters:
{gained} (boolean)
Attributes:
RPC only Since: 0.1.0
Parameters:
{name} (string)
{value} (any)
nvim_ui_term_event(
{event},
{value})
nvim_ui_term_event() Tells Nvim when a terminal event has occurred
The following terminal events are supported:
"termresponse": The terminal sent an OSC, DCS, or APC response sequence to Nvim. The payload is the received response. Sets
v:termresponse and fires
TermResponse.
Attributes:
RPC only Since: 0.10.0
Parameters:
{event} (string) Event name
{value} (any) Event payload
Attributes:
RPC only Since: 0.1.0
Parameters:
{width} (integer)
{height} (integer)
nvim_ui_try_resize_grid()nvim_ui_try_resize_grid(
{grid},
{width},
{height}) Tell Nvim to resize a grid. Triggers a grid_resize event with the requested grid size or the maximum size if it exceeds size limits.
On invalid grid handle, fails with error.
Attributes:
RPC only Since: 0.4.0
Parameters:
{grid} (integer) The handle of the grid to be changed.
{width} (integer) The new requested width.
{height} (integer) The new requested height.