Neovim

https://neovim.io/doc/
Admin
Neovim is a highly extensible and configurable text editor that aims to aggressively refactor Vim to...
Tokens:1,875,907
Snippets:15,319
Trust Score:9.8
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install Copilot language server globally via npm

Source: https://neovim.io/doc/user/lsp

Install the @github/copilot-language-server package globally using npm. This is the first step in the quickstart example for using Copilot with inline completion.

```bash
npm install --global @github/copilot-language-server

```

--------------------------------

### vim.lsp.start() example: start a language server

Source: https://neovim.io/doc/user/lsp

Creates a new LSP client and starts a language server, or reuses an existing client matching name and root_dir. Attaches the current buffer to the client. The example configures a server named 'my-server-name' with a command and root directory detection.

```lua
vim.lsp.start({

   name = 'my-server-name',

   cmd = {'name-of-language-server-executable'},

   root_dir = vim.fs.root(0, {'pyproject.toml', 'setup.py'}),

})
```

--------------------------------

### menu_get() examples

Source: https://neovim.io/doc/user/vimfn

Returns a list of dictionaries describing menus. The examples show getting a specific menu and all menus.

```vim
echo menu_get('File','')

echo menu_get('')
```

--------------------------------

### system() example: list directory of current file

Source: https://neovim.io/doc/user/vimfn

Example of using system() with a list command to get the directory of the current file.

```vim
echo system(['ls', expand('%:h')])
```

--------------------------------

### Find help for example_package

Source: https://neovim.io/doc/user/usr_05

After loading the package with :packadd, use :help to access its documentation.

```vim
:help example_package
```

--------------------------------

### getline() example: get line under cursor

Source: https://neovim.io/doc/user/vimfn

When {lnum} is a String that doesn't start with a digit, line() is called to translate the String into a Number. This example gets the line under the cursor.

```vim
getline(".")
```

--------------------------------

### jobstart() shell command example

Source: https://neovim.io/doc/user/vimfn

Shows how a String command is run in the shell: it is split and combined with shell options.

```vim
call jobstart(split(&shell) + split(&shellcmdflag) + ['{cmd}'])
```

--------------------------------

### getregion() example: xnoremap mapping

Source: https://neovim.io/doc/user/vimfn

Defines a mapping that uses getregion() to get the text of a visual selection. The example uses getpos('v') and getpos('.') for the start and end positions, and passes the current mode as the type option.

```vim
xnoremap <CR>

\ <Cmd>echom getregion(

\ getpos('v'), getpos('.'), #{ type: mode() })<CR>
```

--------------------------------

### vim.lsp.start(config, opts)

Source: https://neovim.io/doc/user/lsp

Starts an LSP server and optionally attaches it to a buffer. Returns a client_id if successful.

```APIDOC
## vim.lsp.start(config, opts)

### Description
Starts an LSP server with the given configuration and optionally attaches it to a buffer. Returns a client_id if successful.

### Method
N/A (Lua function)

### Endpoint
N/A (Lua function)

### Parameters
#### Function Parameters
- **config** (vim.lsp.ClientConfig) - Required - Configuration for the server.
- **opts** (table?) - Optional - Optional keyword arguments.
  - **attach** (boolean, default: true) - Optional - Whether to attach the client to a buffer. If set to false, reuse_client and bufnr will be ignored.
  - **bufnr** (integer) - Optional - Buffer handle to attach to if starting or re-using a client (0 for current).
  - **reuse_client** (fun(client: vim.lsp.Client, config: vim.lsp.ClientConfig, bufnr: integer): boolean) - Optional - Predicate used to decide if a client should be re-used. Used on all running clients. The default implementation re-uses a client if it has the same name and if the given workspace folders (or root_dir) are all included in the client's workspace folders.
  - **silent** (boolean, default: false) - Optional - Suppress error reporting if the LSP server fails to start.

### Return
- **client_id** (integer?) - The client ID if the server started successfully, or nil.

```

--------------------------------

