Lua

Nvim :help pages, generated from source using the tree-sitter-vimdoc parser.


Lua engine Lua

INTRODUCTION lua-intro

The Lua 5.1 script engine is builtin and always available. Try this command to get an idea of what lurks beneath:
:lua vim.print(package.loaded)
Nvim includes a "standard library" lua-stdlib for Lua. It complements the "editor stdlib" (builtin-functions and Ex-commands) and the API, all of which can be used from Lua code (lua-vimscript vim.api). Together these "namespaces" form the Nvim programming interface.
Lua plugins and user config are automatically discovered and loaded, just like Vimscript. See lua-guide for practical guidance.
You can also run Lua scripts from your shell using the -l argument:
nvim -l foo.lua [args...]
lua-compat Lua 5.1 is the permanent interface for Nvim Lua. Plugins need only consider Lua 5.1, not worry about forward-compatibility with future Lua versions. If Nvim ever ships with Lua 5.4+, a Lua 5.1 compatibility shim will be provided so that old plugins continue to work transparently.
lua-luajit Nvim is built with luajit on platforms which support it, which provides extra functionality. Lua code in init.lua and plugins can assume its presence on installations on common platforms. For maximum compatibility with less common platforms, availability can be checked using the jit global variable:
if jit then
  -- code for luajit
else
  -- code for plain lua 5.1
end
lua-bit In particular, the luajit "bit" extension module is _always_ available. A fallback implementation is included when nvim is built with PUC Lua 5.1, and will be transparently used when require("bit") is invoked.

LUA CONCEPTS AND IDIOMS lua-concepts