### get() with dictionary default example

Source: https://neovim.io/doc/user/vimfn

Useful example for get() with a dictionary: let val = get(g:, 'var_name', 'default').

```vim
let val = get(g:, 'var_name', 'default')
```

--------------------------------

### serverstart() TCP/IP address example

Source: https://neovim.io/doc/user/vimfn

Example TCP/IP address: uses '::1:12345' as the address.

```vim
echo serverstart('::1:12345')

```

--------------------------------

### Jump to tag starting with 'get'

Source: https://neovim.io/doc/user/tagsrch

Use :tag /^get to jump to the tag that starts with 'get' and has the highest priority.

```vim
:tag /^get
```

--------------------------------

### vim.lsp.start()

Source: https://neovim.io/doc/user/lsp

Creates a new LSP client and starts a language server, or reuses an existing client matching the given name and root_dir. Attaches the current buffer to the client.

```APIDOC
## vim.lsp.start()

### Description
Creates a new LSP client and starts a language server, or reuses an already running client if one is found matching `name` and `root_dir`. Attaches the current buffer to the client.

### Method
N/A (Lua function)

### Parameters
- `config` (table) - Required - Configuration table for the client, including fields like `name`, `cmd`, and `root_dir`.
- `opts` (table?) - Optional - Additional options.

### Request Example
```lua
vim.lsp.start({
  name = 'my-server-name',
  cmd = {'name-of-language-server-executable'},
  root_dir = vim.fs.root(0, {'pyproject.toml', 'setup.py'}),
})
```

### Response
No return value documented.
```

--------------------------------

### match() with start offset examples

Source: https://neovim.io/doc/user/vimfn

Shows how the start argument affects match() results. The examples demonstrate that the result is still counted from the beginning of the string, and that a start offset can change the match position.

```vim
echo match("testing", "ing", 2)
```

```vim
echo match("testing", "ing", 4)
```

```vim
echo match("testing", "t", 2)
```

--------------------------------

### vim.str_utf_start() examples

Source: https://neovim.io/doc/user/lua

Shows how to use vim.str_utf_start() to get the byte distance from the starting byte of a codepoint. The character 'æ' is stored as bytes '\xc3\xa6' in UTF-8. Returns 0 when the index points at the first byte, and -1 when pointing at the second byte.

```lua
-- 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
```

--------------------------------

### Start Nvim with options and filenames

Source: https://neovim.io/doc/user/starting

General form for starting Nvim with any number of options and filenames.

```bash
nvim [option | filename] ..
```

--------------------------------

### Start the Nvim Tutor

Source: https://neovim.io/doc/user/nvim

Run the built-in tutorial to learn Vim in 30 minutes.

```vim
:Tutor<Enter>
```

--------------------------------

### getwinvar example

Source: https://neovim.io/doc/user/vimfn

Example of using getwinvar to get a window variable.

```vim
echo "myvar = " .. getwinvar(1, 'myvar')
```

--------------------------------

### Java class example for method navigation with [m, ]m, [M, ]M

Source: https://neovim.io/doc/user/motion

Example Java file structure used to demonstrate the [m, ]m, [M, ]M motions. The class definition and methods are surrounded by braces. Starting on 'body_two()', [m jumps to the start of method_two(), 2[m to method_one(), and 3[m to the class start.

```java
// comment

class foo {

        int method_one() {

                body_one();

        }

        int method_two() {

                body_two();

        }

}
```

--------------------------------

### jobstart() example: start a job with a full path

Source: https://neovim.io/doc/user/vimfn

Starts a job using a full or partial path. The extension is required. The command is collapsed to a string of quoted args as expected by CommandLineToArgvW unless cmd[0] is some form of 'cmd.exe'.

```vim
call jobstart(['System32\ping.exe', 'neovim.io'])
```

--------------------------------

### uv.prepare_start(prepare, callback)

Source: https://neovim.io/doc/user/luvref

Starts the prepare handle with the given callback. The callback will be called once per loop iteration before polling for I/O.

```APIDOC
## uv.prepare_start(prepare, callback)

### Description
Starts the prepare handle with the given callback. The callback will be called once per loop iteration before polling for I/O.

### Method
prepare_start

### Endpoint
uv.prepare_start(prepare, callback)

### Parameters
- `prepare` (uv_prepare_t userdata) - Required - The prepare handle.
- `callback` (callable) - Required - The callback to invoke.

### Returns
- `0` or `fail`

### Example
```lua
prepare:start(function()
  print("Before I/O polling")
end)
```
```

--------------------------------

### matchend() example: with start argument

Source: https://neovim.io/doc/user/vimfn

Shows matchend() with a start argument, which has the same meaning as for match(). The example echoes matchend("testing", "ing", 2).

```vim
echo matchend("testing", "ing", 2)
```

--------------------------------

### vim.ui.open examples

Source: https://neovim.io/doc/user/lua

Opens a path or URL with the system default handler. Shows asynchronous usage, custom command, and synchronous waiting.

```lua
-- Asynchronous.

vim.ui.open("https://neovim.io/")

vim.ui.open("~/path/to/file")

-- Use the "osurl" command to handle the path or URL.

vim.ui.open("gh#neovim/neovim!29490", { cmd = { 'osurl' } })

-- Synchronous (wait until the process exits).

local cmd, err = vim.ui.open("$VIMRUNTIME")

if cmd then

  cmd:wait()

end
```

--------------------------------

### virtcol() examples

Source: https://neovim.io/doc/user/vimfn

Examples of using virtcol() to get the virtual column of a position. The first example shows the column of the cursor, the second returns a list of first and last screen positions, the third gets the end of the line, and the fourth uses a mark.

```vim
" With text "foo^Lbar" and cursor on the "^L":


echo virtcol(".")	" returns 5

echo virtcol(".", 1)	" returns [4, 5]

echo virtcol("$")	" returns 9



" With text "	  there", with 't at 'h':


echo virtcol("'t")	" returns 6
```

--------------------------------

### exists() NOT working example with :make install

Source: https://neovim.io/doc/user/vimfn

This example does not work because there are extra characters after the command name.

```vim
echo exists(":make install")

```

--------------------------------

### serverstart() default address example

Source: https://neovim.io/doc/user/vimfn

If the address is omitted, the name is 'nvim'. This example shows the output of serverstart() with no arguments.

```vim
echo serverstart()

```

```vim
=> /tmp/nvim.bram/oknANW/nvim.15430.5

```

--------------------------------

### line() examples: get line numbers for cursor, mark, and window

Source: https://neovim.io/doc/user/vimfn

Shows how to get the line number of the cursor, a specific window, and marks. The last example uses string concatenation with the marker variable.

```vim
echo line(".")			" line number of the cursor

echo line(".", winid)		" idem, in window "winid"

echo line("'t")			" line number of mark t

echo line("'" .. marker)	" line number of mark marker
```

--------------------------------

### Portable syntax file header example

Source: https://neovim.io/doc/user/usr_44

Start a portable syntax file with a header explaining the language, maintainer, last change, and remarks. Keep history minimal.

```vim
" Vim syntax file

" Language:	C

" Maintainer:	Bram Moolenaar <Bram@vim.org>

" Last Change:	2001 Jun 18

" Remark:	Included by the C++ syntax.

```

--------------------------------

### matchstrpos() with start argument

Source: https://neovim.io/doc/user/vimfn

Returns a list with the matched string, start, and end positions. The example shows matching 'ing' starting at position 2.

```vim
echo matchstrpos("testing", "ing", 2)
```

--------------------------------

### glob with backticks example

Source: https://neovim.io/doc/user/vimfn

Example of using glob() with backticks to get file names from an external command.

```vim
let tagfiles = glob("`find . -name tags -print`")

let &tags = substitute(tagfiles, "\n", ",", "g")
```

--------------------------------

### Create init.lua from example_init.lua

Source: https://neovim.io/doc/user/nvim

Commands to create and edit your init.lua config file by copying the example_init.lua file, then restart Nvim.

```vim
:exe 'edit' stdpath('config') .. '/init.lua'

:read $VIMRUNTIME/example_init.lua

:write ++p

:restart
```

--------------------------------

### Get help for the cpoptions flag ';'

Source: https://neovim.io/doc/user/usr_02

Example of getting help for a specific cpoptions flag: :help cpo-;.

```vim
:help cpo-;
```

--------------------------------

### Example package file structure

Source: https://neovim.io/doc/user/pack

Shows the file layout of a package after unpacking, including start and opt plugin directories.

```text
pack/foo/README.txt

pack/foo/start/foobar/plugin/foo.vim

pack/foo/start/foobar/syntax/some.vim

pack/foo/opt/foodebug/plugin/debugger.vim
```

--------------------------------

### Create and start a prepare handle with uv.new_prepare() and prepare:start()

Source: https://neovim.io/doc/user/luvref

Creates a prepare handle and starts it with a callback that prints 'Before I/O polling' each loop iteration before I/O polling. The callback is invoked once per loop iteration.

```lua
local prepare = uv.new_prepare()

prepare:start(function()

  print("Before I/O polling")

end)
```

--------------------------------

### getscriptinfo() - Example usage

Source: https://neovim.io/doc/user/vimfn

Example of using getscriptinfo() with the 'name' option to get information about scripts matching a pattern.

```vim
echo getscriptinfo({'name': 'myscript'})
```

--------------------------------

### Border configuration examples for nvim_open_win()

Source: https://neovim.io/doc/user/api

Examples of border configurations for the 'border' key in the window configuration, showing double-box, ASCII, single-character, selective hiding, and per-side highlight styles.

```lua
[ "╔", "═" ,"╗", "║", "╝", "═", "╚", "║" ].
```

```lua
[ "/", "-", "\\", "|" ],
```

```lua
[ "x" ].
```

```lua
[ "", "", "", ">", "", "", "", "<" ]
```

```lua
[ ["+", "MyCorner"], ["x", "MyBorder"] ].
```

--------------------------------

### ANT script example with perl highlighting

Source: https://neovim.io/doc/user/syntax

Example ANT code block that will be highlighted as perl after installing the syntax.

```xml
<script language = 'perl'><![CDATA[

    # everything inside is highlighted as perl

]]></script>
```

--------------------------------

### Start Vim with a quickfix file: vim -q filename

Source: https://neovim.io/doc/user/quickfix

Use this command to start Vim with a file containing error messages, which will be loaded into the quickfix list.

```vim
vim -q filename
```

--------------------------------

### Translated error message example

Source: https://neovim.io/doc/user/message

Example of a translated error message. Use :help E72 to get help on this message.

```text
E72: Errore durante chiusura swap file
```

--------------------------------

### nvim_create_augroup: Create or get an autocommand group

Source: https://neovim.io/doc/user/api

Creates or gets an autocommand group. The example shows how to get an existing group id with clear set to false. Since 0.7.0.

```lua
local id = vim.api.nvim_create_augroup('my.lsp.config', {

  clear = false

})
```

--------------------------------

### Enable example_package with :packadd

Source: https://neovim.io/doc/user/usr_05

Use :packadd to load an optional package on demand. This adds the package directory to 'runtimepath' so its help files are available.

```vim
packadd example_package
```

--------------------------------

### Install a global plugin on Unix

Source: https://neovim.io/doc/user/usr_05

Creates the plugin directory and copies a plugin file into it. Use this after reading the plugin's text for special conditions.

```bash
mkdir -p ~/.local/share/nvim/site/plugin

cp /tmp/yourplugin.vim ~/.local/share/nvim/site/plugin
```

--------------------------------

### Start the Vim tutor

Source: https://neovim.io/doc/user/usr_01

Execute this command within Neovim to launch the 30-minute interactive tutorial for basic Vim functionality.

```vim
:Tutor
```

--------------------------------

### matchstrpos() basic example

Source: https://neovim.io/doc/user/vimfn

Returns a list with the matched string, start, and end positions. The example shows matching 'ing' in 'testing'.

```vim
echo matchstrpos("testing", "ing")
```

--------------------------------

### C style comment example

Source: https://neovim.io/doc/user/change

An example of a three-piece comment with start, middle, and end strings, as used in C style comments.

```c
/*

 * this is a C comment
```

--------------------------------

### systemlist() difference example

Source: https://neovim.io/doc/user/vimfn

Shows how to see the difference between 'echo hello' and 'echo -n hello' using system() and split().

```vim
echo split(system('echo hello'), '\n', 1)
```

--------------------------------

### gvim geometry example

Source: https://neovim.io/doc/user/usr_31

Example of starting gvim with a size of 80x25 characters and position offset 100 pixels right and 300 pixels down.

```shell
gvim -geometry 80x25+100+300
```

--------------------------------

### serverlist() examples

Source: https://neovim.io/doc/user/vimfn

Returns a list of server addresses, or empty if all servers were stopped. The optional argument supports 'peer' and 'info' options. The second example uses 'info' to return detailed info.

```vim
echo serverlist()

echo serverlist(#{info: v:true})

```

--------------------------------

### Build with specific bundled dependencies

Source: https://neovim.io/doc/build

Example of building with specific bundled and non-bundled dependencies, enabling LUV, TS, and LIBUV while disabling others.

```bash
make DEPS_CMAKE_FLAGS="-DUSE_BUNDLED=OFF -DUSE_BUNDLED_LUV=ON -DUSE_BUNDLED_TS=ON -DUSE_BUNDLED_LIBUV=ON"

```

--------------------------------

### Examples of strpart()

Source: https://neovim.io/doc/user/vimfn

Demonstrates strpart() with various start and length arguments. Negative start values are treated as 0, and out-of-range lengths are truncated.

```vim
echo strpart("abcdefg", 3, 2)    " returns 'de'

echo strpart("abcdefg", -2, 4)   " returns 'ab'

echo strpart("abcdefg", 5, 4)    " returns 'fg'

echo strpart("abcdefg", 3)	 " returns 'defg'

```

--------------------------------

### Create an LSP config file lsp/foo.lua

Source: https://neovim.io/doc/user/lsp

Create a file lsp/foo.lua on your runtimepath. The first command opens the file, the second writes it with ++p to create parent directories, and the third enables the config.

```vim
:exe 'edit' stdpath('config') .. '/lsp/foo.lua'
```

```lua
return {

  cmd = { 'true' },

}
```

```vim
:write ++p
```

```vim
:lua vim.lsp.enable('foo')
```

--------------------------------

### matchstrpos() with start beyond match

Source: https://neovim.io/doc/user/vimfn

Returns an empty list when no match is found. The example shows matching 'ing' starting at position 5.

```vim
echo matchstrpos("testing", "ing", 5)
```

--------------------------------

### Get help for a control character command

Source: https://neovim.io/doc/user/usr_02

Use the prefix 'CTRL-' to get help for control character commands. Example: :help CTRL-A.

```vim
:help CTRL-A
```

--------------------------------

### Help for user manual chapter 10.1

Source: https://neovim.io/doc/user/usr_02

Use :help 10.1 to go to chapter 10.1 in usr_10.txt, which talks about recording macros.

```vim
:help 10.1
```

--------------------------------

### Install Neovim on Ubuntu with apt

Source: https://neovim.io/doc/install

Install Neovim on Ubuntu using apt.

```bash
sudo apt install neovim

```

--------------------------------

### Profile a specific function with :profile start and :profile func

Source: https://neovim.io/doc/user/vimscript

Example of profiling one specific function. Starts profiling and then profiles the function MyFunc.

```vim
profile start /tmp/vimprofile

profile func MyFunc
```
Tokens:
Raw