Lua is very simple: this means that, while there are some quirks, once you internalize those quirks, everything works the same everywhere. Scopes (closures) in particular are very consistent, unlike JavaScript or most other languages.
Lua has three fundamental mechanisms—one for "each major aspect of programming": tables, closures, and coroutines. https://www.lua.org/doc/cacm2018.pdf
Tables are the "object" or container datastructure: they represent both lists and maps, you can extend them to represent your own datatypes and change their behavior using metatables (like Python's "datamodel").
EVERY scope in Lua is a closure: a function is a closure, a module is a closure, a do block (lua-do) is a closure--and they all work the same. A Lua module is literally just a big closure discovered on the "path" (where your modules are found: package.cpath).
Stackful coroutines enable cooperative multithreading, generators, and versatile control for both Lua and its host (Nvim).
iterator An iterator is just a function that can be called repeatedly to get the "next" value of a collection (or any other iterable). This interface is expected by for-in loops, produced by pairs(), supported by vim.iter, etc. https://www.lua.org/pil/7.1.html
iterable An "iterable" is anything that vim.iter() can consume: tables, dicts, lists, iterator functions, tables implementing the __call() metamethod, and vim.iter() objects.
lua-function-call Lua functions can be called in multiple ways. Consider the function:
local foo = function(a, b)
    print("A: ", a)
    print("B: ", b)
end
The first way to call this function is:
foo(1, 2)
-- ==== Result ====
-- A: 1
-- B: 2
This way of calling a function is familiar from most scripting languages. In Lua, any missing arguments are passed as nil, and extra parameters are silently discarded. Example:
foo(1)
-- ==== Result ====
-- A: 1
-- B: nil
kwargs When calling a function, you can omit the parentheses if the function takes exactly one string literal ("foo") or table literal ({1,2,3}). The latter is often used to mimic "named parameters" ("kwargs" or "keyword args") as in languages like Python and C#. Example:
local func_with_opts = function(opts)
    local will_do_foo = opts.foo
    local filename = opts.filename
    ...
end
func_with_opts { foo = true, filename = "hello.world" }
There's nothing special going on here except that parentheses are treated as whitespace. But visually, this small bit of sugar gets reasonably close to a "keyword args" interface. Nvim code tends to prefer this style.

LUA PATTERNS lua-patterns

Lua intentionally does not support regular expressions, instead it has limited "patterns" lua-pattern which avoid the performance pitfalls of extended regex. Lua scripts can also use Vim regex via vim.regex().
Examples:
print(string.match("foo123bar123", "%d+"))
-- 123
print(string.match("foo123bar123", "[^%d]+"))
-- foo
print(string.match("foo123bar123", "[abc]+"))
-- ba
print(string.match("foo.bar", "%.bar"))
-- .bar

IMPORTING LUA MODULES lua-module-load

Modules are searched for under the directories specified in 'runtimepath', in the order they appear. Any "." in the module name is treated as a directory separator when searching. For a module foo.bar, each directory is searched for lua/foo/bar.lua, then lua/foo/bar/init.lua. If no files are found, the directories are searched again for a shared library with a name matching lua/foo/bar.?, where ? is a list of suffixes (such as so or dll) derived from the initial value of package.cpath. If still no files are found, Nvim falls back to Lua's default search mechanism. The first script found is run and require() returns the value returned by the script if any, else true.
The return value is cached after the first call to require() for each module, with subsequent calls returning the cached value without searching for, or executing any script. For further details see require().
For example, if 'runtimepath' is foo,bar and package.cpath was ./?.so;./?.dll at startup, require('mod') searches these paths in order and loads the first module found ("first wins"):
foo/lua/mod.lua
foo/lua/mod/init.lua
bar/lua/mod.lua
bar/lua/mod/init.lua
foo/lua/mod.so
foo/lua/mod.dll
bar/lua/mod.so
bar/lua/mod.dll
lua-package-path Nvim automatically adjusts package.path and package.cpath according to the effective 'runtimepath' value. Adjustment happens whenever 'runtimepath' is changed. package.path is adjusted by simply appending /lua/?.lua and /lua/?/init.lua to each directory from 'runtimepath' (/ is actually the first character of package.config).
Similarly to package.path, modified directories from 'runtimepath' are also added to package.cpath. In this case, instead of appending /lua/?.lua and /lua/?/init.lua to each runtimepath, all unique ?-containing suffixes of the existing package.cpath are used. Example:
1. Given that
'runtimepath' contains /foo/bar,/xxx;yyy/baz,/abc;
initial package.cpath (defined at compile-time or derived from $LUA_CPATH / $LUA_INIT) contains ./?.so;/def/ghi/a?d/j/g.elf;/def/?.so.
2. It finds ?-containing suffixes /?.so, /a?d/j/g.elf and /?.so, in order: parts of the path starting from the first path component containing question mark and preceding path separator.
3. The suffix of /def/?.so, namely /?.so is not unique, as it’s the same as the suffix of the first path from package.path (i.e. ./?.so). Which leaves /?.so and /a?d/j/g.elf, in this order.
4. 'runtimepath' has three paths: /foo/bar, /xxx;yyy/baz and /abc. The second one contains a semicolon which is a paths separator so it is out, leaving only /foo/bar and /abc, in order.
5. The cartesian product of paths from 4. and suffixes from 3. is taken, giving four variants. In each variant a /lua path segment is inserted between path and suffix, leaving:
/foo/bar/lua/?.so
/foo/bar/lua/a?d/j/g.elf
/abc/lua/?.so
/abc/lua/a?d/j/g.elf
6. New paths are prepended to the original package.cpath.
The result will look like this:
/foo/bar,/xxx;yyy/baz,/abc ('runtimepath')
× ./?.so;/def/ghi/a?d/j/g.elf;/def/?.so (package.cpath)
= /foo/bar/lua/?.so;/foo/bar/lua/a?d/j/g.elf;/abc/lua/?.so;/abc/lua/a?d/j/g.elf;./?.so;/def/ghi/a?d/j/g.elf;/def/?.so
Note:
To track 'runtimepath' updates, paths added at previous update are remembered and removed at the next update, while all paths derived from the new 'runtimepath' are prepended as described above. This allows removing paths when path is removed from 'runtimepath', adding paths when they are added and reordering package.path/|package.cpath| content if 'runtimepath' was reordered.
Although adjustments happen automatically, Nvim does not track current values of package.path or package.cpath. If you happen to delete some paths from there you can set 'runtimepath' to trigger an update:
let &runtimepath = &runtimepath
Skipping paths from 'runtimepath' which contain semicolons applies both to package.path and package.cpath. Given that there are some badly written plugins using shell, which will not work with paths containing semicolons, it is better to not have them in 'runtimepath' at all.

COMMANDS lua-commands

These commands execute a Lua chunk from either the command line (:lua, :luado) or a file (:luafile) on the given line [range]. As always in Lua, each chunk has its own scope (closure), so only global variables are shared between command calls. The lua-stdlib modules, user modules, and anything else on package.path are available.
The Lua print() function redirects its output to the Nvim message area, with arguments separated by " " (space) instead of "\t" (tab).
:lua= :lua :lua {chunk} Executes Lua chunk {chunk}. If {chunk} starts with "=" the rest of the chunk is evaluated as an expression and printed. :lua =expr or :=expr is equivalent to :lua print(vim.inspect(expr)).
Examples:
:lua vim.api.nvim_command('echo "Hello, Nvim!"')
To see the Lua version:
:lua print(_VERSION)
To see the LuaJIT version:
:lua =jit.version
:lua-heredoc :lua << [trim] [{endmarker}] {script} {endmarker} Executes Lua script {script} from within Vimscript. You can omit [endmarker] after the "<<" and use a dot "." after {script} (similar to :append, :insert). Refer to :let-heredoc for more information.
Example:
function! CurrentLineInfo()
lua << EOF
local linenr = vim.api.nvim_win_get_cursor(0)[1]
local curline = vim.api.nvim_buf_get_lines(
        0, linenr - 1, linenr, false)[1]
print(string.format("Current line [%d] has %d bytes",
        linenr, #curline))
EOF
endfunction
Note that the local variables will disappear when the block finishes. But not globals.
:luado :[range]luado {body} Executes Lua chunk "function(line, linenr) {body} end" for each buffer line in [range], where line is the current line text (without <EOL>), and linenr is the current line number. If the function returns a string that becomes the text of the corresponding buffer line. Default [range] is the whole file: "1,$".
Examples:
:luado return string.format("%s\t%d", line:reverse(), #line)
:lua require"lpeg"
:lua -- balanced parenthesis grammar:
:lua bp = lpeg.P{ "(" * ((1 - lpeg.S"()") + lpeg.V(1))^0 * ")" }
:luado if bp:match(line) then return "=>\t" .. line end
:luafile :luafile {file} Execute Lua script in {file}. The whole argument is used as the filename (like :edit), spaces do not need to be escaped. Alternatively you can :source Lua files.
Examples:
:luafile script.lua
:luafile %

luaeval() lua-eval

The (dual) equivalent of "vim.eval" for passing Lua values to Nvim is "luaeval". "luaeval" takes an expression string and an optional argument used for _A inside expression and returns the result of the expression. It is semantically equivalent in Lua to:
local chunkheader = "local _A = select(1, ...) return "
function luaeval (expstr, arg)
    local chunk = assert(loadstring(chunkheader .. expstr, "luaeval"))
    return chunk(arg) -- return typval
end
Lua nils, numbers, strings, tables and booleans are converted to their respective Vimscript types. If a Lua string contains a NUL byte, it will be converted to a Blob. Conversion of other Lua types is an error.
The magic global "_A" contains the second argument to luaeval().
Example:
:echo luaeval('_A[1] + _A[2]', [40, 2])
" 42
:echo luaeval('string.match(_A, "[a-z]+")', 'XYXfoo123')
" foo
lua-table-ambiguous Lua tables are used as both dictionaries and lists, so it is impossible to determine whether empty table is meant to be empty list or empty dictionary. Additionally Lua does not have integer numbers. To distinguish between these cases there is the following agreement: lua-list 0. Empty table is empty list. 1. Table with N incrementally growing integral numbers, starting from 1 and ending with N is considered to be a list. lua-dict 2. Table with string keys, none of which contains NUL byte, is considered to be a dictionary. 3. Table with string keys, at least one of which contains NUL byte, is also considered to be a dictionary, but this time it is converted to a msgpack-special-map. lua-special-tbl 4. Table with vim.type_idx key may be a dictionary, a list or floating-point value:
{[vim.type_idx]=vim.types.float, [vim.val_idx]=1} is converted to a floating-point 1.0. Note that by default integral Lua numbers are converted to Numbers, non-integral are converted to Floats. This variant allows integral Floats.
{[vim.type_idx]=vim.types.dictionary} is converted to an empty dictionary, {[vim.type_idx]=vim.types.dictionary, [42]=1, a=2} is converted to a dictionary {'a': 42}: non-string keys are ignored. Without vim.type_idx key tables with keys not fitting in 1., 2. or 3. are errors.
{[vim.type_idx]=vim.types.array} is converted to an empty list. As well as {[vim.type_idx]=vim.types.array, [42]=1}: integral keys that do not form a 1-step sequence from 1 to N are ignored, as well as all non-integral keys.
Examples:
:echo luaeval('math.pi')
:function Rand(x,y) " random uniform between x and y
:  return luaeval('(_A.y-_A.x)*math.random()+_A.x', {'x':a:x,'y':a:y})
:  endfunction
:echo Rand(1,10)
Note: Second argument to luaeval is converted ("marshalled") from Vimscript to Lua, so changes to Lua containers do not affect values in Vimscript. Return value is also always converted. When converting, msgpack-special-dicts are treated specially.

Vimscript v:lua interface v:lua-call

From Vimscript the special v:lua prefix can be used to call Lua functions which are global or accessible from global tables. The expression
call v:lua.func(arg1, arg2)
is equivalent to the Lua chunk
return func(...)
where the args are converted to Lua values. The expression
call v:lua.somemod.func(args)
is equivalent to the Lua chunk
return somemod.func(...)
In addition, functions of packages can be accessed like
call v:lua.require'mypack'.func(arg1, arg2)
call v:lua.require'mypack.submod'.func(arg1, arg2)
Note: Only single quote form without parens is allowed. Using require"mypack" or require('mypack') as prefixes do NOT work (the latter is still valid as a function call of itself, in case require returns a useful value).
The v:lua prefix may be used to call Lua functions as methods. For example:
:eval arg1->v:lua.somemod.func(arg2)
You can use v:lua in "func" options like 'tagfunc', 'omnifunc', etc. For example consider the following Lua omnifunc handler:
function mymod.omnifunc(findstart, base)
  if findstart == 1 then
    return 0
  else
    return {'stuff', 'steam', 'strange things'}
  end
end
vim.bo[buf].omnifunc = 'v:lua.mymod.omnifunc'
Note: The module ("mymod" in the above example) must either be a Lua global, or use require() as shown above to access it from a package.
Note: v:lua without a call is not allowed in a Vimscript expression: Funcrefs cannot represent Lua functions. The following are errors:
let g:Myvar = v:lua.myfunc        " Error
call SomeFunc(v:lua.mycallback)   " Error
let g:foo = v:lua                 " Error
let g:foo = v:['lua']             " Error

Lua standard modules lua-stdlib

The Nvim Lua "standard library" (stdlib) is the vim module, which exposes various functions and sub-modules. It is always loaded, thus require("vim") is unnecessary.
You can peek at the module properties:
:lua vim.print(vim)
Result is something like this:
{
  _os_proc_children = <function 1>,
  _os_proc_info = <function 2>,
  ...
  api = {
    nvim__id = <function 5>,
    nvim__id_array = <function 6>,
    ...
  },
  deepcopy = <function 106>,
  gsplit = <function 107>,
  ...
}
To find documentation on e.g. the "deepcopy" function:
:help vim.deepcopy()
Note that underscore-prefixed functions (e.g. "_os_proc_children") are internal/private and must not be used by plugins.

VIM.UV lua-loop vim.uv

vim.uv exposes the "luv" Lua bindings for the libUV library that Nvim uses for networking, filesystem, and process management, see luvref.txt. In particular, it allows interacting with the main Nvim luv-event-loop.
E5560 lua-loop-callbacks It is an error to directly invoke vim.api functions (except api-fast) in vim.uv callbacks. For example, this is an error:
local timer = vim.uv.new_timer()
timer:start(1000, 0, function()
  vim.api.nvim_command('echomsg "test"')
end)
To avoid the error use vim.schedule_wrap() to defer the callback:
local timer = vim.uv.new_timer()
timer:start(1000, 0, vim.schedule_wrap(function()
  vim.api.nvim_command('echomsg "test"')
end))
(For one-shot timers, see vim.defer_fn(), which automatically adds the wrapping.)
Example: repeating timer 1. Save this code to a file. 2. Execute it with ":luafile %".
-- Create a timer handle (implementation detail: uv_timer_t).
local timer = vim.uv.new_timer()
local i = 0
-- Waits 1000ms, then repeats every 750ms until timer:close().
timer:start(1000, 750, function()
  print('timer invoked! i='..tostring(i))
  if i > 4 then
    timer:close()  -- Always close handles to avoid leaks.
  end
  i = i + 1
end)
print('sleeping');
Example: File-change detection watch-file 1. Save this code to a file. 2. Execute it with ":luafile %". 3. Use ":Watch %" to watch any file. 4. Try editing the file from another text editor. 5. Observe that the file reloads in Nvim (because on_change() calls :checktime).
local w = vim.uv.new_fs_event()
local function on_change(err, fname, status)
  -- Do work...
  vim.api.nvim_command('checktime')
  -- Debounce: stop/start.
  w:stop()
  watch_file(fname)
end
function watch_file(fname)
  local fullpath = vim.api.nvim_call_function(
    'fnamemodify', {fname, ':p'})
  w:start(fullpath, {}, vim.schedule_wrap(function(...)
    on_change(...) end))
end
vim.api.nvim_command(
  "command! -nargs=1 Watch call luaeval('watch_file(_A)', expand('<args>'))")
Example: TCP echo-server tcp-server 1. Save this code to a file. 2. Execute it with ":luafile %". 3. Note the port number. 4. Connect from any TCP client (e.g. "nc 0.0.0.0 36795"):
local function create_server(host, port, on_connect)
  local server = vim.uv.new_tcp()
  server:bind(host, port)
  server:listen(128, function(err)
    assert(not err, err)  -- Check for errors.
    local sock = vim.uv.new_tcp()
    server:accept(sock)  -- Accept client connection.
    on_connect(sock)  -- Start reading messages.
  end)
  return server
end
local server = create_server('0.0.0.0', 0, function(sock)
  sock:read_start(function(err, chunk)
    assert(not err, err)  -- Check for errors.
    if chunk then
      sock:write(chunk)  -- Echo received messages to the channel.
    else  -- EOF (stream closed).
      sock:close()  -- Always close handles to avoid leaks.
    end
  end)
end)
print('TCP echo-server listening on port: '..server:getsockname().port)
Multithreading lua-loop-threading
Plugins can perform work in separate (os-level) threads using the threading APIs in luv, for instance vim.uv.new_thread. Note that every thread gets its own separate Lua interpreter state, with no access to Lua globals in the main thread. Neither can the state of the editor (buffers, windows, etc) be directly accessed from threads.
A subset of the vim.* API is available in threads. This includes:
vim.uv with a separate event loop per thread.
vim.mpack and vim.json (useful for serializing messages between threads)
require in threads can use Lua packages from the global package.path
print() and vim.inspect
vim.diff
most utility functions in vim.* for working with pure Lua values like vim.split, vim.tbl_*, vim.list_*, and so on.
vim.is_thread() returns true from a non-main thread.

VIM.LPEG lua-lpeg

vim.lpeg vim.re The Lpeg library for parsing expression grammars is being included as vim.lpeg (https://www.inf.puc-rio.br/~roberto/lpeg/). In addition, its regex-like interface is available as vim.re (https://www.inf.puc-rio.br/~roberto/lpeg/re.html).

VIM.HIGHLIGHT vim.highlight

Nvim includes a function for highlighting a selection on yank.
To enable it, add the following to your init.vim:
au TextYankPost * silent! lua vim.highlight.on_yank()
You can customize the highlight group and the duration of the highlight via:
au TextYankPost * silent! lua vim.highlight.on_yank {higroup="IncSearch", timeout=150}
If you want to exclude visual selections from highlighting on yank, use:
au TextYankPost * silent! lua vim.highlight.on_yank {on_visual=false}
vim.highlight.on_yank({opts}) vim.highlight.on_yank() Highlight the yanked text
Parameters:
{opts} (table|nil) Optional parameters
higroup highlight group for yanked region (default "IncSearch")
timeout time in ms before highlight is cleared (default 150)
on_macro highlight when executing macro (default false)
on_visual highlight when yanking visual selection (default true)
event event structure (default vim.v.event)
priority integer priority (default vim.highlight.priorities.user)
vim.highlight.priorities vim.highlight.priorities Table with default priorities used for highlighting:
syntax: 50, used for standard syntax highlighting
treesitter: 100, used for tree-sitter-based highlighting
semantic_tokens: 125, used for LSP semantic token highlighting
diagnostics: 150, used for code analysis such as diagnostics
user: 200, used for user-triggered highlights such as LSP document symbols or on_yank autocommands
vim.highlight.range() vim.highlight.range({bufnr}, {ns}, {higroup}, {start}, {finish}, {opts}) Apply highlight group to range of text.
Parameters:
{bufnr} (integer) Buffer number to apply highlighting to
{ns} (integer) Namespace to add highlight to
{higroup} (string) Highlight group to use for highlighting
{start} integer[]|string Start of region as a (line, column) tuple or string accepted by getpos()
{finish} integer[]|string End of region as a (line, column) tuple or string accepted by getpos()
{opts} (table|nil) Optional parameters
regtype type of range (see setreg(), default charwise)
inclusive boolean indicating whether the range is end-inclusive (default false)
priority number indicating priority of highlight (default priorities.user)

VIM.REGEX vim.regex

Vim regexes can be used directly from Lua. Currently they only allow matching within a single line.
vim.regex({re}) vim.regex() Parse the Vim regex {re} and return a regex object. Regexes are "magic" and case-sensitive by default, regardless of 'magic' and 'ignorecase'. They can be controlled with flags, see /magic and /ignorecase.
Parameters:
{re} (string)
Return:
vim.regex
regex:match_line() vim.regex:match_line({bufnr}, {line_idx}, {start}, {end_}) Match line {line_idx} (zero-based) in buffer {bufnr}. If {start} and {end} are supplied, match only this byte index range. Otherwise see regex:match_str(). If {start} is used, then the returned byte indices will be relative {start}.
Parameters:
{bufnr} (integer)
{line_idx} (integer)
{start} (integer|nil)
{end_} (integer|nil)
vim.regex:match_str({str}) regex:match_str() Match the string against the regex. If the string should match the regex precisely, surround the regex with ^ and $ . If there was a match, the byte indices for the beginning and end of the match are returned. When there is no match, nil is returned. Because any integer is "truthy", regex:match_str() can be directly used as a condition in an if-statement.
Parameters:
{str} (string)

VIM.DIFF vim.diff

vim.diff({a}, {b}, {opts}) vim.diff() Run diff on strings {a} and {b}. Any indices returned by this function, either directly or via callback arguments, are 1-based.
Examples:
vim.diff('a\n', 'b\nc\n')
-- =>
-- @@ -1 +1,2 @@
-- -a
-- +b
-- +c
vim.diff('a\n', 'b\nc\n', {result_type = 'indices'})
-- =>
-- {
--   {1, 1, 1, 2}
-- }
Parameters:
{a} (string) First string to compare
{b} (string) Second string to compare
{opts} table<string,any> Optional parameters:
on_hunk (callback): Invoked for each hunk in the diff. Return a negative number to cancel the callback for any remaining hunks. Args:
start_a (integer): Start line of hunk in {a}.
count_a (integer): Hunk size in {a}.
start_b (integer): Start line of hunk in {b}.
count_b (integer): Hunk size in {b}.
result_type (string): Form of the returned diff:
"unified": (default) String in unified format.
"indices": Array of hunk locations. Note: This option is ignored if on_hunk is used.
linematch (boolean|integer): Run linematch on the resulting hunks from xdiff. When integer, only hunks upto this size in lines are run through linematch. Requires result_type = indices, ignored otherwise.
algorithm (string): Diff algorithm to use. Values:
"myers" the default algorithm
"minimal" spend extra time to generate the smallest possible diff
"patience" patience diff algorithm
"histogram" histogram diff algorithm
ctxlen (integer): Context length
interhunkctxlen (integer): Inter hunk context length
ignore_whitespace (boolean): Ignore whitespace
ignore_whitespace_change (boolean): Ignore whitespace change
ignore_whitespace_change_at_eol (boolean) Ignore whitespace change at end-of-line.
ignore_cr_at_eol (boolean) Ignore carriage return at end-of-line
ignore_blank_lines (boolean) Ignore blank lines
indent_heuristic (boolean): Use the indent heuristic for the internal diff library.
Return:
string|table|nil See {opts.result_type}. nil if {opts.on_hunk} is given.

VIM.MPACK vim.mpack

This module provides encoding and decoding of Lua objects to and from msgpack-encoded strings. Supports vim.NIL and vim.empty_dict().
vim.mpack.decode({str}) vim.mpack.decode() Decodes (or "unpacks") the msgpack-encoded {str} to a Lua object.
Parameters:
{str} (string)
vim.mpack.encode({obj}) vim.mpack.encode() Encodes (or "packs") Lua object {obj} as msgpack in a Lua string.

VIM.JSON vim.json

This module provides encoding and decoding of Lua objects to and from JSON-encoded strings. Supports vim.NIL and vim.empty_dict().
vim.json.decode({str}, {opts}) vim.json.decode() Decodes (or "unpacks") the JSON-encoded {str} to a Lua object.
Decodes JSON "null" as vim.NIL (controllable by {opts}, see below).
Decodes empty object as vim.empty_dict().
Decodes empty array as {} (empty Lua table).
Example:
vim.print(vim.json.decode('{"bar":[],"foo":{},"zub":null}'))
-- { bar = {}, foo = vim.empty_dict(), zub = vim.NIL }
Parameters:
{str} (string) Stringified JSON data.
{opts} table<string,any>|nil Options table with keys:
luanil: (table) Table with keys:
object: (boolean) When true, converts null in JSON objects to Lua nil instead of vim.NIL.
array: (boolean) When true, converts null in JSON arrays to Lua nil instead of vim.NIL.
Return:
any
vim.json.encode({obj}) vim.json.encode() Encodes (or "packs") Lua object {obj} as JSON in a Lua string.
Parameters:
{obj} any
Return:
(string)

VIM.SPELL vim.spell

vim.spell.check({str}) vim.spell.check() Check {str} for spelling errors. Similar to the Vimscript function spellbadword().
Note: The behaviour of this function is dependent on: 'spelllang', 'spellfile', 'spellcapcheck' and 'spelloptions' which can all be local to the buffer. Consider calling this with nvim_buf_call().
Example:
vim.spell.check("the quik brown fox")
-- =>
-- {
--     {'quik', 'bad', 5}
-- }
Parameters:
{str} (string)
Return:
{[1]: string, [2]: string, [3]: string}[] List of tuples with three items:
The badly spelled word.
The type of the spelling error: "bad" spelling mistake "rare" rare word "local" word only valid in another region "caps" word should start with Capital
The position in {str} where the word begins.
vim.api.{func}({...}) vim.api Invokes Nvim API function {func} with arguments {...}. Example: call the "nvim_get_current_line()" API function:
print(tostring(vim.api.nvim_get_current_line()))
vim.NIL vim.NIL Special value representing NIL in RPC and v:null in Vimscript conversion, and similar cases. Lua nil cannot be used as part of a Lua table representing a Dictionary or Array, because it is treated as missing: {"foo", nil} is the same as {"foo"}.
vim.type_idx vim.type_idx Type index for use in lua-special-tbl. Specifying one of the values from vim.types allows typing the empty table (it is unclear whether empty Lua table represents empty list or empty array) and forcing integral numbers to be Float. See lua-special-tbl for more details.
vim.val_idx vim.val_idx Value index for tables representing Floats. A table representing floating-point value 1.0 looks like this:
{
  [vim.type_idx] = vim.types.float,
  [vim.val_idx] = 1.0,
}
vim.types vim.types Table with possible values for vim.type_idx. Contains two sets of key-value pairs: first maps possible values for vim.type_idx to human-readable strings, second maps human-readable type names to values for vim.type_idx. Currently contains pairs for float, array and dictionary types.
Note: One must expect that values corresponding to vim.types.float, vim.types.array and vim.types.dictionary fall under only two following assumptions: 1. Value may serve both as a key and as a value in a table. Given the properties of Lua tables this basically means “value is not nil”. 2. For each value in vim.types table vim.types[vim.types[value]] is the same as value. No other restrictions are put on types, and it is not guaranteed that values corresponding to vim.types.float, vim.types.array and vim.types.dictionary will not change or that vim.types table will only contain values for these three types.
log_levels vim.log.levels Log levels are one of the values defined in vim.log.levels:
vim.log.levels.DEBUG vim.log.levels.ERROR vim.log.levels.INFO vim.log.levels.TRACE vim.log.levels.WARN vim.log.levels.OFF
vim.empty_dict() vim.empty_dict() Creates a special empty table (marked with a metatable), which Nvim converts to an empty dictionary when translating Lua values to Vimscript or API types. Nvim by default converts an empty table {} without this metatable to an list/array.
Note: If numeric keys are present in the table, Nvim ignores the metatable marker and converts the dict to a list/array anyway.
vim.iconv({str}, {from}, {to}, {opts}) vim.iconv() The result is a String, which is the text {str} converted from encoding {from} to encoding {to}. When the conversion fails nil is returned. When some characters could not be converted they are replaced with "?". The encoding names are whatever the iconv() library function can accept, see ":Man 3 iconv".
Parameters:
{str} (string) Text to convert
{from} (number) Encoding of {str}
{to} (number) Target encoding
{opts} table<string,any>|nil
Return:
(string|nil) Converted string if conversion succeeds, nil otherwise.
vim.in_fast_event() vim.in_fast_event() Returns true if the code is executing as part of a "fast" event handler, where most of the API is disabled. These are low-level events (e.g. lua-loop-callbacks) which can be invoked whenever Nvim polls for input. When this is false most API functions are callable (but may be subject to other restrictions such as textlock).
vim.rpcnotify({channel}, {method}, {args}, {...}) vim.rpcnotify() Sends {event} to {channel} via RPC and returns immediately. If {channel} is 0, the event is broadcast to all channels.
This function also works in a fast callback lua-loop-callbacks.
Parameters:
{channel} (integer)
{method} (string)
{args} any[]|nil
{...} any|nil
vim.rpcrequest({channel}, {method}, {args}, {...}) vim.rpcrequest() Sends a request to {channel} to invoke {method} via RPC and blocks until a response is received.
Note: NIL values as part of the return value is represented as vim.NIL special value
Parameters:
{channel} (integer)
{method} (string)
{args} any[]|nil
{...} any|nil
vim.schedule({callback}) vim.schedule() Schedules {callback} to be invoked soon by the main event-loop. Useful to avoid textlock or other temporary restrictions.
Parameters:
{callback} fun()
vim.str_byteindex({str}, {index}, {use_utf16}) vim.str_byteindex() Convert UTF-32 or UTF-16 {index} to byte index. If {use_utf16} is not supplied, it defaults to false (use UTF-32). Returns the byte index.
Invalid UTF-8 and NUL is treated like by vim.str_byteindex(). An {index} in the middle of a UTF-16 sequence is rounded upwards to the end of that sequence.
Parameters:
{str} (string)
{index} (number)
{use_utf16} any|nil
vim.str_utf_end({str}, {index}) vim.str_utf_end() Gets the distance (in bytes) from the last byte of the codepoint (character) that {index} points to.
Examples:
-- The character 'æ' is stored as the bytes '\xc3\xa6' (using UTF-8)
-- Returns 0 because the index is pointing at the last byte of a character
vim.str_utf_end('æ', 2)
-- Returns 1 because the index is pointing at the penultimate byte of a character
vim.str_utf_end('æ', 1)
Parameters:
{str} (string)
{index} (number)
Return:
(number)
vim.str_utf_pos({str}) vim.str_utf_pos() Gets a list of the starting byte positions of each UTF-8 codepoint in the given string.
Embedded NUL bytes are treated as terminating the string.
Parameters:
{str} (string)
Return:
(table)
vim.str_utf_start({str}, {index}) vim.str_utf_start() Gets the distance (in bytes) from the starting byte of the codepoint (character) that {index} points to.
The result can be added to {index} to get the starting byte of a character.
Examples:
-- The character 'æ' is stored as the bytes '\xc3\xa6' (using UTF-8)
-- Returns 0 because the index is pointing at the first byte of a character
vim.str_utf_start('æ', 1)
-- Returns -1 because the index is pointing at the second byte of a character
vim.str_utf_start('æ', 2)
Parameters:
{str} (string)
{index} (number)
Return:
(number)
vim.str_utfindex({str}, {index}) vim.str_utfindex() Convert byte index to UTF-32 and UTF-16 indices. If {index} is not supplied, the length of the string is used. All indices are zero-based.
Embedded NUL bytes are treated as terminating the string. Invalid UTF-8 bytes, and embedded surrogates are counted as one code point each. An {index} in the middle of a UTF-8 sequence is rounded upwards to the end of that sequence.
Parameters:
{str} (string)
{index} (number|nil)
Return (multiple):
(integer) UTF-32 index (integer) UTF-16 index
vim.stricmp({a}, {b}) vim.stricmp() Compares strings case-insensitively.
Parameters:
{a} (string)
{b} (string)
Return:
0|1|-1 if strings are equal, {a} is greater than {b} or {a} is lesser than {b}, respectively.
vim.ui_attach({ns}, {options}, {callback}) vim.ui_attach() Attach to ui events, similar to nvim_ui_attach() but receive events as Lua callback. Can be used to implement screen elements like popupmenu or message handling in Lua.
{options} should be a dictionary-like table, where ext_... options should be set to true to receive events for the respective external element.
{callback} receives event name plus additional parameters. See ui-popupmenu and the sections below for event format for respective events.
WARNING: This api is considered experimental. Usability will vary for different screen elements. In particular ext_messages behavior is subject to further changes and usability improvements. This is expected to be used to handle messages when setting 'cmdheight' to zero (which is likewise experimental).
Example (stub for a ui-popupmenu implementation):
ns = vim.api.nvim_create_namespace('my_fancy_pum')
vim.ui_attach(ns, {ext_popupmenu=true}, function(event, ...)
  if event == "popupmenu_show" then
    local items, selected, row, col, grid = ...
    print("display pum ", #items)
  elseif event == "popupmenu_select" then
    local selected = ...
    print("selected", selected)
  elseif event == "popupmenu_hide" then
    print("FIN")
  end
end)
Parameters:
{ns} (integer)
{options} table<string, any>
{callback} fun()
vim.ui_detach({ns}) vim.ui_detach() Detach a callback previously attached with vim.ui_attach() for the given namespace {ns}.
Parameters:
{ns} (integer)
vim.wait({time}, {callback}, {interval}, {fast_only}) vim.wait() Wait for {time} in milliseconds until {callback} returns true.
Executes {callback} immediately and at approximately {interval} milliseconds (default 200). Nvim still processes other events during this time.
Examples:
---
-- Wait for 100 ms, allowing other events to process
vim.wait(100, function() end)
---
-- Wait for 100 ms or until global variable set.
vim.wait(100, function() return vim.g.waiting_for_var end)
---
-- Wait for 1 second or until global variable set, checking every ~500 ms
vim.wait(1000, function() return vim.g.waiting_for_var end, 500)
---
-- Schedule a function to set a value in 100ms
vim.defer_fn(function() vim.g.timer_result = true end, 100)
-- Would wait ten seconds if results blocked. Actually only waits  100 ms
if vim.wait(10000, function() return vim.g.timer_result end) then
  print('Only waiting a little bit of time!')
end
Parameters:
{time} (integer) Number of milliseconds to wait
{callback} fun():|nil boolean Optional callback. Waits until {callback} returns true
{interval} (integer|nil) (Approximate) number of milliseconds to wait between polls
{fast_only} (boolean|nil) If true, only api-fast events will be processed. If called from while in an api-fast event, will automatically be set to true.
Return:
boolean, nil|-1|-2
If {callback} returns true during the {time}: true, nil
If {callback} never returns true during the {time}: false, -1
If {callback} is interrupted during the {time}: false, -2
If {callback} errors, the error is raised.

LUA-VIMSCRIPT BRIDGE lua-vimscript

Nvim Lua provides an interface or "bridge" to Vimscript variables and functions, and editor commands and options.
Objects passed over this bridge are COPIED (marshalled): there are no "references". lua-guide-variables For example, using vim.fn.remove() on a Lua list copies the list object to Vimscript and does NOT modify the Lua list:
local list = { 1, 2, 3 }
vim.fn.remove(list, 0)
vim.print(list)  --> "{ 1, 2, 3 }"
vim.call({func}, {...}) vim.call() Invokes vim-function or user-function {func} with arguments {...}. See also vim.fn. Equivalent to:
vim.fn[func]({...})
vim.cmd({command}) See vim.cmd().
vim.fn.{func}({...}) vim.fn Invokes vim-function or user-function {func} with arguments {...}. To call autoload functions, use the syntax:
vim.fn['some#function']({...})
Unlike vim.api.|nvim_call_function()| this converts directly between Vim objects and Lua objects. If the Vim function returns a float, it will be represented directly as a Lua number. Empty lists and dictionaries both are represented by an empty table.
Note: v:null values as part of the return value is represented as vim.NIL special value
Note: vim.fn keys are generated lazily, thus pairs(vim.fn) only enumerates functions that were called at least once.
Note: The majority of functions cannot run in api-fast callbacks with some undocumented exceptions which are allowed.
lua-vim-variables The Vim editor global dictionaries g: w: b: t: v: can be accessed from Lua conveniently and idiomatically by referencing the vim.* Lua tables described below. In this way you can easily read and modify global Vimscript variables from Lua.
Example:
vim.g.foo = 5     -- Set the g:foo Vimscript variable.
print(vim.g.foo)  -- Get and print the g:foo Vimscript variable.
vim.g.foo = nil   -- Delete (:unlet) the Vimscript variable.
vim.b[2].foo = 6  -- Set b:foo for buffer 2
Note that setting dictionary fields directly will not write them back into Nvim. This is because the index into the namespace simply returns a copy. Instead the whole dictionary must be written as one. This can be achieved by creating a short-lived temporary.
Example:
vim.g.my_dict.field1 = 'value'  -- Does not work
local my_dict = vim.g.my_dict   --
my_dict.field1 = 'value'        -- Instead do
vim.g.my_dict = my_dict         --
vim.g vim.g Global (g:) editor variables. Key with no value returns nil.
vim.b vim.b Buffer-scoped (b:) variables for the current buffer. Invalid or unset key returns nil. Can be indexed with an integer to access variables for a specific buffer.
vim.w vim.w Window-scoped (w:) variables for the current window. Invalid or unset key returns nil. Can be indexed with an integer to access variables for a specific window.
vim.t vim.t Tabpage-scoped (t:) variables for the current tabpage. Invalid or unset key returns nil. Can be indexed with an integer to access variables for a specific tabpage.
vim.v vim.v v: variables. Invalid or unset key returns nil.
Vim options can be accessed through vim.o, which behaves like Vimscript :set.
Examples:
To set a boolean toggle: Vimscript: set number Lua: vim.o.number = true
To set a string value: Vimscript: set wildignore=*.o,*.a,__pycache__ Lua: vim.o.wildignore = '*.o,*.a,__pycache__'
Similarly, there is vim.bo and vim.wo for setting buffer-scoped and window-scoped options. Note that this must NOT be confused with local-options and :setlocal. There is also vim.go that only accesses the global value of a global-local option, see :setglobal.
A special interface vim.opt exists for conveniently interacting with list- and map-style option from Lua: It allows accessing them as Lua tables and offers object-oriented method for adding and removing entries.
Examples:
The following methods of setting a list-style option are equivalent: In Vimscript:
set wildignore=*.o,*.a,__pycache__
In Lua using vim.o:
vim.o.wildignore = '*.o,*.a,__pycache__'
In Lua using vim.opt:
vim.opt.wildignore = { '*.o', '*.a', '__pycache__' }
To replicate the behavior of :set+=, use:
vim.opt.wildignore:append { "*.pyc", "node_modules" }
To replicate the behavior of :set^=, use:
vim.opt.wildignore:prepend { "new_first_value" }
To replicate the behavior of :set-=, use:
vim.opt.wildignore:remove { "node_modules" }
The following methods of setting a map-style option are equivalent: In Vimscript:
set listchars=space:_,tab:>~
In Lua using vim.o:
vim.o.listchars = 'space:_,tab:>~'
In Lua using vim.opt:
vim.opt.listchars = { space = '_', tab = '>~' }
Note that vim.opt returns an Option object, not the value of the option, which is accessed through vim.opt:get():
Examples:
The following methods of getting a list-style option are equivalent: In Vimscript:
echo wildignore
In Lua using vim.o:
print(vim.o.wildignore)
In Lua using vim.opt:
vim.print(vim.opt.wildignore:get())
In any of the above examples, to replicate the behavior :setlocal, use vim.opt_local. Additionally, to replicate the behavior of :setglobal, use vim.opt_global.
Option:append({value}) vim.opt:append() Append a value to string-style options. See :set+=
These are equivalent:
vim.opt.formatoptions:append('j')
vim.opt.formatoptions = vim.opt.formatoptions + 'j'
Parameters:
{value} (string) Value to append
Option:get() vim.opt:get() Returns a Lua-representation of the option. Boolean, number and string values will be returned in exactly the same fashion.
For values that are comma-separated lists, an array will be returned with the values as entries in the array:
vim.cmd [[set wildignore=*.pyc,*.o]]
vim.print(vim.opt.wildignore:get())
-- { "*.pyc", "*.o", }
for _, ignore_pattern in ipairs(vim.opt.wildignore:get()) do
    print("Will ignore:", ignore_pattern)
end
-- Will ignore: *.pyc
-- Will ignore: *.o
For values that are comma-separated maps, a table will be returned with the names as keys and the values as entries:
vim.cmd [[set listchars=space:_,tab:>~]]
vim.print(vim.opt.listchars:get())
--  { space = "_", tab = ">~", }
for char, representation in pairs(vim.opt.listchars:get()) do
    print(char, "=>", representation)
end
For values that are lists of flags, a set will be returned with the flags as keys and true as entries.
vim.cmd [[set formatoptions=njtcroql]]
vim.print(vim.opt.formatoptions:get())
-- { n = true, j = true, c = true, ... }
local format_opts = vim.opt.formatoptions:get()
if format_opts.j then
    print("J is enabled!")
end
Return:
string|integer|boolean|nil value of option
Option:prepend({value}) vim.opt:prepend() Prepend a value to string-style options. See :set^=
These are equivalent:
vim.opt.wildignore:prepend('*.o')
vim.opt.wildignore = vim.opt.wildignore ^ '*.o'
Parameters:
{value} (string) Value to prepend
Option:remove({value}) vim.opt:remove() Remove a value from string-style options. See :set-=
These are equivalent:
vim.opt.wildignore:remove('*.pyc')
vim.opt.wildignore = vim.opt.wildignore - '*.pyc'
Parameters:
{value} (string) Value to remove
vim.bo vim.bo Get or set buffer-scoped options for the buffer with number {bufnr}. Like :set and :setlocal. If [{bufnr}] is omitted then the current buffer is used. Invalid {bufnr} or key is an error.
Note: this is equivalent to both :set and :setlocal.
Example:
local bufnr = vim.api.nvim_get_current_buf()
vim.bo[bufnr].buflisted = true    -- same as vim.bo.buflisted = true
print(vim.bo.comments)
print(vim.bo.baz)                 -- error: invalid key
vim.env vim.env Environment variables defined in the editor session. See expand-env and :let-environment for the Vimscript behavior. Invalid or unset key returns nil.
Example:
vim.env.FOO = 'bar'
print(vim.env.TERM)
Parameters:
{var} (string)
vim.go vim.go Get or set global options. Like :setglobal. Invalid key is an error.
Note: this is different from vim.o because this accesses the global option value and thus is mostly useful for use with global-local options.
Example:
vim.go.cmdheight = 4
print(vim.go.columns)
print(vim.go.bar)     -- error: invalid key
vim.o vim.o Get or set options. Like :set. Invalid key is an error.
Note: this works on both buffer-scoped and window-scoped options using the current buffer and window.
Example:
vim.o.cmdheight = 4
print(vim.o.columns)
print(vim.o.foo)     -- error: invalid key
vim.wo vim.wo Get or set window-scoped options for the window with handle {winid} and buffer with number {bufnr}. Like :setlocal if {bufnr} is provided, like :set otherwise. If [{winid}] is omitted then the current window is used. Invalid {winid}, {bufnr} or key is an error.
Note: only {bufnr} with value 0 (the current buffer in the window) is supported.
Example:
local winid = vim.api.nvim_get_current_win()
vim.wo[winid].number = true    -- same as vim.wo.number = true
print(vim.wo.foldmarker)
print(vim.wo.quux)             -- error: invalid key
vim.wo[winid][0].spell = false -- like ':setlocal nospell'

Lua module: vim lua-vim

vim.cmd vim.cmd() Execute Vim script commands.
Note that vim.cmd can be indexed with a command name to return a callable function to the command.
Example:
vim.cmd('echo 42')
vim.cmd([[
  augroup My_group
    autocmd!
    autocmd FileType c setlocal cindent
  augroup END
]])
-- Ex command :echo "foo"
-- Note string literals need to be double quoted.
vim.cmd('echo "foo"')
vim.cmd { cmd = 'echo', args = { '"foo"' } }
vim.cmd.echo({ args = { '"foo"' } })
vim.cmd.echo('"foo"')
-- Ex command :write! myfile.txt
vim.cmd('write! myfile.txt')
vim.cmd { cmd = 'write', args = { "myfile.txt" }, bang = true }
vim.cmd.write { args = { "myfile.txt" }, bang = true }
vim.cmd.write { "myfile.txt", bang = true }
-- Ex command :colorscheme blue
vim.cmd('colorscheme blue')
vim.cmd.colorscheme('blue')
Parameters:
{command} string|table Command(s) to execute. If a string, executes multiple lines of Vim script at once. In this case, it is an alias to nvim_exec2(), where opts.output is set to false. Thus it works identical to :source. If a table, executes a single command. In this case, it is an alias to nvim_cmd() where opts is empty.
See also:
vim.defer_fn({fn}, {timeout}) vim.defer_fn() Defers calling {fn} until {timeout} ms passes.
Use to do a one-shot timer that calls {fn} Note: The {fn} is vim.schedule_wrap()ped automatically, so API functions are safe to call.
Parameters:
{fn} (function) Callback to call once timeout expires
{timeout} (integer) Number of milliseconds to wait before calling fn
Return:
(table) timer luv timer object
vim.deprecate() vim.deprecate({name}, {alternative}, {version}, {plugin}, {backtrace}) Shows a deprecation message to the user.
Parameters:
{name} string Deprecated feature (function, API, etc.).
{alternative} (string|nil) Suggested alternative feature.
{version} string Version when the deprecated function will be removed.
{plugin} string|nil Name of the plugin that owns the deprecated feature. Defaults to "Nvim".
{backtrace} boolean|nil Prints backtrace. Defaults to true.
Return:
(string|nil) Deprecated message, or nil if no message was shown.
vim.inspect vim.inspect() Gets a human-readable representation of the given object.
Return:
(string)
vim.keycode({str}) vim.keycode() Translate keycodes.
Example:
local k = vim.keycode
vim.g.mapleader = k'<bs>'
Parameters:
{str} (string) String to be converted.
Return:
(string)
vim.lua_omnifunc({find_start}, {_}) vim.lua_omnifunc() Omnifunc for completing Lua values from the runtime Lua interpreter, similar to the builtin completion for the :lua command.
Activate using set omnifunc=v:lua.vim.lua_omnifunc in a Lua buffer.
vim.notify({msg}, {level}, {opts}) vim.notify() Display a notification to the user.
This function can be overridden by plugins to display notifications using a custom provider (such as the system notification provider). By default, writes to :messages.
Parameters:
{msg} (string) Content of the notification to show to the user.
{level} (integer|nil) One of the values from vim.log.levels.
{opts} (table|nil) Optional parameters. Unused by default.
vim.notify_once({msg}, {level}, {opts}) vim.notify_once() Display a notification only one time.
Like vim.notify(), but subsequent calls with the same message will not display a notification.
Parameters:
{msg} (string) Content of the notification to show to the user.
{level} (integer|nil) One of the values from vim.log.levels.
{opts} (table|nil) Optional parameters. Unused by default.
Return:
(boolean) true if message was displayed, else false
vim.on_key({fn}, {ns_id}) vim.on_key() Adds Lua function {fn} with namespace id {ns_id} as a listener to every, yes every, input key.
The Nvim command-line option -w is related but does not support callbacks and cannot be toggled dynamically.
Note:
{fn} will be removed on error.
{fn} will not be cleared by nvim_buf_clear_namespace()
{fn} will receive the keys after mappings have been evaluated
Parameters:
{fn} fun(key: string) Function invoked on every key press. i_CTRL-V Returning nil removes the callback associated with namespace {ns_id}.
{ns_id} integer? Namespace ID. If nil or 0, generates and returns a new nvim_create_namespace() id.
Return:
(integer) Namespace id associated with {fn}. Or count of all callbacks if on_key() is called without arguments.
vim.paste({lines}, {phase}) vim.paste() Paste handler, invoked by nvim_paste() when a conforming UI (such as the TUI) pastes text into the editor.
Example: To remove ANSI color codes when pasting:
vim.paste = (function(overridden)
  return function(lines, phase)
    for i,line in ipairs(lines) do
      -- Scrub ANSI color codes from paste input.
      lines[i] = line:gsub('\27%[[0-9;mK]+', '')
    end
    overridden(lines, phase)
  end
end)(vim.paste)
Parameters:
{lines} string[] # readfile()-style list of lines to paste. channel-lines
{phase} paste_phase -1: "non-streaming" paste: the call contains all lines. If paste is "streamed", phase indicates the stream state:
1: starts the paste (exactly once)
2: continues the paste (zero or more times)
3: ends the paste (exactly once)
Return:
(boolean) result false if client should cancel the paste.
See also:
paste @alias paste_phase -1 | 1 | 2 | 3
vim.print({...}) vim.print() "Pretty prints" the given arguments and returns them unmodified.
Example:
local hl_normal = vim.print(vim.api.nvim_get_hl_by_name('Normal', true))
Return:
any given arguments.
See also:
:=
vim.region() vim.region({bufnr}, {pos1}, {pos2}, {regtype}, {inclusive}) Gets a dict of line segment ("chunk") positions for the region from pos1 to pos2.
Input and output positions are byte positions, (0,0)-indexed. "End of line" column position (for example, linewise visual selection) is returned as v:maxcol (big number).
Parameters:
{bufnr} (integer) Buffer number, or 0 for current buffer
{pos1} integer[]|string Start of region as a (line, column) tuple or getpos()-compatible string
{pos2} integer[]|string End of region as a (line, column) tuple or getpos()-compatible string
{regtype} (string) setreg()-style selection type
{inclusive} (boolean) Controls whether pos2 column is inclusive (see also 'selection').
Return:
(table) region Dict of the form {linenr = {startcol,endcol}}. endcol is exclusive, and whole lines are returned as {startcol,endcol} = {0,-1}.
vim.schedule_wrap({cb}) vim.schedule_wrap() Defers callback cb until the Nvim API is safe to call.
Parameters:
{cb} (function)
Return:
(function)
vim.system({cmd}, {opts}, {on_exit}) vim.system() Run a system command
Examples:
local on_exit = function(obj)
  print(obj.code)
  print(obj.signal)
  print(obj.stdout)
  print(obj.stderr)
end
-- Run asynchronously
vim.system({'echo', 'hello'}, { text = true }, on_exit)
-- Run synchronously
local obj = vim.system({'echo', 'hello'}, { text = true }):wait()
-- { code = 0, signal = 0, stdout = 'hello', stderr = '' }
See uv.spawn() for more details.
Parameters:
{cmd} (string[]) Command to execute
{opts} (SystemOpts|nil) Options:
cwd: (string) Set the current working directory for the sub-process.
env: table<string,string> Set environment variables for the new process. Inherits the current environment with NVIM set to v:servername.
clear_env: (boolean) env defines the job environment exactly, instead of merging current environment.
stdin: (string|string[]|boolean) If true, then a pipe to stdin is opened and can be written to via the write() method to SystemObj. If string or string[] then will be written to stdin and closed. Defaults to false.
stdout: (boolean|function) Handle output from stdout. When passed as a function must have the signature fun(err: string, data: string). Defaults to true
stderr: (boolean|function) Handle output from stderr. When passed as a function must have the signature fun(err: string, data: string). Defaults to true.
text: (boolean) Handle stdout and stderr as text. Replaces \r\n with \n.
timeout: (integer) Run the command with a time limit. Upon timeout the process is sent the TERM signal (15) and the exit code is set to 124.
detach: (boolean) If true, spawn the child process in a detached state - this will make it a process group leader, and will effectively enable the child to keep running after the parent exits. Note that the child process will still keep the parent's event loop alive unless the parent process calls uv.unref() on the child's process handle.
{on_exit} (function|nil) Called when subprocess exits. When provided, the command runs asynchronously. Receives SystemCompleted object, see return of SystemObj:wait().
Return:
vim.SystemObj Object with the fields:
pid (integer) Process ID
wait (fun(timeout: integer|nil): SystemCompleted) Wait for the process to complete. Upon timeout the process is sent the KILL signal (9) and the exit code is set to 124.
SystemCompleted is an object with the fields:
code: (integer)
signal: (integer)
stdout: (string), nil if stdout argument is passed
stderr: (string), nil if stderr argument is passed
kill (fun(signal: integer|string))
write (fun(data: string|nil)) Requires stdin=true. Pass nil to close the stream.
is_closing (fun(): boolean)

Lua module: vim.inspector vim.inspector

vim.inspect_pos({bufnr}, {row}, {col}, {filter}) vim.inspect_pos() Get all the items at a given buffer position.
Can also be pretty-printed with :Inspect!. :Inspect!
Parameters:
{bufnr} (integer|nil) defaults to the current buffer
{row} (integer|nil) row to inspect, 0-based. Defaults to the row of the current cursor
{col} (integer|nil) col to inspect, 0-based. Defaults to the col of the current cursor
{filter} (table|nil) a table with key-value pairs to filter the items
syntax (boolean): include syntax based highlight groups (defaults to true)
treesitter (boolean): include treesitter based highlight groups (defaults to true)
extmarks (boolean|"all"): include extmarks. When all, then extmarks without a hl_group will also be included (defaults to true)
semantic_tokens (boolean): include semantic tokens (defaults to true)
Return:
(table) a table with the following key-value pairs. Items are in "traversal order":
treesitter: a list of treesitter captures
syntax: a list of syntax groups
semantic_tokens: a list of semantic tokens
extmarks: a list of extmarks
buffer: the buffer used to get the items
row: the row used to get the items
col: the col used to get the items
vim.show_pos({bufnr}, {row}, {col}, {filter}) vim.show_pos() Show all the items at a given buffer position.
Can also be shown with :Inspect. :Inspect
Parameters:
{bufnr} (integer|nil) defaults to the current buffer
{row} (integer|nil) row to inspect, 0-based. Defaults to the row of the current cursor
{col} (integer|nil) col to inspect, 0-based. Defaults to the col of the current cursor
{filter} (table|nil) see vim.inspect_pos()
vim.deep_equal({a}, {b}) vim.deep_equal() Deep compare values for equality
Tables are compared recursively unless they both provide the eq metamethod. All other types are compared using the equality == operator.
Parameters:
{a} any First value
{b} any Second value
Return:
(boolean) true if values are equals, else false
vim.deepcopy({orig}) vim.deepcopy() Returns a deep copy of the given object. Non-table objects are copied as in a typical Lua assignment, whereas table objects are copied recursively. Functions are naively copied, so functions in the copied table point to the same functions as those in the input table. Userdata and threads are not copied and will throw an error.
Parameters:
{orig} (table) Table to copy
Return:
(table) Table of copied keys and (nested) values.
vim.defaulttable({createfn}) vim.defaulttable() Creates a table whose missing keys are provided by {createfn} (like Python's "defaultdict").
If {createfn} is nil it defaults to defaulttable() itself, so accessing nested keys creates nested tables:
local a = vim.defaulttable()
a.b.c = 1
Parameters:
{createfn} function?(key:any):any Provides the value for a missing key.
Return:
(table) Empty table with __index metamethod.
vim.endswith({s}, {suffix}) vim.endswith() Tests if s ends with suffix.
Parameters:
{s} (string) String
{suffix} (string) Suffix to match
Return:
(boolean) true if suffix is a suffix of s
vim.gsplit({s}, {sep}, {opts}) vim.gsplit() Gets an iterator that splits a string at each instance of a separator, in "lazy" fashion (as opposed to vim.split() which is "eager").
Example:
for s in vim.gsplit(':aa::b:', ':', {plain=true}) do
  print(s)
end
If you want to also inspect the separator itself (instead of discarding it), use string.gmatch(). Example:
for word, num in ('foo111bar222'):gmatch('([^0-9]*)(%d*)') do
  print(('word: %s num: %s'):format(word, num))
end
Parameters:
{s} (string) String to split
{sep} (string) Separator or pattern
{opts} (table|nil) Keyword arguments kwargs:
plain: (boolean) Use sep literally (as in string.find).
trimempty: (boolean) Discard empty segments at start and end of the sequence.
Return:
(function) Iterator over the split components
vim.is_callable({f}) vim.is_callable() Returns true if object f can be called as a function.
Parameters:
{f} any Any object
Return:
(boolean) true if f is callable, else false
vim.list_contains({t}, {value}) vim.list_contains() Checks if a list-like table (integer keys without gaps) contains value.
Parameters:
{t} (table) Table to check (must be list-like, not validated)
{value} any Value to compare
Return:
(boolean) true if t contains value
See also:
vim.tbl_contains() for checking values in general tables
vim.list_extend({dst}, {src}, {start}, {finish}) vim.list_extend() Extends a list-like table with the values of another list-like table.
NOTE: This mutates dst!
Parameters:
{dst} (table) List which will be modified and appended to
{src} (table) List from which values will be inserted
{start} (integer|nil) Start index on src. Defaults to 1
{finish} (integer|nil) Final index on src. Defaults to #src
Return:
(table) dst
See also:
vim.list_slice({list}, {start}, {finish}) vim.list_slice() Creates a copy of a table containing only elements from start to end (inclusive)
Parameters:
{list} (list) Table
{start} (integer|nil) Start range of slice
{finish} (integer|nil) End range of slice
Return:
(list) Copy of table sliced from start to finish (inclusive)
vim.pesc({s}) vim.pesc() Escapes magic chars in lua-patterns.
Parameters:
{s} (string) String to escape
Return:
(string) %-escaped pattern string
vim.ringbuf({size}) vim.ringbuf() Create a ring buffer limited to a maximal number of items. Once the buffer is full, adding a new entry overrides the oldest entry.
local ringbuf = vim.ringbuf(4)
ringbuf:push("a")
ringbuf:push("b")
ringbuf:push("c")
ringbuf:push("d")
ringbuf:push("e")    -- overrides "a"
print(ringbuf:pop()) -- returns "b"
print(ringbuf:pop()) -- returns "c"
-- Can be used as iterator. Pops remaining items:
for val in ringbuf do
  print(val)
end
Returns a Ringbuf instance with the following methods:
Parameters:
{size} (integer)
Return:
(table)
vim.Ringbuf:clear() Ringbuf:clear() Clear all items.
vim.Ringbuf:peek() Ringbuf:peek() Returns the first unread item without removing it
Return:
any?|nil
vim.Ringbuf:pop() Ringbuf:pop() Removes and returns the first unread item
Return:
any?|nil
vim.Ringbuf:push({item}) Ringbuf:push() Adds an item, overriding the oldest item if the buffer is full.
Parameters:
{item} any
vim.spairs({t}) vim.spairs() Enumerates key-value pairs of a table, ordered by key.
Parameters:
{t} (table) Dict-like table
Return:
(function) for-in iterator over sorted keys and their values
vim.split({s}, {sep}, {opts}) vim.split() Splits a string at each instance of a separator and returns the result as a table (unlike vim.gsplit()).
Examples:
split(":aa::b:", ":")                   --> {'','aa','','b',''}
split("axaby", "ab?")                   --> {'','x','y'}
split("x*yz*o", "*", {plain=true})      --> {'x','yz','o'}
split("|x|y|z|", "|", {trimempty=true}) --> {'x', 'y', 'z'}
Parameters:
{s} (string) String to split
{sep} (string) Separator or pattern
{opts} (table|nil) Keyword arguments kwargs accepted by vim.gsplit()
Return:
string[] List of split components
vim.startswith({s}, {prefix}) vim.startswith() Tests if s starts with prefix.
Parameters:
{s} (string) String
{prefix} (string) Prefix to match
Return:
(boolean) true if prefix is a prefix of s
vim.tbl_add_reverse_lookup({o}) vim.tbl_add_reverse_lookup() Add the reverse lookup values to an existing table. For example: tbl_add_reverse_lookup { A = 1 } == { [1] = 'A', A = 1 }
Note that this modifies the input.
Parameters:
{o} (table) Table to add the reverse to
Return:
(table) o
vim.tbl_contains({t}, {value}, {opts}) vim.tbl_contains() Checks if a table contains a given value, specified either directly or via a predicate that is checked for each value.
Example:
vim.tbl_contains({ 'a', { 'b', 'c' } }, function(v)
  return vim.deep_equal(v, { 'b', 'c' })
end, { predicate = true })
-- true
Parameters:
{t} (table) Table to check
{value} any Value to compare or predicate function reference
{opts} (table|nil) Keyword arguments kwargs:
predicate: (boolean) value is a function reference to be checked (default false)
Return:
(boolean) true if t contains value
See also:
vim.list_contains() for checking values in list-like tables
vim.tbl_count({t}) vim.tbl_count() Counts the number of non-nil values in table t.
vim.tbl_count({ a=1, b=2 })  --> 2
vim.tbl_count({ 1, 2 })      --> 2
Parameters:
{t} (table) Table
Return:
(integer) Number of non-nil values in table
vim.tbl_deep_extend({behavior}, {...}) vim.tbl_deep_extend() Merges recursively two or more tables.
Parameters:
{behavior} (string) Decides what to do if a key is found in more than one map:
"error": raise an error
"keep": use value from the leftmost map
"force": use value from the rightmost map
{...} (table) Two or more tables
Return:
(table) Merged table
See also:
vim.tbl_extend({behavior}, {...}) vim.tbl_extend() Merges two or more tables.
Parameters:
{behavior} (string) Decides what to do if a key is found in more than one map:
"error": raise an error
"keep": use value from the leftmost map
"force": use value from the rightmost map
{...} (table) Two or more tables
Return:
(table) Merged table
See also:
vim.tbl_filter({func}, {t}) vim.tbl_filter() Filter a table using a predicate function
Parameters:
{func} (function) Function
{t} (table) Table
Return:
(table) Table of filtered values
vim.tbl_flatten({t}) vim.tbl_flatten() Creates a copy of a list-like table such that any nested tables are "unrolled" and appended to the result.
Parameters:
{t} (table) List-like table
Return:
(table) Flattened copy of the given list-like table
vim.tbl_get({o}, {...}) vim.tbl_get() Index into a table (first argument) via string keys passed as subsequent arguments. Return nil if the key does not exist.
Examples:
vim.tbl_get({ key = { nested_key = true }}, 'key', 'nested_key') == true
vim.tbl_get({ key = {}}, 'key', 'nested_key') == nil
Parameters:
{o} (table) Table to index
{...} any Optional keys (0 or more, variadic) via which to index the table
Return:
any Nested value indexed by key (if it exists), else nil
vim.tbl_isarray({t}) vim.tbl_isarray() Tests if t is an "array": a table indexed only by integers (potentially non-contiguous).
If the indexes start from 1 and are contiguous then the array is also a list. vim.tbl_islist()
Empty table {} is an array, unless it was created by vim.empty_dict() or returned as a dict-like API or Vimscript result, for example from rpcrequest() or vim.fn.
Parameters:
{t} (table)
Return:
(boolean) true if array-like table, else false.
vim.tbl_isempty({t}) vim.tbl_isempty() Checks if a table is empty.
Parameters:
{t} (table) Table to check
Return:
(boolean) true if t is empty
vim.tbl_islist({t}) vim.tbl_islist() Tests if t is a "list": a table indexed only by contiguous integers starting from 1 (what lua-length calls a "regular array").
Empty table {} is a list, unless it was created by vim.empty_dict() or returned as a dict-like API or Vimscript result, for example from rpcrequest() or vim.fn.
Parameters:
{t} (table)
Return:
(boolean) true if list-like table, else false.
See also:
vim.tbl_keys({t}) vim.tbl_keys() Return a list of all keys used in a table. However, the order of the return table of keys is not guaranteed.
Parameters:
{t} (table) Table
Return:
(list) List of keys
vim.tbl_map({func}, {t}) vim.tbl_map() Apply a function to all values of a table.
Parameters:
{func} (function) Function
{t} (table) Table
Return:
(table) Table of transformed values
vim.tbl_values({t}) vim.tbl_values() Return a list of all values used in a table. However, the order of the return table of values is not guaranteed.
Parameters:
{t} (table) Table
Return:
(list) List of values
vim.trim({s}) vim.trim() Trim whitespace (Lua pattern "%s") from both sides of a string.
Parameters:
{s} (string) String to trim
Return:
(string) String with whitespace removed from its beginning and end
vim.validate({opt}) vim.validate() Validates a parameter specification (types and values).
Usage example:
function user.new(name, age, hobbies)
  vim.validate{
    name={name, 'string'},
    age={age, 'number'},
    hobbies={hobbies, 'table'},
  }
  ...
end
Examples with explicit argument values (can be run directly):
vim.validate{arg1={{'foo'}, 'table'}, arg2={'foo', 'string'}}
   --> NOP (success)
vim.validate{arg1={1, 'table'}}
   --> error('arg1: expected table, got number')
vim.validate{arg1={3, function(a) return (a % 2) == 0 end, 'even number'}}
   --> error('arg1: expected even number, got 3')
If multiple types are valid they can be given as a list.
vim.validate{arg1={{'foo'}, {'table', 'string'}}, arg2={'foo', {'table', 'string'}}}
-- NOP (success)
vim.validate{arg1={1, {'string', 'table'}}}
-- error('arg1: expected string|table, got number')
Parameters:
{opt} (table) Names of parameters to validate. Each key is a parameter name; each value is a tuple in one of these forms: 1. (arg_value, type_name, optional)
arg_value: argument value
type_name: string|table type name, one of: ("table", "t", "string", "s", "number", "n", "boolean", "b", "function", "f", "nil", "thread", "userdata") or list of them.
optional: (optional) boolean, if true, nil is valid
2. (arg_value, fn, msg)
arg_value: argument value
fn: any function accepting one argument, returns true if and only if the argument is valid. Can optionally return an additional informative error message as the second returned value.
msg: (optional) error string if validation fails

Lua module: vim.loader vim.loader

vim.loader.disable() vim.loader.disable() Disables the experimental Lua module loader:
removes the loaders
adds the default Nvim loader
vim.loader.enable() vim.loader.enable() Enables the experimental Lua module loader:
overrides loadfile
adds the Lua loader using the byte-compilation cache
adds the libs loader
removes the default Nvim loader
vim.loader.find({modname}, {opts}) vim.loader.find() Finds Lua modules for the given module name.
Parameters:
{modname} (string) Module name, or "*" to find the top-level modules instead
{opts} (table|nil) Options for finding a module:
rtp: (boolean) Search for modname in the runtime path (defaults to true)
paths: (string[]) Extra paths to search for modname (defaults to {})
patterns: (string[]) List of patterns to use when searching for modules. A pattern is a string added to the basename of the Lua module being searched. (defaults to {"/init.lua", ".lua"})
all: (boolean) Return all matches instead of just the first one (defaults to false)
Return:
(list) A list of results with the following properties:
modpath: (string) the path to the module
modname: (string) the name of the module
stat: (table|nil) the fs_stat of the module path. Won't be returned for modname="*"
vim.loader.reset({path}) vim.loader.reset() Resets the cache for the path, or all the paths if path is nil.
Parameters:
{path} string? path to reset

Lua module: vim.uri vim.uri

vim.uri_decode({str}) vim.uri_decode() URI-decodes a string containing percent escapes.
Parameters:
{str} (string) string to decode
Return:
(string) decoded string
vim.uri_encode({str}, {rfc}) vim.uri_encode() URI-encodes a string using percent escapes.
Parameters:
{str} (string) string to encode
{rfc} "rfc2396" | "rfc2732" | "rfc3986" | nil
Return:
(string) encoded string
vim.uri_from_bufnr({bufnr}) vim.uri_from_bufnr() Gets a URI from a bufnr.
Parameters:
{bufnr} (integer)
Return:
(string) URI
vim.uri_from_fname({path}) vim.uri_from_fname() Gets a URI from a file path.
Parameters:
{path} (string) Path to file
Return:
(string) URI
vim.uri_to_bufnr({uri}) vim.uri_to_bufnr() Gets the buffer for a uri. Creates a new unloaded buffer if no buffer for the uri already exists.
Parameters:
{uri} (string)
Return:
(integer) bufnr
vim.uri_to_fname({uri}) vim.uri_to_fname() Gets a filename from a URI.
Parameters:
{uri} (string)
Return:
(string) filename or unchanged URI for non-file URIs

Lua module: vim.ui vim.ui

vim.ui.input({opts}, {on_confirm}) vim.ui.input() Prompts the user for input, allowing arbitrary (potentially asynchronous) work until on_confirm.
Example:
vim.ui.input({ prompt = 'Enter value for shiftwidth: ' }, function(input)
    vim.o.shiftwidth = tonumber(input)
end)
Parameters:
{opts} (table) Additional options. See input()
prompt (string|nil) Text of the prompt
default (string|nil) Default reply to the input
completion (string|nil) Specifies type of completion supported for input. Supported types are the same that can be supplied to a user-defined command using the "-complete=" argument. See :command-completion
highlight (function) Function that will be used for highlighting user inputs.
{on_confirm} (function) ((input|nil) -> ()) Called once the user confirms or abort the input. input is what the user typed (it might be an empty string if nothing was entered), or nil if the user aborted the dialog.
vim.ui.open({path}) vim.ui.open() Opens path with the system default handler (macOS open, Windows explorer.exe, Linux xdg-open, …), or returns (but does not show) an error message on failure.
Expands "~/" and environment variables in filesystem paths.
Examples:
vim.ui.open("https://neovim.io/")
vim.ui.open("~/path/to/file")
vim.ui.open("$VIMRUNTIME")
Parameters:
{path} (string) Path or URL to open
Return (multiple):
vim.SystemCompleted|nil Command result, or nil if not found. (string|nil) Error message on failure
See also:
vim.ui.select({items}, {opts}, {on_choice}) vim.ui.select() Prompts the user to pick from a list of items, allowing arbitrary (potentially asynchronous) work until on_choice.
Example:
vim.ui.select({ 'tabs', 'spaces' }, {
    prompt = 'Select tabs or spaces:',
    format_item = function(item)
        return "I'd like to choose " .. item
    end,
}, function(choice)
    if choice == 'spaces' then
        vim.o.expandtab = true
    else
        vim.o.expandtab = false
    end
end)
Parameters:
{items} (table) Arbitrary items
{opts} (table) Additional options
prompt (string|nil) Text of the prompt. Defaults to Select one of:
format_item (function item -> text) Function to format an individual item from items. Defaults to tostring.
kind (string|nil) Arbitrary hint string indicating the item shape. Plugins reimplementing vim.ui.select may wish to use this to infer the structure or semantics of items, or the context in which select() was called.
{on_choice} (function) ((item|nil, idx|nil) -> ()) Called once the user made a choice. idx is the 1-based index of item within items. nil if the user aborted the dialog.

Lua module: vim.filetype vim.filetype

vim.filetype.add({filetypes}) vim.filetype.add() Add new filetype mappings.
Filetype mappings can be added either by extension or by filename (either the "tail" or the full file path). The full file path is checked first, followed by the file name. If a match is not found using the filename, then the filename is matched against the list of lua-patterns (sorted by priority) until a match is found. Lastly, if pattern matching does not find a filetype, then the file extension is used.
The filetype can be either a string (in which case it is used as the filetype directly) or a function. If a function, it takes the full path and buffer number of the file as arguments (along with captures from the matched pattern, if any) and should return a string that will be used as the buffer's filetype. Optionally, the function can return a second function value which, when called, modifies the state of the buffer. This can be used to, for example, set filetype-specific buffer variables. This function will be called by Nvim before setting the buffer's filetype.
Filename patterns can specify an optional priority to resolve cases when a file path matches multiple patterns. Higher priorities are matched first. When omitted, the priority defaults to 0. A pattern can contain environment variables of the form "${SOME_VAR}" that will be automatically expanded. If the environment variable is not set, the pattern won't be matched.
See $VIMRUNTIME/lua/vim/filetype.lua for more examples.
Example:
vim.filetype.add({
  extension = {
    foo = 'fooscript',
    bar = function(path, bufnr)
      if some_condition() then
        return 'barscript', function(bufnr)
          -- Set a buffer variable
          vim.b[bufnr].barscript_version = 2
        end
      end
      return 'bar'
    end,
  },
  filename = {
    ['.foorc'] = 'toml',
    ['/etc/foo/config'] = 'toml',
  },
  pattern = {
    ['.*&zwj;/etc/foo/.*'] = 'fooscript',
    -- Using an optional priority
    ['.*&zwj;/etc/foo/.*%.conf'] = { 'dosini', { priority = 10 } },
    -- A pattern containing an environment variable
    ['${XDG_CONFIG_HOME}/foo/git'] = 'git',
    ['README.(%a+)$'] = function(path, bufnr, ext)
      if ext == 'md' then
        return 'markdown'
      elseif ext == 'rst' then
        return 'rst'
      end
    end,
  },
})
To add a fallback match on contents, use
vim.filetype.add {
  pattern = {
    ['.*'] = {
      priority = -math.huge,
      function(path, bufnr)
        local content = vim.api.nvim_buf_get_lines(bufnr, 0, 1, false)[1] or ''
        if vim.regex([[^#!.*\\<mine\\>]]):match_str(content) ~= nil then
          return 'mine'
        elseif vim.regex([[\\<drawing\\>]]):match_str(content) ~= nil then
          return 'drawing'
        end
      end,
    },
  },
}
Parameters:
{filetypes} (table) A table containing new filetype maps (see example).
vim.filetype.get_option() vim.filetype.get_option({filetype}, {option}) Get the default option value for a {filetype}.
The returned value is what would be set in a new buffer after 'filetype' is set, meaning it should respect all FileType autocmds and ftplugin files.
Example:
vim.filetype.get_option('vim', 'commentstring')
Note: this uses nvim_get_option_value() but caches the result. This means ftplugin and FileType autocommands are only triggered once and may not reflect later changes.
Parameters:
{filetype} (string) Filetype
{option} (string) Option name
Return:
string|boolean|integer: Option value
vim.filetype.match({args}) vim.filetype.match() Perform filetype detection.
The filetype can be detected using one of three methods: 1. Using an existing buffer 2. Using only a file name 3. Using only file contents
Of these, option 1 provides the most accurate result as it uses both the buffer's filename and (optionally) the buffer contents. Options 2 and 3 can be used without an existing buffer, but may not always provide a match in cases where the filename (or contents) cannot unambiguously determine the filetype.
Each of the three options is specified using a key to the single argument of this function. Example:
-- Using a buffer number
vim.filetype.match({ buf = 42 })
-- Override the filename of the given buffer
vim.filetype.match({ buf = 42, filename = 'foo.c' })
-- Using a filename without a buffer
vim.filetype.match({ filename = 'main.lua' })
-- Using file contents
vim.filetype.match({ contents = {'#!/usr/bin/env bash'} })
Parameters:
{args} (table) Table specifying which matching strategy to use. Accepted keys are:
buf (number): Buffer number to use for matching. Mutually exclusive with {contents}
filename (string): Filename to use for matching. When {buf} is given, defaults to the filename of the given buffer number. The file need not actually exist in the filesystem. When used without {buf} only the name of the file is used for filetype matching. This may result in failure to detect the filetype in cases where the filename alone is not enough to disambiguate the filetype.
contents (table): An array of lines representing file contents to use for matching. Can be used with {filename}. Mutually exclusive with {buf}.
Return (multiple):
(string|nil) If a match was found, the matched filetype. (function|nil) A function that modifies buffer state when called (for example, to set some filetype specific buffer variables). The function accepts a buffer number as its only argument.

Lua module: vim.keymap vim.keymap

vim.keymap.del({modes}, {lhs}, {opts}) vim.keymap.del() Remove an existing mapping. Examples:
vim.keymap.del('n', 'lhs')
vim.keymap.del({'n', 'i', 'v'}, '<leader>w', { buffer = 5 })
Parameters:
{opts} (table|nil) A table of optional arguments:
"buffer": (number|boolean) Remove a mapping from the given buffer. When 0 or true, use the current buffer.
See also:
vim.keymap.set({mode}, {lhs}, {rhs}, {opts}) vim.keymap.set() Adds a new mapping. Examples:
-- Map to a Lua function:
vim.keymap.set('n', 'lhs', function() print("real lua function") end)
-- Map to multiple modes:
vim.keymap.set({'n', 'v'}, '<leader>lr', vim.lsp.buf.references, { buffer = true })
-- Buffer-local mapping:
vim.keymap.set('n', '<leader>w', "<cmd>w<cr>", { silent = true, buffer = 5 })
-- Expr mapping:
vim.keymap.set('i', '<Tab>', function()
  return vim.fn.pumvisible() == 1 and "<C-n>" or "<Tab>"
end, { expr = true })
-- <Plug> mapping:
vim.keymap.set('n', '[%%', '<Plug>(MatchitNormalMultiBackward)')
Parameters:
{mode} string|table Mode short-name, see nvim_set_keymap(). Can also be list of modes to create mapping on multiple modes.
{lhs} (string) Left-hand side {lhs} of the mapping.
{rhs} string|function Right-hand side {rhs} of the mapping, can be a Lua function.
{opts} (table|nil) Table of :map-arguments.
Same as nvim_set_keymap() {opts}, except:
"replace_keycodes" defaults to true if "expr" is true.
"noremap": inverse of "remap" (see below).
Also accepts:
"buffer": (number|boolean) Creates buffer-local mapping, 0 or true for current buffer.
"remap": (boolean) Make the mapping recursive. Inverse of "noremap". Defaults to false.

Lua module: vim.fs vim.fs

vim.fs.basename({file}) vim.fs.basename() Return the basename of the given path
Parameters:
{file} (string) Path
Return:
(string|nil) Basename of {file}
vim.fs.dir({path}, {opts}) vim.fs.dir() Return an iterator over the items located in {path}
Parameters:
{path} (string) An absolute or relative path to the directory to iterate over. The path is first normalized vim.fs.normalize().
{opts} (table|nil) Optional keyword arguments:
depth: integer|nil How deep the traverse (default 1)
skip: (fun(dir_name: string): boolean)|nil Predicate to control traversal. Return false to stop searching the current directory. Only useful when depth > 1
Return:
Iterator over items in {path}. Each iteration yields two values: "name" and "type". "name" is the basename of the item relative to {path}. "type" is one of the following: "file", "directory", "link", "fifo", "socket", "char", "block", "unknown".
vim.fs.dirname({file}) vim.fs.dirname() Return the parent directory of the given path
Parameters:
{file} (string) Path
Return:
(string|nil) Parent directory of {file}
vim.fs.find({names}, {opts}) vim.fs.find() Find files or directories (or other items as specified by opts.type) in the given path.
Finds items given in {names} starting from {path}. If {upward} is "true" then the search traverses upward through parent directories; otherwise, the search traverses downward. Note that downward searches are recursive and may search through many directories! If {stop} is non-nil, then the search stops when the directory given in {stop} is reached. The search terminates when {limit} (default 1) matches are found. You can set {type} to "file", "directory", "link", "socket", "char", "block", or "fifo" to narrow the search to find only that type.
Examples:
-- location of Cargo.toml from the current buffer's path
local cargo = vim.fs.find('Cargo.toml', {
  upward = true,
  stop = vim.uv.os_homedir(),
  path = vim.fs.dirname(vim.api.nvim_buf_get_name(0)),
})
-- list all test directories under the runtime directory
local test_dirs = vim.fs.find(
  {'test', 'tst', 'testdir'},
  {limit = math.huge, type = 'directory', path = './runtime/'}
)
-- get all files ending with .cpp or .hpp inside lib/
local cpp_hpp = vim.fs.find(function(name, path)
  return name:match('.*%.[ch]pp$') and path:match('[/\\\\]lib$')
end, {limit = math.huge, type = 'file'})
Parameters:
{names} (string|string[]|fun(name: string, path: string): boolean) Names of the items to find. Must be base names, paths and globs are not supported when {names} is a string or a table. If {names} is a function, it is called for each traversed item with args:
name: base name of the current item
path: full path of the current item The function should return true if the given item is considered a match.
{opts} (table) Optional keyword arguments:
path (string): Path to begin searching from. If omitted, the current-directory is used.
upward (boolean, default false): If true, search upward through parent directories. Otherwise, search through child directories (recursively).
stop (string): Stop searching when this directory is reached. The directory itself is not searched.
type (string): Find only items of the given type. If omitted, all items that match {names} are included.
limit (number, default 1): Stop the search after finding this many matches. Use math.huge to place no limit on the number of matches.
Return:
(string[]) Normalized paths vim.fs.normalize() of all matching items
vim.fs.joinpath({...}) vim.fs.joinpath() Concatenate directories and/or file paths into a single path with normalization (e.g., "foo/" and "bar" get joined to "foo/bar")
Parameters:
{...} (string)
Return:
(string)
vim.fs.normalize({path}, {opts}) vim.fs.normalize() Normalize a path to a standard format. A tilde (~) character at the beginning of the path is expanded to the user's home directory and any backslash (\) characters are converted to forward slashes (/). Environment variables are also expanded.
Examples:
vim.fs.normalize('C:\\\\Users\\\\jdoe')
-- 'C:/Users/jdoe'
vim.fs.normalize('~/src/neovim')
-- '/home/jdoe/src/neovim'
vim.fs.normalize('$XDG_CONFIG_HOME/nvim/init.vim')
-- '/Users/jdoe/.config/nvim/init.vim'
Parameters:
{path} (string) Path to normalize
{opts} (table|nil) Options:
expand_env: boolean Expand environment variables (default: true)
Return:
(string) Normalized path
vim.fs.parents({start}) vim.fs.parents() Iterate over all the parents of the given path.
Example:
local root_dir
for dir in vim.fs.parents(vim.api.nvim_buf_get_name(0)) do
  if vim.fn.isdirectory(dir .. "/.git") == 1 then
    root_dir = dir
    break
  end
end
if root_dir then
  print("Found git repository at", root_dir)
end
Parameters:
{start} (string) Initial path.
Return (multiple):
fun(_, dir: string): string? Iterator nil (string|nil)

Lua module: vim.secure vim.secure

vim.secure.read({path}) vim.secure.read() Attempt to read the file at {path} prompting the user if the file should be trusted. The user's choice is persisted in a trust database at $XDG_STATE_HOME/nvim/trust.
Parameters:
{path} (string) Path to a file to read.
Return:
(string|nil) The contents of the given file if it exists and is trusted, or nil otherwise.
See also:
vim.secure.trust({opts}) vim.secure.trust() Manage the trust database.
The trust database is located at $XDG_STATE_HOME/nvim/trust.
Parameters:
{opts} (table)
action (string): "allow" to add a file to the trust database and trust it, "deny" to add a file to the trust database and deny it, "remove" to remove file from the trust database
path (string|nil): Path to a file to update. Mutually exclusive with {bufnr}. Cannot be used when {action} is "allow".
bufnr (number|nil): Buffer number to update. Mutually exclusive with {path}.
Return (multiple):
(boolean) success true if operation was successful (string) msg full path if operation was successful, else error message

Lua module: vim.version vim.version

The vim.version module provides functions for comparing versions and ranges conforming to the
spec. Plugins, and plugin managers, can use this to check available tools and dependencies on the current system.
Example:
local v = vim.version.parse(vim.fn.system({'tmux', '-V'}), {strict=false})
if vim.version.gt(v, {3, 2, 0}) then
  -- ...
end
vim.version() returns the version of the current Nvim process.

VERSION RANGE SPEC version-range

A version "range spec" defines a semantic version range which can be tested against a version, using vim.version.range().
Supported range specs are shown in the following table. Note: suffixed versions (1.2.3-rc1) are not matched.
1.2.3             is 1.2.3
=1.2.3            is 1.2.3
>1.2.3            greater than 1.2.3
<1.2.3            before 1.2.3
>=1.2.3           at least 1.2.3
~1.2.3            is >=1.2.3 <1.3.0       "reasonably close to 1.2.3"
^1.2.3            is >=1.2.3 <2.0.0       "compatible with 1.2.3"
^0.2.3            is >=0.2.3 <0.3.0       (0.x.x is special)
^0.0.1            is =0.0.1               (0.0.x is special)
^1.2              is >=1.2.0 <2.0.0       (like ^1.2.0)
~1.2              is >=1.2.0 <1.3.0       (like ~1.2.0)
^1                is >=1.0.0 <2.0.0       "compatible with 1"
~1                same                    "reasonably close to 1"
1.x               same
1.*               same
1                 same
*                 any version
x                 same
1.2.3 - 2.3.4     is >=1.2.3 <=2.3.4
Partial right: missing pieces treated as x (2.3 => 2.3.x).
1.2.3 - 2.3       is >=1.2.3 <2.4.0
1.2.3 - 2         is >=1.2.3 <3.0.0
Partial left: missing pieces treated as 0 (1.2 => 1.2.0).
1.2 - 2.3.0       is 1.2.0 - 2.3.0
vim.version.cmp({v1}, {v2}) vim.version.cmp() Parses and compares two version objects (the result of vim.version.parse(), or specified literally as a {major, minor, patch} tuple, e.g. {1, 0, 3}).
Example:
if vim.version.cmp({1,0,3}, {0,2,1}) == 0 then
  -- ...
end
local v1 = vim.version.parse('1.0.3-pre')
local v2 = vim.version.parse('0.2.1')
if vim.version.cmp(v1, v2) == 0 then
  -- ...
end
Note:
Per semver, build metadata is ignored when comparing two otherwise-equivalent versions.
Parameters:
{v1} Version|number[] Version object.
{v2} Version|number[] Version to compare with v1 .
Return:
(integer) -1 if v1 < v2, 0 if v1 == v2, 1 if v1 > v2.
vim.version.eq({v1}, {v2}) vim.version.eq() Returns true if the given versions are equal. See vim.version.cmp() for usage.
Parameters:
{v1} Version|number[]
{v2} Version|number[]
Return:
(boolean)
vim.version.gt({v1}, {v2}) vim.version.gt() Returns true if v1 > v2 . See vim.version.cmp() for usage.
Parameters:
{v1} Version|number[]
{v2} Version|number[]
Return:
(boolean)
vim.version.last({versions}) vim.version.last() TODO: generalize this, move to func.lua
Parameters:
{versions} Version []
Return:
Version ?|nil
vim.version.lt({v1}, {v2}) vim.version.lt() Returns true if v1 < v2 . See vim.version.cmp() for usage.
Parameters:
{v1} Version|number[]
{v2} Version|number[]
Return:
(boolean)
vim.version.parse({version}, {opts}) vim.version.parse() Parses a semantic version string and returns a version object which can be used with other vim.version functions. For example "1.0.1-rc1+build.2" returns:
{ major = 1, minor = 0, patch = 1, prerelease = "rc1", build = "build.2" }
Parameters:
{version} (string) Version string to parse.
{opts} (table|nil) Optional keyword arguments:
strict (boolean): Default false. If true, no coercion is attempted on input not conforming to semver v2.0.0. If false, parse() attempts to coerce input such as "1.0", "0-x", "tmux 3.2a" into valid versions.
Return:
(table|nil) parsed_version Version object or nil if input is invalid.
vim.version.range({spec}) vim.version.range() Parses a semver version-range "spec" and returns a range object:
{
  from: Version
  to: Version
  has(v: string|Version)
}
:has() checks if a version is in the range (inclusive from, exclusive to).
Example:
local r = vim.version.range('1.0.0 - 2.0.0')
print(r:has('1.9.9'))       -- true
print(r:has('2.0.0'))       -- false
print(r:has(vim.version())) -- check against current Nvim version
Or use cmp(), eq(), lt(), and gt() to compare .to and .from directly:
local r = vim.version.range('1.0.0 - 2.0.0')
print(vim.version.gt({1,0,3}, r.from) and vim.version.lt({1,0,3}, r.to))
Parameters:
{spec} (string) Version range "spec"

Lua module: vim.iter vim.iter

vim.iter() is an interface for iterables: it wraps a table or function argument into an Iter object with methods (such as Iter:filter() and Iter:map()) that transform the underlying source data. These methods can be chained together to create iterator "pipelines". Each pipeline stage receives as input the output values from the prior stage. The values used in the first stage of the pipeline depend on the type passed to this function:
List tables (arrays) pass only the value of each element
Non-list tables (dictionaries) pass both the key and value of each element
Function iterators pass all of the values returned by their respective function
Tables with a metatable implementing __call() are treated as function iterators
The iterator pipeline terminates when the original table or function iterator runs out of values (for function iterators, this means that the first value returned by the function is nil).
Examples:
local it = vim.iter({ 1, 2, 3, 4, 5 })
it:map(function(v)
  return v * 3
end)
it:rev()
it:skip(2)
it:totable()
-- { 9, 6, 3 }
-- ipairs() is a function iterator which returns both the index (i) and the value (v)
vim.iter(ipairs({ 1, 2, 3, 4, 5 })):map(function(i, v)
  if i > 2 then return v end
end):totable()
-- { 3, 4, 5 }
local it = vim.iter(vim.gsplit('1,2,3,4,5', ','))
it:map(function(s) return tonumber(s) end)
for i, d in it:enumerate() do
  print(string.format("Column %d is %d", i, d))
end
-- Column 1 is 1
-- Column 2 is 2
-- Column 3 is 3
-- Column 4 is 4
-- Column 5 is 5
vim.iter({ a = 1, b = 2, c = 3, z = 26 }):any(function(k, v)
  return k == 'z'
end)
-- true
local rb = vim.ringbuf(3)
rb:push("a")
rb:push("b")
vim.iter(rb):totable()
-- { "a", "b" }
In addition to the vim.iter() function, the vim.iter module provides convenience functions like vim.iter.filter() and vim.iter.totable().
filter({f}, {src}, {...}) vim.iter.filter() Filter a table or iterator.
This is a convenience function that performs:
vim.iter(src):filter(f):totable()
Parameters:
{f} function(...):bool Filter function. Accepts the current iterator or table values as arguments and returns true if those values should be kept in the final table
{src} table|function Table or iterator function to filter
Return:
(table)
See also:
Iter:all({pred}) Iter:all() Return true if all of the items in the iterator match the given predicate.
Parameters:
{pred} function(...):bool Predicate function. Takes all values returned from the previous stage in the pipeline as arguments and returns true if the predicate matches.
Iter:any({pred}) Iter:any() Return true if any of the items in the iterator match the given predicate.
Parameters:
{pred} function(...):bool Predicate function. Takes all values returned from the previous stage in the pipeline as arguments and returns true if the predicate matches.
Iter:each({f}) Iter:each() Call a function once for each item in the pipeline.
This is used for functions which have side effects. To modify the values in the iterator, use Iter:map().
This function drains the iterator.
Parameters:
{f} function(...) Function to execute for each item in the pipeline. Takes all of the values returned by the previous stage in the pipeline as arguments.
Iter:enumerate() Iter:enumerate() Add an iterator stage that returns the current iterator count as well as the iterator value.
For list tables, prefer
vim.iter(ipairs(t))
over
vim.iter(t):enumerate()
as the former is faster.
Example:
local it = vim.iter(vim.gsplit('abc', '')):enumerate()
it:next()
-- 1   'a'
it:next()
-- 2   'b'
it:next()
-- 3   'c'
Return:
Iter
Iter:filter({f}) Iter:filter() Add a filter step to the iterator pipeline.
Example:
local bufs = vim.iter(vim.api.nvim_list_bufs()):filter(vim.api.nvim_buf_is_loaded)
Parameters:
{f} function(...):bool Takes all values returned from the previous stage in the pipeline and returns false or nil if the current iterator element should be removed.
Return:
Iter
Iter:find({f}) Iter:find() Find the first value in the iterator that satisfies the given predicate.
Advances the iterator. Returns nil and drains the iterator if no value is found.
Examples:
local it = vim.iter({ 3, 6, 9, 12 })
it:find(12)
-- 12
local it = vim.iter({ 3, 6, 9, 12 })
it:find(20)
-- nil
local it = vim.iter({ 3, 6, 9, 12 })
it:find(function(v) return v % 4 == 0 end)
-- 12
Return:
any
Iter:fold({init}, {f}) Iter:fold() Fold ("reduce") an iterator or table into a single value.
Examples:
-- Create a new table with only even values
local t = { a = 1, b = 2, c = 3, d = 4 }
local it = vim.iter(t)
it:filter(function(k, v) return v % 2 == 0 end)
it:fold({}, function(t, k, v)
  t[k] = v
  return t
end)
-- { b = 2, d = 4 }
Parameters:
{init} any Initial value of the accumulator.
{f} function(acc:any, ...):A Accumulation function.
Return:
any
Iter:last() Iter:last() Return the last item in the iterator.
Drains the iterator.
Example:
local it = vim.iter(vim.gsplit('abcdefg', ''))
it:last()
-- 'g'
local it = vim.iter({ 3, 6, 9, 12, 15 })
it:last()
-- 15
Return:
any
Iter:map({f}) Iter:map() Add a map step to the iterator pipeline.
If the map function returns nil, the value is filtered from the iterator.
Example:
local it = vim.iter({ 1, 2, 3, 4 }):map(function(v)
  if v % 2 == 0 then
    return v * 3
  end
end)
it:totable()
-- { 6, 12 }
Parameters:
{f} function(...):any Mapping function. Takes all values returned from the previous stage in the pipeline as arguments and returns one or more new values, which are used in the next pipeline stage. Nil return values are filtered from the output.
Return:
Iter
Iter:next() Iter:next() Return the next value from the iterator.
Example:
local it = vim.iter(string.gmatch('1 2 3', '%d+')):map(tonumber)
it:next()
-- 1
it:next()
-- 2
it:next()
-- 3
Return:
any
Iter:nextback() Iter:nextback() Return the next value from the end of the iterator.
Only supported for iterators on list-like tables.
Example:
local it = vim.iter({1, 2, 3, 4})
it:nextback()
-- 4
it:nextback()
-- 3
Return:
any
Iter:nth({n}) Iter:nth() Return the nth value in the iterator.
This function advances the iterator.
Example:
local it = vim.iter({ 3, 6, 9, 12 })
it:nth(2)
-- 6
it:nth(2)
-- 12
Parameters:
{n} (number) The index of the value to return.
Return:
any
Iter:nthback({n}) Iter:nthback() Return the nth value from the end of the iterator.
This function advances the iterator.
Only supported for iterators on list-like tables.
Example:
local it = vim.iter({ 3, 6, 9, 12 })
it:nthback(2)
-- 9
it:nthback(2)
-- 3
Parameters:
{n} (number) The index of the value to return.
Return:
any
Iter:peek() Iter:peek() Peek at the next value in the iterator without consuming it.
Only supported for iterators on list-like tables.
Example:
local it = vim.iter({ 3, 6, 9, 12 })
it:peek()
-- 3
it:peek()
-- 3
it:next()
-- 3
Return:
any
Iter:peekback() Iter:peekback() Return the next value from the end of the iterator without consuming it.
Only supported for iterators on list-like tables.
Example:
local it = vim.iter({1, 2, 3, 4})
it:peekback()
-- 4
it:peekback()
-- 4
it:nextback()
-- 4
Return:
any
Iter:rev() Iter:rev() Reverse an iterator.
Only supported for iterators on list-like tables.
Example:
local it = vim.iter({ 3, 6, 9, 12 }):rev()
it:totable()
-- { 12, 9, 6, 3 }
Return:
Iter
Iter:rfind({f}) Iter:rfind() Find the first value in the iterator that satisfies the given predicate, starting from the end.
Advances the iterator. Returns nil and drains the iterator if no value is found.
Only supported for iterators on list-like tables.
Examples:
local it = vim.iter({ 1, 2, 3, 2, 1 }):enumerate()
it:rfind(1)
-- 5   1
it:rfind(1)
-- 1   1
Return:
any
See also:
Iter.find
Iter:skip({n}) Iter:skip() Skip values in the iterator.
Example:
local it = vim.iter({ 3, 6, 9, 12 }):skip(2)
it:next()
-- 9
Parameters:
{n} (number) Number of values to skip.
Return:
Iter
Iter:skipback({n}) Iter:skipback() Skip values in the iterator starting from the end.
Only supported for iterators on list-like tables.
Example:
local it = vim.iter({ 1, 2, 3, 4, 5 }):skipback(2)
it:next()
-- 1
it:nextback()
-- 3
Parameters:
{n} (number) Number of values to skip.
Return:
Iter
Iter:slice({first}, {last}) Iter:slice() Slice an iterator, changing its start and end positions.
This is equivalent to :skip(first - 1):skipback(len - last + 1)
Only supported for iterators on list-like tables.
Parameters:
{first} (number)
{last} (number)
Return:
Iter
Iter:totable() Iter:totable() Collect the iterator into a table.
The resulting table depends on the initial source in the iterator pipeline. List-like tables and function iterators will be collected into a list-like table. If multiple values are returned from the final stage in the iterator pipeline, each value will be included in a table.
Examples:
vim.iter(string.gmatch('100 20 50', '%d+')):map(tonumber):totable()
-- { 100, 20, 50 }
vim.iter({ 1, 2, 3 }):map(function(v) return v, 2 * v end):totable()
-- { { 1, 2 }, { 2, 4 }, { 3, 6 } }
vim.iter({ a = 1, b = 2, c = 3 }):filter(function(k, v) return v % 2 ~= 0 end):totable()
-- { { 'a', 1 }, { 'c', 3 } }
The generated table is a list-like table with consecutive, numeric indices. To create a map-like table with arbitrary keys, use Iter:fold().
Return:
(table)
map({f}, {src}, {...}) vim.iter.map() Map and filter a table or iterator.
This is a convenience function that performs:
vim.iter(src):map(f):totable()
Parameters:
{f} function(...):?any Map function. Accepts the current iterator or table values as arguments and returns one or more new values. Nil values are removed from the final table.
{src} table|function Table or iterator function to filter
Return:
(table)
See also:
totable({f}, {...}) vim.iter.totable() Collect an iterator into a table.
This is a convenience function that performs:
vim.iter(f):totable()
Parameters:
{f} (function) Iterator function
Return:
(table)
Main
Commands index
Quick reference