A module to provide helper functions to manage autocmd.

A module to provide functions of Vim and Neovim native functions.

A module to provide accessors of Vim and Neovim native options.

A module to provide helper accessor functions to variables

Error thrown when Deadline times out.

A mutual exclusion lock that provides safe concurrent access to a shared value.

Allow CTRL-_ in Insert and Command-line mode. This is default off, to avoid that users that accidentally type CTRL-_ instead of SHIFT-_ get into reverse Insert mode, and don't know how to get out. See 'revins'. NOTE: This option is reset when 'compatible' is set.

Only effective when 'encoding' is "utf-8" or another Unicode encoding. Tells Vim what to do with characters with East Asian Width Class Ambiguous (such as Euro, Registered Sign, Copyright Sign, Greek letters, Cyrillic letters).

This option can be set to start editing Arabic text. Setting this option will:

• Set the 'rightleft' option, unless 'termbidi' is set.
• Set the 'arabicshape' option, unless 'termbidi' is set.
• Set the 'keymap' option to "arabic"; in Insert mode CTRL-^ toggles between typing English and Arabic key mapping.
• Set the 'delcombine' option Note that 'encoding' must be "utf-8" for working with Arabic text.

When on and 'termbidi' is off, the required visual character corrections that need to take place for displaying the Arabic language take effect. Shaping, in essence, gets enabled; the term is a broad one which encompasses: a) the changing/morphing of characters based on their location within a word (initial, medial, final and stand-alone). b) the enabling of the ability to compose characters c) the enabling of the required combining of some characters When disabled the display shows each character's true stand-alone form. Arabic is a complex language which requires other settings, for further details see arabic.txt. NOTE: This option is set when 'compatible' is set.

When on, Vim will change the current working directory whenever you open a file, switch buffers, delete a buffer or open/close a window. It will change to the directory containing the file which was opened or selected. When a buffer has no name it also has no directory, thus the current directory won't change when navigating to it. Note: When this option is on some plugins may not work.

Copy indent from current line when starting a new line (typing <CR> in Insert mode or when using the "o" or "O" command). If you do not type anything on the new line except <BS> or CTRL-D and then type <Esc>, CTRL-O or <CR>, the indent is deleted again. Moving the cursor to another line has the same effect, unless the 'I' flag is included in 'cpoptions'. When autoindent is on, formatting (with the "gq" command or when you reach 'textwidth' in Insert mode) uses the indentation of the first line. When 'smartindent' or 'cindent' is on the indent is changed in a different way. The 'autoindent' option is reset when the 'paste' option is set and restored when 'paste' is reset.

When a file has been detected to have been changed outside of Vim and it has not been changed inside of Vim, automatically read it again. When the file has been deleted this is not done, so you have the text from before it was deleted. When it appears again then it is read. timestamp If this option has a local value, use this command to switch back to using the global value:

Write the contents of the file, if it has been modified, on each :next, :rewind, :last, :first, :previous, :stop, :suspend, :tag, :!, :make, CTRL-] and CTRL-^ command; and when a :buffer, CTRL-O, CTRL-I, '{A-Z0-9}, or `{A-Z0-9} command takes one to another file. A buffer is not written if it becomes hidden, e.g. when 'bufhidden' is set to "hide" and :next is used. Note that for some commands the 'autowrite' option is not used, see 'autowriteall' for that. Some buffers will not be written, specifically when 'buftype' is "nowrite", "nofile", "terminal" or "prompt". USE WITH CARE: If you make temporary changes to a buffer that you don't want to be saved this option may cause it to be saved anyway. Renaming the buffer with ":file {name}" may help avoid this.

Like 'autowrite', but also used for commands ":edit", ":enew", ":quit", ":qall", ":exit", ":xit", ":recover" and closing the Vim window. Setting this option also implies that Vim behaves like 'autowrite' has been set.

When set to "dark", Vim will try to use colors that look good on a dark background. When set to "light", Vim will try to use colors that look good on a light background. Any other value is illegal. Vim tries to set the default value according to the terminal used. This will not always be correct. Setting this option does not change the background color, it tells Vim what the background color looks like. For changing the background color, see :hi-normal.

Influences the working of <BS>, <Del>, CTRL-W and CTRL-U in Insert mode. This is a list of items, separated by commas. Each item allows a way to backspace over something: value effect indent allow backspacing over autoindent eol allow backspacing over line breaks (join lines) start allow backspacing over the start of insert; CTRL-W and CTRL-U stop once at the start of insert. nostop like start, except CTRL-W and CTRL-U do not stop at the start of insert.

Make a backup before overwriting a file. Leave it around after the file has been successfully written. If you do not want to keep the backup file, but you do want a backup while the file is being written, reset this option and set the 'writebackup' option (this is the default). If you do not want a backup file at all reset both options (use this if your file system is almost full). See the backup-table for more explanations. When the 'backupskip' pattern matches, a backup is not made anyway. When 'patchmode' is set, the backup may be renamed to become the oldest version of a file. NOTE: This option is reset when 'compatible' is set.

When writing a file and a backup is made, this option tells how it's done. This is a comma-separated list of words.

List of directories for the backup file, separated with commas.

• The backup file will be created in the first directory in the list where this is possible. The directory must exist, Vim will not create it for you.
• Empty means that no backup file will be created ('patchmode' is impossible!). Writing may fail because of this.
• A directory "." means to put the backup file in the same directory as the edited file.
• A directory starting with "./" (or "." for MS-Windows) means to put the backup file relative to where the edited file is. The leading "." is replaced with the path name of the edited file. ("." inside a directory name has no special meaning).
• Spaces after the comma are ignored, other spaces are considered part of the directory name. To have a space at the start of a directory name, precede it with a backslash.
• To include a comma in a directory name precede it with a backslash.
• A directory name may end in an '/'.
• For Unix and Win32, if a directory ends in two path separators "//", the backup file name will be built from the complete path to the file with all path separators changed to percent '%' signs. This will ensure file name uniqueness in the backup directory. On Win32, it is also possible to end with "\". However, When a separating comma is following, you must use "//", since "\" will include the comma in the file name. Therefore it is recommended to use '//', instead of '\'.
• Environment variables are expanded :set_env.
• Careful with '' characters, type one before a space, type two to get one in the option (see option-backslash), for example:

String which is appended to a file name to make the name of the backup file. The default is quite unusual, because this avoids accidentally overwriting existing files with a backup file. You might prefer using ".bak", but make sure that you don't have files with ".bak" that you want to keep. Only normal file name characters can be used; "/\*?[|<>" are illegal.

A list of file patterns. When one of the patterns matches with the name of the file which is written, no backup file is created. Both the specified file name and the full path name of the file are used. The pattern is used like with :autocmd, see autocmd-patterns. Watch out for special characters, see option-backslash. When $TMPDIR, $TMP or $TEMP is not defined, it is not used for the default value. "/tmp/*" is only used for Unix.

Specifies for which events the bell will not be rung. It is a comma separated list of items. For each item that is present, the bell will be silenced. This is most useful to specify specific events in insert mode to be silenced. You can also make it flash by using 'visualbell'.

This option should be set before editing a binary file. You can also use the -b Vim argument. When this option is switched on a few options will be changed (also when it already was on): 'textwidth' will be set to 0 'wrapmargin' will be set to 0 'modeline' will be off 'expandtab' will be off Also, 'fileformat' and 'fileformats' options will not be used, the file is read and written like 'fileformat' was "unix" (a single <NL> separates lines). The 'fileencoding' and 'fileencodings' options will not be used, the file is read without conversion. NOTE: When you start editing a(nother) file while the 'bin' option is on, settings from autocommands may change the settings again (e.g., 'textwidth'), causing trouble when editing. You might want to set 'bin' again when the file has been loaded. The previous values of these options are remembered and restored when 'bin' is switched from on to off. Each buffer has its own set of saved option values. To edit a file with 'binary' set you can use the ++bin argument. This avoids you have to do ":set bin", which would have effect for all files you edit. When writing a file the <EOL> for the last line is only written if there was one in the original file (normally Vim appends an <EOL> to the last line if there is none; this would make the file longer). See the 'endofline' option.

When writing a file and the following conditions are met, a BOM (Byte Order Mark) is prepended to the file:

• this option is on
• the 'binary' option is off
• 'fileencoding' is "utf-8", "ucs-2", "ucs-4" or one of the little/big endian variants. Some applications use the BOM to recognize the encoding of the file. Often used for UCS-2 files on MS-Windows. For other applications it causes trouble, for example: "cat file1 file2" makes the BOM of file2 appear halfway through the resulting file. Gcc doesn't accept a BOM. When Vim reads a file and 'fileencodings' starts with "ucs-bom", a check for the presence of the BOM is done and 'bomb' set accordingly. Unless 'binary' is set, it is removed from the first line, so that you don't see it when editing. When you don't change the options, the BOM will be restored when writing the file.

This option lets you choose which characters might cause a line break if 'linebreak' is on. Only works for ASCII and also for 8-bit characters when 'encoding' is an 8-bit encoding.

Every wrapped line will continue visually indented (same amount of space as the beginning of that line), thus preserving horizontal blocks of text. NOTE: This option is reset when 'compatible' is set.

Settings for 'breakindent'. It can consist of the following optional items and must be separated by a comma: min:{n} Minimum text width that will be kept after applying 'breakindent', even if the resulting text should normally be narrower. This prevents text indented almost to the right window border occupying lot of vertical space when broken. (default: 20) shift:{n} After applying 'breakindent', the wrapped line's beginning will be shifted by the given number of characters. It permits dynamic French paragraph indentation (negative) or emphasizing the line continuation (positive). (default: 0) sbr Display the 'showbreak' value before applying the additional indent. (default: off) list:{n} Adds an additional indent for lines that match a numbered or bulleted list (using the 'formatlistpat' setting). list:-1 Uses the length of a match with 'formatlistpat' for indentation. (default: 0) column:{n} Indent at column {n}. Will overrule the other sub-options. Note: an additional indent may be added for the 'showbreak' setting. (default: off)

Which directory to use for the file browser: last Use same directory as with last file browser, where a file was opened or saved. buffer Use the directory of the related buffer. current Use the current directory. {path} Use the specified directory

This option specifies what happens when a buffer is no longer displayed in a window: <empty> follow the global 'hidden' option hide hide the buffer (don't unload it), even if 'hidden' is not set unload unload the buffer, even if 'hidden' is set; the :hide command will also unload the buffer delete delete the buffer from the buffer list, even if 'hidden' is set; the :hide command will also delete the buffer, making it behave like :bdelete wipe wipe the buffer from the buffer list, even if 'hidden' is set; the :hide command will also wipe out the buffer, making it behave like :bwipeout

When this option is set, the buffer shows up in the buffer list. If it is reset it is not used for ":bnext", "ls", the Buffers menu, etc. This option is reset by Vim for buffers that are only used to remember a file name or marks. Vim sets it when starting to edit a buffer. But not when moving to a buffer with ":buffer".

The value of this option specifies the type of a buffer: <empty> normal buffer nofile buffer which is not related to a file and will not be written nowrite buffer which will not be written acwrite buffer which will always be written with BufWriteCmd autocommands. quickfix quickfix buffer, contains list of errors :cwindow or list of locations :lwindow help help buffer (you are not supposed to set this manually) terminal buffer for a terminal (you are not supposed to set this manually) prompt buffer where only the last line can be edited, meant to be used by a plugin, see prompt-buffer only when compiled with the +channel feature popup buffer used in a popup window, see popup. only when compiled with the +textprop feature

Specifies details about changing the case of letters. It may contain these words, separated by a comma: internal Use internal case mapping functions, the current locale does not change the case mapping. This only matters when 'encoding' is a Unicode encoding, "latin1" or "iso-8859-15". When "internal" is omitted, the towupper() and towlower() system library functions are used when available. keepascii For the ASCII characters (0x00 to 0x7f) use the US case mapping, the current locale is not effective. This probably only matters for Turkish.

When on, :cd, :tcd and :lcd without an argument changes the current working directory to the $HOME directory like in Unix. When off, those commands just print the current directory name. On Unix this option has no effect. This option cannot be set from a modeline or in the sandbox, for security reasons. NOTE: This option is reset when 'compatible' is set.

This is a list of directories which will be searched when using the :cd, :tcd and :lcd commands, provided that the directory being searched for has a relative path, not an absolute part starting with "/", "./" or "../", the 'cdpath' option is not used then. The 'cdpath' option's value has the same form and semantics as 'path'. Also see file-searching. The default value is taken from $CDPATH, with a "," prepended to look in the current directory first. If the default value taken from $CDPATH is not what you want, include a modified version of the following command in your vimrc file to override it:

The key used in Command-line Mode to open the command-line window. The default is CTRL-F when 'compatible' is off. Only non-printable keys are allowed. The key can be specified as a single character, but it is difficult to type. The preferred way is to use the <> notation. Examples:

An expression that is used for character encoding conversion. It is evaluated when a file that is to be read or has been written has a different encoding from what is desired. 'charconvert' is not used when the internal iconv() function is supported and is able to do the conversion. Using iconv() is preferred, because it is much faster. 'charconvert' is not used when reading stdin --, because there is no file to convert from. You will have to save the text in a file first. The expression must return zero, false or an empty string for success, non-zero or true for failure. The possible encoding names encountered are in 'encoding'. Additionally, names given in 'fileencodings' and 'fileencoding' are used. Conversion between "latin1", "unicode", "ucs-2", "ucs-4" and "utf-8" is done internally by Vim, 'charconvert' is not used for this. 'charconvert' is also used to convert the viminfo file, if the 'c' flag is present in 'viminfo'. Also used for Unicode conversion. Example:

Enables automatic C program indenting. See 'cinkeys' to set the keys that trigger reindenting in insert mode and 'cinoptions' to set your preferred indent style. If 'indentexpr' is not empty, it overrules 'cindent'. If 'lisp' is not on and both 'indentexpr' and 'equalprg' are empty, the "=" operator indents using this algorithm rather than calling an external program. See C-indenting. When you don't like the way 'cindent' works, try the 'smartindent' option or 'indentexpr'. This option is not used when 'paste' is set. NOTE: This option is reset when 'compatible' is set.

A list of keys that, when typed in Insert mode, cause reindenting of the current line. Only used if 'cindent' is on and 'indentexpr' is empty. For the format of this option see cinkeys-format. See C-indenting.

The 'cinoptions' affect the way 'cindent' reindents lines in a C program. See cinoptions-values for the values of this option, and C-indenting for info on C indenting in general.

Keywords that are interpreted as a C++ scope declaration by cino-g. Useful e.g. for working with the Qt framework that defines additional scope declarations "signals", "public slots" and "private slots":

These keywords start an extra indent in the next line when 'smartindent' or 'cindent' is set. For 'cindent' this is only done at an appropriate place (inside {}). Note that 'ignorecase' isn't used for 'cinwords'. If case doesn't matter, include the keyword both the uppercase and lowercase: "if,If,IF".

This option is a list of comma-separated names. Note: if one of the items is "exclude:", then you can't add an item after that. Therefore do not append an item with += but use ^= to prepend, e.g.:

Number of screen lines to use for the command-line. A larger value helps avoiding hit-enter prompts. The value of this option is stored with the tab page, so that each tab page can have a different value.

Number of screen lines to use for the command-line window. cmdwin

'colorcolumn' is a comma-separated list of screen columns that are highlighted with ColorColumn hl-ColorColumn. Useful to align text. Will make screen redrawing slower. The screen column can be an absolute number, or a number preceded with '+' or '-', which is added to or subtracted from 'textwidth'.

Number of columns of the screen. Normally this is set by the terminal initialization and does not have to be set by hand. Also see posix-screen-size. When Vim is running in the GUI or in a resizable window, setting this option will cause the window size to be changed. When you only want to use the size for the GUI, put the command in your gvimrc file. When you set this option and Vim is unable to change the physical number of columns of the display, the display may be messed up. For the GUI it is always possible and Vim limits the number of columns to what fits on the screen. You can use this command to get the widest window possible:

A comma-separated list of strings that can start a comment line. See format-comments. See option-backslash about using backslashes to insert a space.

A template for a comment. The "%s" in the value is replaced with the comment text. Currently only used to add markers for folding, see fold-marker.

This option specifies how keyword completion ins-completion works when CTRL-P or CTRL-N are used. It is also used for whole-line completion i_CTRL-X_CTRL-L. It indicates the type of completion and the places to scan. It is a comma-separated list of flags: . scan the current buffer ('wrapscan' is ignored) w scan buffers from other windows b scan other loaded buffers that are in the buffer list u scan the unloaded buffers that are in the buffer list U scan the buffers that are not in the buffer list k scan the files given with the 'dictionary' option kspell use the currently active spell checking spell k**{dict}** scan the file {dict}. Several "k" flags can be given, patterns are valid too. For example:

This option specifies a function to be used for Insert mode completion with CTRL-X CTRL-U. i_CTRL-X_CTRL-U See complete-functions for an explanation of how the function is invoked and what it should return. The value can be the name of a function, a lambda or a Funcref. See option-value-function for more information. This option cannot be set from a modeline or in the sandbox, for security reasons.

A comma-separated list of options for Insert mode completion ins-completion. The supported values are:

When this option is set it overrules 'shellslash' for completion:

• When this option is set to "slash", a forward slash is used for path completion in insert mode. This is useful when editing HTML tag, or Makefile with 'noshellslash' on MS-Windows.
• When this option is set to "backslash", backslash is used. This is useful when editing a batch file with 'shellslash' set on MS-Windows.
• When this option is empty, same character is used as for 'shellslash'. For Insert mode completion the buffer-local value is used. For command line completion the global value is used.

Sets the modes in which text in the cursor line can also be concealed. When the current mode is listed then concealing happens just like in other lines. n Normal mode v Visual mode i Insert mode c Command line editing, for 'incsearch'

Determine how text with the "conceal" syntax attribute :syn-conceal is shown:

When 'confirm' is on, certain operations that would normally fail because of unsaved changes to a buffer, e.g. ":q" and ":e", instead raise a dialog asking if you wish to save the current file(s). You can still use a ! to unconditionally abandon a buffer. If 'confirm' is off you can still activate confirmation for one command only (this is most useful in mappings) with the :confirm command. Also see the confirm() function and the 'v' flag in 'guioptions'.

Copy the structure of the existing lines indent when autoindenting a new line. Normally the new indent is reconstructed by a series of tabs followed by spaces as required (unless 'expandtab' is enabled, in which case only spaces are used). Enabling this option makes the new line copy whatever characters were used for indenting on the existing line. 'expandtab' has no effect on these characters, a Tab remains a Tab. If the new indent is greater than on the existing line, the remaining space is filled in the normal manner. NOTE: This option is reset when 'compatible' is set. Also see 'preserveindent'.

A sequence of single character flags. When a character is present this indicates Vi-compatible behavior. This is used for things where not being Vi-compatible is mostly or sometimes preferred. 'cpoptions' stands for "compatible-options". Commas can be added for readability. To avoid problems with flags that are added in the future, use the "+=" and "-=" feature of ":set" add-option-flags.

When this option is set, as the cursor in the current window moves other cursorbound windows (windows that also have this option set) move their cursors to the corresponding line and column. This option is useful for viewing the differences between two versions of a file (see 'diff'); in diff mode, inserted and deleted lines (though not characters within a line) are taken into account.

Highlight the screen column of the cursor with CursorColumn hl-CursorColumn. Useful to align text. Will make screen redrawing slower. If you only want the highlighting in the current window you can use these autocommands:

Highlight the text line of the cursor with CursorLine hl-CursorLine. Useful to easily spot the cursor. Will make screen redrawing slower. When Visual mode is active the highlighting isn't used to make it easier to see the selected text.

Comma-separated list of settings for how 'cursorline' is displayed. Valid values: "line" Highlight the text line of the cursor with CursorLine hl-CursorLine. "screenline" Highlight only the screen line of the cursor with CursorLine hl-CursorLine. "number" Highlight the line number of the cursor with CursorLineNr hl-CursorLineNr.

These values can be used: msg Error messages that would otherwise be omitted will be given anyway. throw Error messages that would otherwise be omitted will be given anyway and also throw an exception and set v:errmsg. beep A message will be given when otherwise only a beep would be produced. The values can be combined, separated by a comma. "msg" and "throw" are useful for debugging 'foldexpr', 'formatexpr' or 'indentexpr'.

Pattern to be used to find a macro definition. It is a search pattern, just like for the "/" command. This option is used for the commands like "[i" and "[d" include-search. The 'isident' option is used to recognize the defined name after the match: {match with 'define'}{non-ID chars}{defined name}{non-ID char} See option-backslash about inserting backslashes to include a space or backslash. The default value is for C programs. For C++ this value would be useful, to include const type declarations:

If editing Unicode and this option is set, backspace and Normal mode "x" delete each combining character on its own. When it is off (the default) the character along with its combining characters are deleted. Note: When 'delcombine' is set "xx" may work differently from "2x"!

List of file names, separated by commas, that are used to lookup words for keyword completion commands i_CTRL-X_CTRL-K. Each file should contain a list of words. This can be one word per line, or several words per line, separated by non-keyword characters (white space is preferred). Maximum line length is 510 bytes.

Join the current window in the group of windows that shows differences between files. See vimdiff.

Expression which is evaluated to obtain a diff file (either ed-style or unified-style) from two versions of a file. See diff-diffexpr. This option cannot be set from a modeline or in the sandbox, for security reasons.

Option settings for diff mode. It can consist of the following items. All are optional. Items must be separated by a comma.

Enable the entering of digraphs in Insert mode with {char1} <BS> {char2}. See digraphs. NOTE: This option is reset when 'compatible' is set.

List of directory names for the swap file, separated with commas. Recommended value: ".,~/vimswap//" - this will put the swap file next to the edited file if possible, and in your personal swap directory otherwise. Make sure "~/vimswap//" is only readable for you.

Change the way text is displayed. This is a comma-separated list of flags: lastline When included, as much as possible of the last line in a window will be displayed. "@@@" is put in the last columns of the last screen line to indicate the rest of the line is not displayed. truncate Like "lastline", but "@@@" is displayed in the first column of the last screen line. Overrules "lastline". uhex Show unprintable characters hexadecimal as <xx> instead of using ^C and ~C.

Tells when the 'equalalways' option applies: ver vertically, width of windows is not affected hor horizontally, height of windows is not affected both width and height of windows is affected

When on all Unicode emoji characters are considered to be full width. This excludes "text emoji" characters, which are normally displayed as single width. Unfortunately there is no good specification for this and it has been determined on trial-and-error basis. Use the setcellwidths() function to change the behavior.

Sets the character encoding used inside Vim. It applies to text in the buffers, registers, Strings in expressions, text stored in the viminfo file, etc. It sets the kind of characters which Vim can work with. See encoding-names for the possible values.

Indicates that a CTRL-Z character was found at the end of the file when reading it. Normally only happens when 'fileformat' is "dos". When writing a file and this option is off and the 'binary' option is on, or 'fixeol' option is off, no CTRL-Z will be written at the end of the file. See eol-and-eof for example settings.

When writing a file and this option is off and the 'binary' option is on, or 'fixeol' option is off, no <EOL> will be written for the last line in the file. This option is automatically set or reset when starting to edit a new file, depending on whether file has an <EOL> for the last line in the file. Normally you don't have to set or reset this option. When 'binary' is off and 'fixeol' is on the value is not used when writing the file. When 'binary' is on or 'fixeol' is off it is used to remember the presence of a <EOL> for the last line in the file, so that when you write the file the situation from the original file can be kept. But you can change it if you want to. See eol-and-eof for example settings.

When on, all the windows are automatically made the same size after splitting or closing a window. This also happens the moment the option is switched on. When off, splitting a window will reduce the size of the current window and leave the other windows the same. When closing a window the extra lines are given to the window next to it (depending on 'splitbelow' and 'splitright'). When mixing vertically and horizontally split windows, a minimal size is computed and some windows may be larger if there is room. The 'eadirection' option tells in which direction the size is affected. Changing the height and width of a window can be avoided by setting 'winfixheight' and 'winfixwidth', respectively. If a window size is specified when creating a new window sizes are currently not equalized (it's complicated, but may be implemented in the future).

External program to use for "=" command. When this option is empty the internal formatting functions are used; either 'lisp', 'cindent' or 'indentexpr'. When Vim was compiled without internal formatting, the "indent" program is used. Environment variables are expanded :set_env. See option-backslash about including spaces and backslashes. This option cannot be set from a modeline or in the sandbox, for security reasons.

Ring the bell (beep or screen flash) for error messages. This only makes a difference for error messages, the bell will be used always for a lot of errors without a message (e.g., hitting <Esc> in Normal mode). See 'visualbell' on how to make the bell behave like a beep, screen flash or do nothing. See 'belloff' to finetune when to ring the bell.

Name of the errorfile for the QuickFix mode (see :cf). When the "-q" command-line argument is used, 'errorfile' is set to the following argument. See -q. NOT used for the ":make" command. See 'makeef' for that. Environment variables are expanded :set_env. See option-backslash about including spaces and backslashes. This option cannot be set from a modeline or in the sandbox, for security reasons.

Scanf-like description of the format for the lines in the error file (see errorformat).

A list of autocommand event names, which are to be ignored. When set to "all" or when "all" is one of the items, all autocommand events are ignored, autocommands will not be executed. Otherwise this is a comma-separated list of event names. Example:

In Insert mode: Use the appropriate number of spaces to insert a <Tab>. Spaces are used in indents with the '>' and '<' commands and when 'autoindent' is on. To insert a real tab when 'expandtab' is on, use CTRL-V. See also :retab and ins-expandtab. This option is reset when the 'paste' option is set and restored when the 'paste' option is reset. NOTE: This option is reset when 'compatible' is set.

Enables the reading of .vimrc, .exrc and .gvimrc in the current directory.

Sets the character encoding for the file of this buffer.

This is a list of character encodings considered when starting to edit an existing file. When a file is read, Vim tries to use the first mentioned character encoding. If an error is detected, the next one in the list is tried. When an encoding is found that works, 'fileencoding' is set to it. If all fail, 'fileencoding' is set to an empty string, which means the value of 'encoding' is used. WARNING: Conversion can cause loss of information! When 'encoding' is "utf-8" (or one of the other Unicode variants) conversion is most likely done in a way that the reverse conversion results in the same text. When 'encoding' is not "utf-8" some non-ASCII characters may be lost! You can use the ++bad argument to specify what is done with characters that can't be converted. For an empty file or a file with only ASCII characters most encodings will work and the first entry of 'fileencodings' will be used (except "ucs-bom", which requires the BOM to be present). If you prefer another encoding use an BufReadPost autocommand event to test if your preferred encoding is to be used. Example:

This gives the <EOL> of the current buffer, which is used for reading/writing the buffer from/to a file: dos <CR><NL> unix <NL> mac <CR> When "dos" is used, CTRL-Z at the end of a file is ignored. See file-formats and file-read. For the character encoding of the file see 'fileencoding'. When 'binary' is set, the value of 'fileformat' is ignored, file I/O works like it was set to "unix". This option is set automatically when starting to edit a file and 'fileformats' is not empty and 'binary' is off. When this option is set, after starting to edit a file, the 'modified' option is set, because the file would be different when written. This option can not be changed when 'modifiable' is off. For backwards compatibility: When this option is set to "dos", 'textmode' is set, otherwise 'textmode' is reset.

This gives the end-of-line (<EOL>) formats that will be tried when starting to edit a new buffer and when reading a file into an existing buffer:

• When empty, the format defined with 'fileformat' will be used always. It is not set automatically.
• When set to one name, that format will be used whenever a new buffer is opened. 'fileformat' is set accordingly for that buffer. The 'fileformats' name will be used when a file is read into an existing buffer, no matter what 'fileformat' for that buffer is set to.
• When more than one name is present, separated by commas, automatic <EOL> detection will be done when reading a file. When starting to edit a file, a check is done for the <EOL>:
  1. If all lines end in <CR><NL>, and 'fileformats' includes "dos", 'fileformat' is set to "dos".
  2. If a <NL> is found and 'fileformats' includes "unix", 'fileformat' is set to "unix". Note that when a <NL> is found without a preceding <CR>, "unix" is preferred over "dos".
  3. If 'fileformat' has not yet been set, and if a <CR> is found, and if 'fileformats' includes "mac", 'fileformat' is set to "mac". This means that "mac" is only chosen when: "unix" is not present or no <NL> is found in the file, and "dos" is not present or no <CR><NL> is found in the file. Except: if "unix" was chosen, but there is a <CR> before the first <NL>, and there appear to be more <CR>s than <NL>s in the first few lines, "mac" is used.
  4. If 'fileformat' is still not set, the first name from 'fileformats' is used. When reading a file into an existing buffer, the same is done, but this happens like 'fileformat' has been set appropriately for that file only, the option is not changed. When 'binary' is set, the value of 'fileformats' is not used.

When set case is ignored when using file names and directories. See 'wildignorecase' for only ignoring case when doing completion.

When this option is set, the FileType autocommand event is triggered. All autocommands that match with the value of this option will be executed. Thus the value of 'filetype' is used in place of the file name. Otherwise this option does not always reflect the current file type. This option is normally set when the file type is detected. To enable this use the ":filetype on" command. :filetype Setting this option to a different value is most useful in a modeline, for a file for which the file type is not automatically recognized. Example, for in an IDL file: /* vim: set filetype=idl : * / FileType filetypes When a dot appears in the value then this separates two filetype names. Example: /* vim: set filetype=c.doxygen : * / This will use the "c" filetype first, then the "doxygen" filetype. This works both for filetype plugins and for syntax files. More than one dot may appear. This option is not copied to another buffer, independent of the 's' or 'S' flag in 'cpoptions'. Only normal file name characters can be used, "/\*?[|<>" are illegal.

Characters to fill the statuslines, vertical separators and special lines in the window. It is a comma-separated list of items. Each item has a name, a colon and the value of that item:

When writing a file and this option is on, <EOL> at the end of file will be restored if missing. Turn this option off if you want to preserve the situation from the original file. When the 'binary' option is set the value of this option doesn't matter. See the 'endofline' option. See eol-and-eof for example settings.

When set to "all", a fold is closed when the cursor isn't in it and its level is higher than 'foldlevel'. Useful if you want folds to automatically close when moving out of them.

When non-zero, a column with the specified width is shown at the side of the window which indicates open and closed folds. The maximum value is 12. See folding.

When off, all folds are open. This option can be used to quickly switch between showing all text unfolded and viewing the text with folds (including manually opened or closed folds). It can be toggled with the zi command. The 'foldcolumn' will remain blank when 'foldenable' is off. This option is set by commands that create a new fold or close a fold. See folding.

The expression used for when 'foldmethod' is "expr". It is evaluated for each line to obtain its fold level. The context is set to the script where 'foldexpr' was set, script-local items can be accessed. See fold-expr for the usage.

Used only when 'foldmethod' is "indent". Lines starting with characters in 'foldignore' will get their fold level from surrounding lines. White space is skipped before checking for this character. The default "#" works well for C programs. See fold-indent.

Sets the fold level: Folds with a higher level will be closed. Setting this option to zero will close all folds. Higher numbers will close fewer folds. This option is set by commands like zm, zM and zR. See fold-foldlevel.

Sets 'foldlevel' when starting to edit another buffer in a window. Useful to always start editing with all folds closed (value zero), some folds closed (one) or no folds closed (99). This is done before reading any modeline, thus a setting in a modeline overrules this option. Starting to edit a file for diff-mode also ignores this option and closes all folds. It is also done before BufReadPre autocommands, to allow an autocmd to overrule the 'foldlevel' value for specific files. When the value is negative, it is not used.

The start and end marker used when 'foldmethod' is "marker". There must be one comma, which separates the start and end marker. The marker is a literal string (a regular expression would be too slow). See fold-marker.

The kind of folding used for the current window. Possible values: fold-manual manual Folds are created manually. fold-indent indent Lines with equal indent form a fold. fold-expr expr 'foldexpr' gives the fold level of a line. fold-marker marker Markers are used to specify folds. fold-syntax syntax Syntax highlighting items specify folds. fold-diff diff Fold text that is not changed.

Sets the number of screen lines above which a fold can be displayed closed. Also for manually closed folds. With the default value of one a fold can only be closed if it takes up two or more screen lines. Set to zero to be able to close folds of just one screen line. Note that this only has an effect on what is displayed. After using "zc" to close a fold, which is displayed open because it's smaller than 'foldminlines', a following "zc" may close a containing fold.

Sets the maximum nesting of folds for the "indent" and "syntax" methods. This avoids that too many folds will be created. Using more than 20 doesn't work, because the internal limit is 20.

Specifies for which type of commands folds will be opened, if the command moves the cursor into a closed fold. It is a comma-separated list of items. NOTE: When the command is part of a mapping this option is not used. Add the zv command to the mapping to get the same effect. (rationale: the mapping may want to control opening folds itself)

An expression which is used to specify the text displayed for a closed fold. The context is set to the script where 'foldexpr' was set, script-local items can be accessed. See fold-foldtext for the usage.

Expression which is evaluated to format a range of lines for the gq operator or automatic formatting (see 'formatoptions'). When this option is empty 'formatprg' is used.

A pattern that is used to recognize a list header. This is used for the "n" flag in 'formatoptions'. The pattern must match exactly the text that will be the indent for the line below it. You can use /\ze to mark the end of the match while still checking more characters. There must be a character following the pattern, when it matches the whole line it is handled like there is no match. The default recognizes a number, followed by an optional punctuation character and white space.

This is a sequence of letters which describes how automatic formatting is to be done. See fo-table for possible values and gq for how to format text. When the 'paste' option is on, no formatting is done (like 'formatoptions' is empty). Commas can be inserted for readability. To avoid problems with flags that are added in the future, use the "+=" and "-=" feature of ":set" add-option-flags. NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

The name of an external program that will be used to format the lines selected with the gq operator. The program must take the input on stdin and produce the output on stdout. The Unix program "fmt" is such a program. If the 'formatexpr' option is not empty it will be used instead. Otherwise, if 'formatprg' option is an empty string, the internal format function will be used C-indenting. Environment variables are expanded :set_env. See option-backslash about including spaces and backslashes. This option cannot be set from a modeline or in the sandbox, for security reasons.

When on, the library function fsync() will be called after writing a file. This will flush a file to disk, ensuring that it is safely written even on filesystems which do metadata-only journaling. This will force the harddrive to spin up on Linux systems running in laptop mode, so it may be undesirable in some situations. Be warned that turning this off increases the chances of data loss after a crash. On systems without an fsync() implementation, this variable is always off. Also see 'swapsync' for controlling fsync() on swap files. 'fsync' also applies to writefile() (unless a flag is used to overrule it) and when writing undo files (see undo-persistence). This option cannot be set from a modeline or in the sandbox, for security reasons.

When on, the ":substitute" flag 'g' is default on. This means that all matches in a line are substituted instead of one. When a 'g' flag is given to a ":substitute" command, this will toggle the substitution of all or one match. See complex-change.

Format to recognize for the ":grep" command output. This is a scanf-like string that uses the same format as the 'errorformat' option: see errorformat.

Program to use for the :grep command. This option may contain '%' and '#' characters, which are expanded like when used in a command- line. The placeholder "$*" is allowed to specify where the arguments will be included. Environment variables are expanded :set_env. See option-backslash about including spaces and backslashes. When your "grep" accepts the "-H" argument, use this to make ":grep" also work well with a single file:

This option tells Vim what the cursor should look like in different modes. It fully works in the GUI. In a Win32 console, only the height of the cursor can be changed. This can be done by specifying a block cursor, or a percentage for a vertical or horizontal cursor. For a console the 't_SI', 't_SR', and 't_EI' escape sequences are used.

This is a list of fonts which will be used for the GUI version of Vim. In its simplest form the value is just one font name. See gui-font for the details.

When not empty, specifies a comma-separated list of fonts to be used for double-width characters. The first font that can be loaded is used. See gui-fontwide.

This option only has an effect in the GUI version of Vim. It is a sequence of letters which describes what components and options of the GUI should be used. To avoid problems with flags that are added in the future, use the "+=" and "-=" feature of ":set" add-option-flags.

When non-empty describes the text to use in a label of the GUI tab pages line. When empty and when the result is empty Vim will use a default label. See setting-guitablabel for more info.

When non-empty describes the text to use in a tooltip for the GUI tab pages line. When empty Vim will use a default tooltip. This option is otherwise just like 'guitablabel' above. You can include a line break. Simplest method is to use :let:

Name of the main help file. All distributed help files should be placed together in one directory. Additionally, all "doc" directories in 'runtimepath' will be used. Environment variables are expanded :set_env. For example: "$VIMRUNTIME/doc/help.txt". If $VIMRUNTIME is not set, $VIM is also tried. Also see $VIMRUNTIME and option-backslash about including spaces and backslashes. This option cannot be set from a modeline or in the sandbox, for security reasons.

Minimal initial height of the help window when it is opened with the ":help" command. The initial height of the help window is half of the current window, or (when the 'ea' option is on) the same as other windows. When the height is less than 'helpheight', the height is set to 'helpheight'. Set to zero to disable.

Comma-separated list of languages. Vim will use the first language for which the desired help can be found. The English help will always be used as a last resort. You can add "en" to prefer English over another language, but that will only find tags that exist in that language and not in the English help. Example:

When off a buffer is unloaded when it is abandoned. When on a buffer becomes hidden when it is abandoned. If the buffer is still displayed in another window, it does not become hidden, of course.

A history of ":" commands, and a history of previous search patterns is remembered. This option decides how many entries may be stored in each of these histories (see cmdline-editing). The maximum value is 10000. NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

When there is a previous search pattern, highlight all its matches. The type of highlighting used can be set with the 'l' occasion in the 'highlight' option. This uses the "Search" highlight group by default. Note that only the matching text is highlighted, any offsets are not applied. If the "CurSearch" highlight group is set then the current match is highlighted with that. See also: 'incsearch' and :match. When you get bored looking at the highlighted matches, you can turn it off with :nohlsearch. This does not change the option value, as soon as you use a search command, the highlighting comes back. 'redrawtime' specifies the maximum time spent on finding matches. When the search pattern can match an end-of-line, Vim will try to highlight all of the matched text. However, this depends on where the search starts. This will be the first line in the window or the first line below a closed fold. A match in a previous line which is not drawn may not continue in a newly drawn line. You can specify whether the highlight status is restored on startup with the 'h' flag in 'viminfo' viminfo-h. NOTE: This option is reset when 'compatible' is set.

When on, the icon text of the window will be set to the value of 'iconstring' (if it is not empty), or to the name of the file currently being edited. Only the last part of the name is used. Overridden by the 'iconstring' option. Only works if the terminal supports setting window icons (currently only X11 GUI and terminals with a non-empty 't_IS' option - these are Unix xterm and iris-ansi by default, where 't_IS' is taken from the builtin termcap). When Vim was compiled with HAVE_X11 defined, the original icon will be restored if possible X11. See X11-icon for changing the icon on X11. For MS-Windows the icon can be changed, see windows-icon.

When this option is not empty, it will be used for the icon text of the window. This happens only when the 'icon' option is on. Only works if the terminal supports setting window icon text (currently only X11 GUI and terminals with a non-empty 't_IS' option). Does not work for MS-Windows. When Vim was compiled with HAVE_X11 defined, the original icon will be restored if possible X11. When this option contains printf-style '%' items, they will be expanded according to the rules used for 'statusline'. See 'titlestring' for example settings. This option cannot be set in a modeline when 'modelineexpr' is off. not available when compiled without the +statusline feature

Ignore case in search patterns, cmdline-completion, when searching in the tags file, and non-|Vim9| expr-==. Also see 'smartcase' and 'tagcase'. Can be overruled by using "\c" or "\C" in the pattern, see /ignorecase.

When set the Input Method is always on when starting to edit a command line, unless entering a search pattern (see 'imsearch' for that). Setting this option is useful when your input method allows entering English characters directly, e.g., when it's used to type accented characters with dead keys.

When set the Input Method is never used. This is useful to disable the IM when it doesn't work properly. Currently this option is on by default for SGI/IRIX machines. This may change in later releases.

Specifies whether :lmap or an Input Method (IM) is to be used in Insert mode. Valid values: 0 :lmap is off and IM is off 1 :lmap is ON and IM is off 2 :lmap is off and IM is ON To always reset the option to zero when leaving Insert mode with <Esc> this can be used:

Specifies whether :lmap or an Input Method (IM) is to be used when entering a search pattern. Valid values: -1 the value of 'iminsert' is used, makes it look like 'iminsert' is also used when typing a search pattern 0 :lmap is off and IM is off 1 :lmap is ON and IM is off 2 :lmap is off and IM is ON Note that this option changes when using CTRL-^ in Command-line mode c_CTRL-^. The value is set to 1 when it is not -1 and setting the 'keymap' option to a valid keymap name. The value 0 may not work correctly with Motif with some XIM methods. Use 'imdisable' to disable XIM then.

Pattern to be used to find an include command. It is a search pattern, just like for the "/" command (See pattern). The default value is for C programs. This option is used for the commands "[i", "]I", "[d", etc. Normally the 'isfname' option is used to recognize the file name that comes after the matched pattern. But if "\zs" appears in the pattern then the text matched from "\zs" to the end, or until "\ze" if it appears, is used as the file name. Use this to include characters that are not in 'isfname', such as a space. You can then use 'includeexpr' to process the matched text. See option-backslash about including spaces and backslashes.

Expression to be used to transform the string found with the 'include' option to a file name. Mostly useful to change "." to "/" for Java:

While typing a search command, show where the pattern, as it was typed so far, matches. The matched string is highlighted. If the pattern is invalid or not found, nothing is shown. The screen will be updated often, this is only useful on fast terminals. Also applies to the pattern in commands:

Expression which is evaluated to obtain the proper indent for a line. It is used when a new line is created, for the = operator and in Insert mode as specified with the 'indentkeys' option. When this option is not empty, it overrules the 'cindent' and 'smartindent' indenting. When 'lisp' is set, this option is is only used when 'lispoptions' contains "expr:1". When 'paste' is set this option is not used for indenting. The expression is evaluated with v:lnum set to the line number for which the indent is to be computed. The cursor is also in this line when the expression is evaluated (but it may be moved around).

A list of keys that, when typed in Insert mode, cause reindenting of the current line. Only happens if 'indentexpr' isn't empty. The format is identical to 'cinkeys', see indentkeys-format. See C-indenting and indent-expression.

When doing keyword completion in insert mode ins-completion, and 'ignorecase' is also on, the case of the match is adjusted depending on the typed text. If the typed text contains a lowercase letter where the match has an upper case letter, the completed part is made lowercase. If the typed text has no lowercase letters and the match has a lowercase letter where the typed text has an uppercase letter, and there is a letter before it, the completed part is made uppercase. With 'noinfercase' the match is used as-is.

The characters specified by this option are included in file names and path names. Filenames are used for commands like "gf", "[i" and in the tags file. It is also used for "\f" in a pattern. Multi-byte characters 256 and above are always included, only the characters up to 255 are specified with this option. For UTF-8 the characters 0xa0 to 0xff are included as well. Think twice before adding white space to this option. Although a space may appear inside a file name, the effect will be that Vim doesn't know where a file name starts or ends when doing completion. It most likely works better without a space in 'isfname'.

The characters given by this option are included in identifiers. Identifiers are used in recognizing environment variables and after a match of the 'define' option. It is also used for "\i" in a pattern. See 'isfname' for a description of the format of this option. For '@' only characters up to 255 are used. Careful: If you change this option, it might break expanding environment variables. E.g., when '/' is included and Vim tries to expand "$HOME/.viminfo". Maybe you should change 'iskeyword' instead.

Keywords are used in searching and recognizing with many commands: "w", "", "[i", etc. It is also used for "\k" in a pattern. See 'isfname' for a description of the format of this option. For '@' characters above 255 check the "word" character class (any character that is not white space or punctuation). For C programs you could use "a-z,A-Z,48-57,_,.,-,>". For a help file it is set to all non-blank printable characters except '', '"' and '|' (so that CTRL-] on a command finds the help for that command). When the 'lisp' option is on the '-' character is always included. This option also influences syntax highlighting, unless the syntax uses :syn-iskeyword. NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

The characters given by this option are displayed directly on the screen. It is also used for "\p" in a pattern. The characters from space (ASCII 32) to '~' (ASCII 126) are always displayed directly, even when they are not included in 'isprint' or excluded. See 'isfname' for a description of the format of this option.

Insert two spaces after a '.', '?' and '!' with a join command. When 'cpoptions' includes the 'j' flag, only do this after a '.'. Otherwise only one space is inserted. NOTE: This option is set when 'compatible' is set.

List of words that change the behavior of the jumplist. stack Make the jumplist behave like the tagstack. Relative location of entries in the jumplist is preserved at the cost of discarding subsequent entries when navigating backwards in the jumplist and then jumping to a location. jumplist-stack

Name of a keyboard mapping. See mbyte-keymap. Setting this option to a valid keymap name has the side effect of setting 'iminsert' to one, so that the keymap becomes effective. 'imsearch' is also set to one, unless it was -1 Only normal file name characters can be used, "/\*?[|<>" are illegal.

List of comma-separated words, which enable special things that keys can do. These values can be used: startsel Using a shifted special key starts selection (either Select mode or Visual mode, depending on "key" being present in 'selectmode'). stopsel Using a not-shifted special key stops selection. Special keys in this context are the cursor keys, <End>, <Home>, <PageUp> and <PageDown>. The 'keymodel' option is set by the :behave command.

Program to use for the K command. Environment variables are expanded :set_env. ":help" may be used to access the Vim internal help. (Note that previously setting the global option to the empty value did this, which is now deprecated.) When the first character is ":", the command is invoked as a Vim Ex command with [count] added as an argument if it is not zero. When "man", "man -s" or an Ex command is used, Vim will automatically translate a count for the "K" command and pass it as the first argument. For "man -s" the "-s" is removed when there is no count. See option-backslash about including spaces and backslashes. Example:

This option allows switching your keyboard into a special language mode. When you are typing text in Insert mode the characters are inserted directly. When in Normal mode the 'langmap' option takes care of translating these special characters to the original meaning of the key. This means you don't have to change the keyboard mode to be able to execute Normal mode commands. This is the opposite of the 'keymap' option, where characters are mapped in Insert mode. Also consider setting 'langremap' to off, to prevent 'langmap' from applying to characters resulting from a mapping. This option cannot be set from a modeline or in the sandbox, for security reasons.

Language to use for menu translation. Tells which file is loaded from the "lang" directory in 'runtimepath':

When off, setting 'langmap' does not apply to characters resulting from a mapping. This basically means, if you noticed that setting 'langmap' disables some of your mappings, try resetting this option. This option defaults to on for backwards compatibility. Set it off if that works for you to avoid mappings to break.

The value of this option influences when the last window will have a status line: 0: never 1: only if there are at least two windows 2: always The screen looks nicer with a status line if you have several windows, but it takes another screen line. status-line

When this option is set, the screen will not be redrawn while executing macros, registers and other commands that have not been typed. Also, updating the window title is postponed. To force an update use :redraw. This may occasionally cause display errors. It is only meant to be set temporarily when performing an operation where redrawing may cause flickering or cause a slow down.

If on, Vim will wrap long lines at a character in 'breakat' rather than at the last character that fits on the screen. Unlike 'wrapmargin' and 'textwidth', this does not insert <EOL>s in the file, it only affects the way the file is displayed, not its contents. If 'breakindent' is set, line is visually indented. Then, the value of 'showbreak' is used to put in front of wrapped lines. This option is not used when the 'wrap' option is off. Note that <Tab> characters after an <EOL> are mostly not displayed with the right amount of white space.

Number of lines of the Vim window. Normally you don't need to set this. It is done automatically by the terminal initialization code. Also see posix-screen-size. When Vim is running in the GUI or in a resizable window, setting this option will cause the window size to be changed. When you only want to use the size for the GUI, put the command in your gvimrc file. Vim limits the number of lines to what fits on the screen. You can use this command to get the tallest window possible:

Number of pixel lines inserted between characters. Useful if the font uses the full character cell height, making lines touch each other. When non-zero there is room for underlining. With some fonts there can be too much room between lines (to have space for ascents and descents). Then it makes sense to set 'linespace' to a negative value. This may cause display problems though!

Lisp mode: When <Enter> is typed in insert mode set the indent for the next line to Lisp standards (well, sort of). Also happens with "cc" or "S". 'autoindent' must also be on for this to work. The 'p' flag in 'cpoptions' changes the method of indenting: Vi compatible or better. Also see 'lispwords'. The '-' character is included in keyword characters. Redefines the "=" operator to use this same indentation algorithm rather than calling an external program if 'equalprg' is empty. This option is not used when 'paste' is set.

Comma-separated list of items that influence the Lisp indenting when enabled with the 'lisp' option. Currently only one item is supported: expr:1 use 'indentexpr' for Lisp indenting when it is set expr:0 do not use 'indentexpr' for Lisp indenting (default) Note that when using 'indentexpr' the = operator indents all the lines, otherwise the first line is not indented (Vi-compatible).

Comma-separated list of words that influence the Lisp indenting when enabled with the 'lisp' option.

List mode: By default show tabs as CTRL-I is displayed, display $ after end of line. Useful to see the difference between tabs and spaces and for trailing blanks. Further changed by the 'listchars' option.

Strings to use in 'list' mode and for the :list command. It is a comma-separated list of string settings.

When on the plugin scripts are loaded when starting up load-plugins. This option can be reset in your vimrc file to disable the loading of plugins. Note that using the "-u NONE", "-u DEFAULTS" and "--noplugin" command line arguments reset this option. See -u and --noplugin.

Changes the special characters that can be used in search patterns. See pattern. WARNING: Switching this option off most likely breaks plugins! That is because many patterns assume it's on and will fail when it's off. Only switch it off when working with old Vi scripts. In any other situation write patterns that work when 'magic' is on. Include "\M" when you want to /\M. In Vim9 script the value of 'magic' is ignored, patterns behave like it is always set.

Name of the errorfile for the :make command (see :make_makeprg) and the :grep command. When it is empty, an internally generated temp file will be used. When "##" is included, it is replaced by a number to make the name unique. This makes sure that the ":make" command doesn't overwrite an existing file. NOT used for the ":cf" command. See 'errorfile' for that. Environment variables are expanded :set_env. See option-backslash about including spaces and backslashes. This option cannot be set from a modeline or in the sandbox, for security reasons.

Encoding used for reading the output of external commands. When empty, encoding is not converted. This is used for :make, :lmake, :grep, :lgrep, :grepadd, :lgrepadd, :cfile, :cgetfile, :caddfile, :lfile, :lgetfile, and :laddfile.

Program to use for the ":make" command. See :make_makeprg. This option may contain '%' and '#' characters (see :_% and :_#), which are expanded to the current and alternate file name. Use ::S to escape file names in case they contain special characters. Environment variables are expanded :set_env. See option-backslash about including spaces and backslashes. Note that a '|' must be escaped twice: once for ":set" and once for the interpretation of a command. When you use a filter called "myfilter" do it like this:

Characters that form pairs. The % command jumps from one to the other. Only character pairs are allowed that are different, thus you cannot jump between two double quotes. The characters must be separated by a colon. The pairs must be separated by a comma. Example for including '<' and '>' (for HTML):

Tenths of a second to show the matching paren, when 'showmatch' is set. Note that this is not in milliseconds, like other options that set a time. This is to be compatible with Nvi.

Maximum depth of function calls for user functions. This normally catches endless recursion. When using a recursive function with more depth, set 'maxfuncdepth' to a bigger number. But this will use more memory, there is the danger of failing when memory is exhausted. Increasing this limit above 200 also changes the maximum for Ex command recursion, see E169. See also :function. Also used for maximum depth of callback functions.

Maximum number of times a mapping is done without resulting in a character to be used. This normally catches endless mappings, like ":map x y" with ":map y x". It still does not catch ":map g wg", because the 'w' is used before the next mapping is done. See also key-mapping.

Maximum amount of memory (in Kbyte) to use for pattern matching. The maximum value is about 2000000. Use this to work without a limit.

Maximum number of items to use in a menu. Used for menus that are generated from a list of items, e.g., the Buffers menu. Changing this option has no direct effect, the menu must be refreshed first.

Parameters for :mkspell. This tunes when to start compressing the word tree. Compression can be slow when there are many words, but it's needed to avoid running out of memory. The amount of memory used per word depends very much on how similar the words are, that's why this tuning is complicated.

If 'modeline' is on 'modelines' gives the number of lines that is checked for set commands. If 'modeline' is off or 'modelines' is zero no lines are checked. See modeline.

When on allow some options that are an expression to be set in the modeline. Check the option for whether it is affected by 'modelineexpr'. Also see modeline. This option cannot be set from a modeline or in the sandbox, for security reasons.

If 'modeline' is on 'modelines' gives the number of lines that is checked for set commands. If 'modeline' is off or 'modelines' is zero no lines are checked. See modeline. NOTE: 'modeline' is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

When off the buffer contents cannot be changed. The 'fileformat' and 'fileencoding' options also can't be changed. Can be reset on startup with the -M command line argument.

When on, the buffer is considered to be modified. This option is set when:

1. A change was made to the text since it was last written. Using the undo command to go back to the original text will reset the option. But undoing changes that were made before writing the buffer will set the option again, since the text is different from when it was written.
2. 'fileformat' or 'fileencoding' is different from its original value. The original value is set when the buffer is read or written. A ":set nomodified" command also resets the original values to the current values and the 'modified' option will be reset. Similarly for 'eol' and 'bomb'. This option is not set when a change is made to the buffer as the result of a BufNewFile, BufRead/BufReadPost, BufWritePost, FileAppendPost or VimLeave autocommand event. See gzip-example for an explanation. When 'buftype' is "nowrite" or "nofile" this option may be set, but will be ignored. Note that the text may actually be the same, e.g. 'modified' is set when using "rA" on an "A".

When on, listings pause when the whole screen is filled. You will get the more-prompt. When this option is off there are no pauses, the listing continues until finished. NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

Enable the use of the mouse. Works for most terminals (xterm, Win32 win32-mouse, QNX pterm, *BSD console with sysmouse and Linux console with gpm). For using the mouse in the GUI, see gui-mouse. The mouse can be enabled for different modes: n Normal mode and Terminal modes v Visual mode i Insert mode c Command-line mode h all previous modes when editing a help file a all previous modes r for hit-enter and more-prompt prompt Normally you would enable the mouse in all five modes with:

The window that the mouse pointer is on is automatically activated. When changing the window layout or window focus in another way, the mouse pointer is moved to the window with keyboard focus. Off is the default because it makes using the pull down menus a little goofy, as a pointer transit may activate a window unintentionally. MS-Windows: Also see 'scrollfocus' for what window is scrolled when using the mouse scroll wheel.

When on, the mouse pointer is hidden when characters are typed. The mouse pointer is restored when the mouse is moved.

Sets the model to use for the mouse. The name mostly specifies what the right mouse button is used for: extend Right mouse button extends a selection. This works like in an xterm. popup Right mouse button pops up a menu. The shifted left mouse button extends a selection. This works like with Microsoft Windows. popup_setpos Like "popup", but the cursor will be moved to the position where the mouse was clicked, and thus the selected operation will act upon the clicked object. If clicking inside a selection, that selection will be acted upon, i.e. no cursor move. This implies of course, that right clicking outside a selection will end Visual mode. Overview of what button does what for each model: mouse extend popup(_setpos) left click place cursor place cursor left drag start selection start selection shift-left search word extend selection right click extend selection popup menu (place cursor) right drag extend selection - middle click paste paste

When on, mouse move events are delivered to the input queue and are available for mapping. The default, off, avoids the mouse movement overhead except when needed. See gui-mouse-mapping. Warning: Setting this option can make pending mappings to be aborted when the mouse is moved. Currently only works in the GUI, may be made to work in a terminal later.

This option tells Vim what the mouse pointer should look like in different modes. The option is a comma-separated list of parts, much like used for 'guicursor'. Each part consist of a mode/location-list and an argument-list: mode-list:shape,mode-list:shape,.. The mode-list is a dash separated list of these modes/locations: In a normal window: n Normal mode v Visual mode ve Visual mode with 'selection' "exclusive" (same as 'v', if not specified) o Operator-pending mode i Insert mode r Replace mode

Only for GUI, Win32 and Unix with xterm. Defines the maximum time in msec between two mouse clicks for the second click to be recognized as a multi click.

This defines what bases Vim will consider for numbers when using the CTRL-A and CTRL-X commands for adding to and subtracting from a number respectively; see CTRL-A for more info on these commands. alpha If included, single alphabetical characters will be incremented or decremented. This is useful for a list with a letter index a), b), etc. octal If included, numbers that start with a zero will be considered to be octal. Example: Using CTRL-A on "007" results in "010". hex If included, numbers starting with "0x" or "0X" will be considered to be hexadecimal. Example: Using CTRL-X on "0x100" results in "0x0ff". bin If included, numbers starting with "0b" or "0B" will be considered to be binary. Example: Using CTRL-X on "0b1000" subtracts one, resulting in "0b0111". unsigned If included, numbers are recognized as unsigned. Thus a leading dash or negative sign won't be considered as part of the number. Examples: Using CTRL-X on "2020" in "9-2020" results in "9-2019" (without "unsigned" it would become "9-2021"). Using CTRL-A on "2020" in "9-2020" results in "9-2021" (without "unsigned" it would become "9-2019"). Using CTRL-X on "0" or CTRL-A on "18446744073709551615" (2^64 - 1) has no effect, overflow is prevented. Numbers which simply begin with a digit in the range 1-9 are always considered decimal. This also happens for numbers that are not recognized as octal or hex.

Print the line number in front of each line. When the 'n' option is excluded from 'cpoptions' a wrapped line will not use the column of line numbers (this is the default when 'compatible' isn't set). The 'numberwidth' option can be used to set the room used for the line number. When a long, wrapped line doesn't start with the first character, '-' characters are put before the number. For highlighting see hl-LineNr, and hl-CursorLineNr, and the :sign-define "numhl" argument.

Minimal number of columns to use for the line number. Only relevant when the 'number' or 'relativenumber' option is set or printing lines with a line number. Since one space is always between the number and the text, there is one less character for the number itself. The value is the minimum width. A bigger width is used when needed to fit the highest line number in the buffer respectively the number of rows in the window, depending on whether 'number' or 'relativenumber' is set. Thus with the Vim default of 4 there is room for a line number up to 999. When the buffer has 1000 lines five columns will be used. The minimum value is 1, the maximum value is 20. NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

This option specifies a function to be used for Insert mode omni completion with CTRL-X CTRL-O. i_CTRL-X_CTRL-O See complete-functions for an explanation of how the function is invoked and what it should return. The value can be the name of a function, a lambda or a Funcref. See option-value-function for more information. This option is usually set by a filetype plugin: :filetype-plugin-on This option cannot be set from a modeline or in the sandbox, for security reasons.

only for MS-Windows Enable reading and writing from devices. This may get Vim stuck on a device that can be opened but doesn't actually do the I/O. Therefore it is off by default. Note that on MS-Windows editing "aux.h", "lpt1.txt" and the like also result in editing a device.

This option specifies a function to be called by the g@ operator. See :map-operator for more info and an example. The value can be the name of a function, a lambda or a Funcref. See option-value-function for more information.

Directories used to find packages. See packages. This option cannot be set from a modeline or in the sandbox, for security reasons.

Specifies the nroff macros that separate paragraphs. These are pairs of two letters (see object-motions).

Expression which is evaluated to apply a patch to a file and generate the resulting new version of the file. See diff-patchexpr. This option cannot be set from a modeline or in the sandbox, for security reasons.

When non-empty the oldest version of a file is kept. This can be used to keep the original version of a file if you are changing files in a source distribution. Only the first time that a file is written a copy of the original file will be kept. The name of the copy is the name of the original file with the string in the 'patchmode' option appended. This option should start with a dot. Use a string like ".orig" or ".org". 'backupdir' must not be empty for this to work (Detail: The backup file is renamed to the patchmode file after the new file has been successfully written, that's why it must be possible to write a backup file). If there was no file to be backed up, an empty file is created. When the 'backupskip' pattern matches, a patchmode file is not made. Using 'patchmode' for compressed files appends the extension at the end (e.g., "file.gz.orig"), thus the resulting name isn't always recognized as a compressed file. Only normal file name characters can be used, "/\*?[|<>" are illegal.

This is a list of directories which will be searched when using the gf, [f, ]f, ^Wf, :find, :sfind, :tabfind and other commands, provided that the file being searched for has a relative path (not starting with "/", "./" or "../"). The directories in the 'path' option may be relative or absolute.

• Use commas to separate directory names:

When changing the indent of the current line, preserve as much of the indent structure as possible. Normally the indent is replaced by a series of tabs followed by spaces as required (unless 'expandtab' is enabled, in which case only spaces are used). Enabling this option means the indent will preserve as many existing characters as possible for indenting, and only add additional tabs or spaces as required. 'expandtab' does not apply to the preserved white space, a Tab remains a Tab. NOTE: When using ">>" multiple times the resulting indent is a mix of tabs and spaces. You might not like this. NOTE: This option is reset when 'compatible' is set. Also see 'copyindent'. Use :retab to clean up white space.

Default height for a preview window. Used for :ptag and associated commands. Used for CTRL-W_} when no count is given. Not used when 'previewpopup' is set.

Identifies the preview window. Only one window can have this option set. It's normally not set directly, but by using one of the commands :ptag, :pedit, etc.

Determines the maximum number of items to show in the popup menu for Insert mode completion. When zero as much space as available is used. ins-completion-menu.

Determines the minimum width to use for the popup menu for Insert mode completion. ins-completion-menu.

Specifies the python version used for pyx* functions and commands python_x. The default value is as follows:

This option specifies a function to be used to get the text to display in the quickfix and location list windows. This can be used to customize the information displayed in the quickfix or location window for each entry in the corresponding quickfix or location list. See quickfix-window-function for an explanation of how to write the function and an example. The value can be the name of a function, a lambda or a Funcref. See option-value-function for more information.

The characters that are used to escape quotes in a string. Used for objects like a', a" and a` a'. When one of the characters in this option is found inside a string, the following character will be skipped. The default value makes the text "foo"bar\" considered to be one string.

If on, writes fail unless you use a '!'. Protects you from accidentally overwriting a file. Default on when Vim is started in read-only mode ("vim -R") or when the executable is called "view". When using ":w!" the 'readonly' option is reset for the current buffer, unless the 'Z' flag is in 'cpoptions'. When using the ":view" command the 'readonly' option is set for the newly edited buffer. See 'modifiable' for disallowing changes to the buffer.

The time in milliseconds for redrawing the display. This applies to searching for patterns for 'hlsearch', :match highlighting and syntax highlighting. When redrawing takes more than this many milliseconds no further matches will be highlighted. For syntax highlighting the time applies per window. When over the limit syntax highlighting is disabled until CTRL-L is used. This is used to avoid that Vim hangs when using a very complicated pattern.

This selects the default regexp engine. two-engines The possible values are: 0 automatic selection 1 old engine 2 NFA engine Note that when using the NFA engine and the pattern contains something that is not supported the pattern will not match. This is only useful for debugging the regexp engine. Using automatic selection enables Vim to switch the engine, if the default engine becomes too costly. E.g., when the NFA engine uses too many states. This should prevent Vim from hanging on a combination of a complex pattern with long text.

Show the line number relative to the line with the cursor in front of each line. Relative line numbers help you use the count you can precede some vertical motion commands (e.g. j k + -) with, without having to calculate it yourself. Especially useful in combination with other commands (e.g. y d c < > gq gw =). When the 'n' option is excluded from 'cpoptions' a wrapped line will not use the column of line numbers (this is the default when 'compatible' isn't set). The 'numberwidth' option can be used to set the room used for the line number. When a long, wrapped line doesn't start with the first character, '-' characters are put before the number. See hl-LineNr and hl-CursorLineNr for the highlighting used for the number.

Threshold for reporting number of lines changed. When the number of changed lines is more than 'report' a message will be given for most ":" commands. If you want it always, set 'report' to 0. For the ":substitute" command the number of substitutions is used instead of the number of lines.

Inserting characters in Insert mode will work backwards. See "typing backwards" ins-reverse. This option can be toggled with the CTRL-_ command in Insert mode, when 'allowrevins' is set. NOTE: This option is reset when 'compatible' is set. This option is reset when 'paste' is set and restored when 'paste' is reset.

When on, display orientation becomes right-to-left, i.e., characters that are stored in the file appear from the right to the left. Using this option, it is possible to edit files for languages that are written from the right to the left such as Hebrew and Arabic. This option is per window, so it is possible to edit mixed files simultaneously, or to view the same file in both ways (this is useful whenever you have a mixed text file with both right-to-left and left-to-right strings so that both sets are displayed properly in different windows). Also see rileft.txt.

Each word in this option enables the command line editing to work in right-to-left mode for a group of commands:

Show the line and column number of the cursor position, separated by a comma. When there is room, the relative position of the displayed text in the file is shown on the far right: Top first line is visible Bot last line is visible All first and last line are visible 45% relative position in the file If 'rulerformat' is set, it will determine the contents of the ruler. Each window has its own ruler. If a window has a status line, the ruler is shown there. Otherwise it is shown in the last line of the screen. If the statusline is given by 'statusline' (i.e. not empty), this option takes precedence over 'ruler' and 'rulerformat'. If the number of characters displayed is different from the number of bytes in the text (e.g., for a TAB or a multibyte character), both the text column (byte number) and the screen column are shown, separated with a dash. For an empty line "0-1" is shown. For an empty buffer the line number will also be zero: "0,0-1". This option is reset when 'paste' is set and restored when 'paste' is reset. If you don't want to see the ruler all the time but want to know where you are, use "g CTRL-G" g_CTRL-G. NOTE: This option is reset when 'compatible' is set.

When this option is not empty, it determines the content of the ruler string, as displayed for the 'ruler' option. The format of this option is like that of 'statusline'. This option cannot be set in a modeline when 'modelineexpr' is off.

This is a list of directories which will be searched for runtime files: filetype.vim filetypes by file name new-filetype scripts.vim filetypes by file contents new-filetype-scripts autoload/ automatically loaded scripts autoload-functions colors/ color scheme files :colorscheme compiler/ compiler files :compiler doc/ documentation write-local-help ftplugin/ filetype plugins write-filetype-plugin import/ files that are found by :import indent/ indent scripts indent-expression keymap/ key mapping files mbyte-keymap lang/ menu translations :menutrans menu.vim GUI menus menu.vim pack/ packages :packadd plugin/ plugin scripts write-plugin print/ files for printing postscript-print-encoding spell/ spell checking files spell syntax/ syntax files mysyntaxfile tutor/ files for vimtutor tutor

Number of lines to scroll with CTRL-U and CTRL-D commands. Will be set to half the number of lines in the window when the window size changes. This may happen when enabling the status-line or 'tabline' option after setting the 'scroll' option. If you give a count to the CTRL-U or CTRL-D command it will be used as the new value for 'scroll'. Reset to half the window height with ":set scroll=0".

See also scroll-binding. When this option is set, scrolling the current window also scrolls other scrollbind windows (windows that also have this option set). This option is useful for viewing the differences between two versions of a file, see 'diff'. See 'scrollopt' for options that determine how this option should be interpreted. This option is mostly reset when splitting a window to edit another file. This means that ":split | edit file" results in two windows with scroll-binding, but ":split file" does not.

Minimal number of lines to scroll when the cursor gets off the screen (e.g., with "j"). Not used for scroll commands (e.g., CTRL-E, CTRL-D). Useful if your terminal scrolls very slowly. When set to a negative number from -1 to -100 this is used as the percentage of the window height. Thus -50 scrolls half the window height. NOTE: This option is set to 1 when 'compatible' is set.

Minimal number of screen lines to keep above and below the cursor. This will make some context visible around where you are working. If you set it to a very large value (999) the cursor line will always be in the middle of the window (except at the start or end of the file or when long lines wrap). After using the local value, go back the global value with one of these two:

This is a comma-separated list of words that specifies how 'scrollbind' windows should behave. 'sbo' stands for ScrollBind Options. The following words are available: ver Bind vertical scrolling for 'scrollbind' windows hor Bind horizontal scrolling for 'scrollbind' windows jump Applies to the offset between two windows for vertical scrolling. This offset is the difference in the first displayed line of the bound windows. When moving around in a window, another 'scrollbind' window may reach a position before the start or after the end of the buffer. The offset is not changed though, when moving back the 'scrollbind' window will try to scroll to the desired position when possible. When now making that window the current one, two things can be done with the relative offset: 1. When "jump" is not included, the relative offset is adjusted for the scroll position in the new current window. When going back to the other window, the new relative offset will be used. 2. When "jump" is included, the other windows are scrolled to keep the same relative offset. When going back to the other window, it still uses the same relative offset. Also see scroll-binding. When 'diff' mode is active there always is vertical scroll binding, even when "ver" isn't there.

Specifies the nroff macros that separate sections. These are pairs of two letters (See object-motions). The default makes a section start at the nroff macros ".SH", ".NH", ".H", ".HU", ".nh" and ".sh".

This option defines the behavior of the selection. It is only used in Visual and Select mode. Possible values: value past line inclusive old no yes inclusive yes yes exclusive yes no "past line" means that the cursor is allowed to be positioned one character past the line. "inclusive" means that the last character of the selection is included in an operation. For example, when "x" is used to delete the selection. When "old" is used and 'virtualedit' allows the cursor to move past the end of line the line break still isn't included. Note that when "exclusive" is used and selecting from the end backwards, you cannot include the last character of a line, when starting in Normal mode and 'virtualedit' empty.

This is a comma-separated list of words, which specifies when to start Select mode instead of Visual mode, when a selection is started. Possible values: mouse when using the mouse key when using shifted special keys cmd when using "v", "V" or CTRL-V See Select-mode. The 'selectmode' option is set by the :behave command.

Changes the effect of the :mksession command. It is a comma separated list of words. Each word enables saving and restoring something: word save and restore blank empty windows buffers hidden and unloaded buffers, not just those in windows curdir the current directory folds manually created folds, opened/closed folds and local fold options globals global variables that start with an uppercase letter and contain at least one lowercase letter. Only String and Number types are stored. help the help window localoptions options and mappings local to a window or buffer (not global values for local options) options all options and mappings (also global values for local options) skiprtp exclude 'runtimepath' and 'packpath' from the options resize size of the Vim window: 'lines' and 'columns' sesdir the directory in which the session file is located will become the current directory (useful with projects accessed over a network from different systems) slash backslashes in file names replaced with forward slashes tabpages all tab pages; without this only the current tab page is restored, so that you can make a session for each tab page separately terminal include terminal windows where the command can be restored unix with Unix end-of-line format (single <NL>), even when on Windows or DOS winpos position of the whole Vim window winsize window sizes

Name of the shell to use for ! and :! commands. When changing the value also check these options: 'shelltype', 'shellpipe', 'shellslash' 'shellredir', 'shellquote', 'shellxquote' and 'shellcmdflag'. It is allowed to give an argument to the command, e.g. "csh -f". See option-backslash about including spaces and backslashes. Environment variables are expanded :set_env.

Flag passed to the shell to execute "!" and ":!" commands; e.g., "bash.exe -c ls", "powershell.exe -Command dir", or "cmd.exe /c dir". For MS-Windows, the default is set according to the value of 'shell', to reduce the need to set this option by the user. On Unix it can have more than one flag. Each white space separated part is passed as an argument to the shell command. See option-backslash about including spaces and backslashes. Also see dos-shell and dos-powershell for MS-Windows. This option cannot be set from a modeline or in the sandbox, for security reasons.

String to be used to put the output of the ":make" command in the error file. See also :make_makeprg. See option-backslash about including spaces and backslashes. The name of the temporary file can be represented by "%s" if necessary (the file name is appended automatically if no %s appears in the value of this option). For the Amiga the default is ">". For MS-Windows using powershell the default is "2>&1 | Out-File -Encoding default", otherwise the default is ">%s 2>&1". The output is directly saved in a file and not echoed to the screen. For Unix the default is "| tee". The stdout of the compiler is saved in a file and echoed to the screen. If the 'shell' option is "csh" or "tcsh" after initializations, the default becomes "|& tee". If the 'shell' option is "sh", "ksh", "mksh", "pdksh", "zsh", "zsh-beta", "bash", "fish", "ash" or "dash" the default becomes "2>&1| tee". This means that stderr is also included. Before using the 'shell' option a path is removed, thus "/bin/sh" uses "sh". For Unix and MS-Windows, when the 'shell' option is "pwsh" the default becomes ">%s 2>&1" and the output is not echoed to the screen. The initialization of this option is done after reading the ".vimrc" and the other initializations, so that when the 'shell' option is set there, the 'shellpipe' option changes automatically, unless it was explicitly set before. When 'shellpipe' is set to an empty string, no redirection of the ":make" output will be done. This is useful if you use a 'makeprg' that writes to 'makeef' by itself. If you want no piping, but do want to include the 'makeef', set 'shellpipe' to a single space. Don't forget to precede the space with a backslash: ":set sp=\ ". In the future pipes may be used for filtering and this option will become obsolete (at least for Unix). This option cannot be set from a modeline or in the sandbox, for security reasons.

Quoting character(s), put around the command passed to the shell, for the "!" and ":!" commands. The redirection is kept outside of the quoting. See 'shellxquote' to include the redirection. It's probably not useful to set both options. This is an empty string by default. Only known to be useful for third-party shells on MS-Windows-like systems, such as the MKS Korn Shell or bash, where it should be """. See dos-shell. This option cannot be set from a modeline or in the sandbox, for security reasons.

String to be used to put the output of a filter command in a temporary file. See also :!. See option-backslash about including spaces and backslashes. The name of the temporary file can be represented by "%s" if necessary (the file name is appended automatically if no %s appears in the value of this option). The default is ">". For Unix, if the 'shell' option is "csh" or "tcsh" during initializations, the default becomes ">&". If the 'shell' option is "sh", "ksh", "mksh", "pdksh", "zsh", "zsh-beta", "bash", "fish", or "pwsh", the default becomes ">%s 2>&1". This means that stderr is also included. For Win32, the Unix checks are done and additionally "cmd" is checked for, which makes the default ">%s 2>&1", and "powershell" is checked for which makes the default "2>&1 | Out-File -Encoding default" (see dos-powershell). Also, the same names with ".exe" appended are checked for. The initialization of this option is done after reading the ".vimrc" and the other initializations, so that when the 'shell' option is set there, the 'shellredir' option changes automatically unless it was explicitly set before. In the future pipes may be used for filtering and this option will become obsolete (at least for Unix). This option cannot be set from a modeline or in the sandbox, for security reasons.

When set, a forward slash is used when expanding file names. This is useful when a Unix-like shell is used instead of cmd.exe, pwsh.exe, or powershell.exe. Backward slashes can still be typed, but they are changed to forward slashes by Vim. Note that setting or resetting this option has no effect for some existing file names, thus this option needs to be set before opening any file for best results. This might change in the future. 'shellslash' only works when a backslash can be used as a path separator. To test if this is so use:

When on, use temp files for shell commands. When off use a pipe. When using a pipe is not possible temp files are used anyway. Currently a pipe is only supported on Unix and MS-Windows 2K and later. You can check it with:

When 'shellxquote' is set to "(" then the characters listed in this option will be escaped with a '^' character. This makes it possible to execute most external commands with cmd.exe. This option cannot be set from a modeline or in the sandbox, for security reasons.

Quoting character(s), put around the command passed to the shell, for the "!" and ":!" commands. Includes the redirection. See 'shellquote' to exclude the redirection. It's probably not useful to set both options. When the value is '(' then ')' is appended. When the value is '"(' then ')"' is appended. When the value is '(' then also see 'shellxescape'. This is an empty string by default on most systems, but is known to be useful for on Win32 version, either for cmd.exe, powershell.exe, or pwsh.exe which automatically strips off the first and last quote on a command, or 3rd-party shells such as the MKS Korn Shell or bash, where it should be """. The default is adjusted according the value of 'shell', to reduce the need to set this option by the user. See dos-shell. This option cannot be set from a modeline or in the sandbox, for security reasons.

Round indent to multiple of 'shiftwidth'. Applies to > and < commands. CTRL-T and CTRL-D in Insert mode always round the indent to a multiple of 'shiftwidth' (this is Vi compatible). NOTE: This option is reset when 'compatible' is set.

Number of spaces to use for each step of (auto)indent. Used for 'cindent', >>, <<, etc. When zero the 'tabstop' value will be used. Use the shiftwidth() function to get the effective shiftwidth value.

This option helps to avoid all the hit-enter prompts caused by file messages, for example with CTRL-G, and to avoid some other messages. It is a list of flags: flag meaning when present f use "(3 of 5)" instead of "(file 3 of 5)" i use "[noeol]" instead of "[Incomplete last line]" l use "999L, 888B" instead of "999 lines, 888 bytes" m use "[+]" instead of "[Modified]" n use "[New]" instead of "[New File]" r use "[RO]" instead of "[readonly]" w use "[w]" instead of "written" for file write message and "[a]" instead of "appended" for ':w >> file' command x use "[dos]" instead of "[dos format]", "[unix]" instead of "[unix format]" and "[mac]" instead of "[mac format]" a all of the above abbreviations

String to put at the start of lines that have been wrapped. Useful values are "> " or "+++ ":

Show (partial) command in the last line of the screen. Set this option off if your terminal is slow. In Visual mode the size of the selected area is shown:

• When selecting characters within a line, the number of characters. If the number of bytes is different it is also displayed: "2-6" means two characters and six bytes.
• When selecting more than one line, the number of lines.
• When selecting a block, the size in screen characters: {lines}x{columns}. This information can be displayed in an alternative location using the 'showcmdloc' option. NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

This option can be used to display the (partially) entered command in another location. Possible values are: last Last line of the screen (default). statusline Status line of the current window. tabline First line of the screen if 'showtabline' is enabled. Setting this option to "statusline" or "tabline" means that these will be redrawn whenever the command changes, which can be on every key pressed. The %S 'statusline' item can be used in 'statusline' or 'tabline' to place the text. Without a custom 'statusline' or 'tabline' it will be displayed in a convenient location.

When completing a word in insert mode (see ins-completion) from the tags file, show both the tag name and a tidied-up form of the search pattern (if there is one) as possible matches. Thus, if you have matched a C function, you can see a template for what arguments are required (coding style permitting). Note that this doesn't work well together with having "longest" in 'completeopt', because the completion from the search pattern may not match the typed text.

When a bracket is inserted, briefly jump to the matching one. The jump is only done if the match can be seen on the screen. The time to show the match can be set with 'matchtime'. A Beep is given if there is no match (no matter if the match can be seen or not). This option is reset when 'paste' is set and restored when 'paste' is reset. When the 'm' flag is not included in 'cpoptions', typing a character will immediately move the cursor back to where it belongs. See the "sm" field in 'guicursor' for setting the cursor shape and blinking when showing the match. The 'matchpairs' option can be used to specify the characters to show matches for. 'rightleft' and 'revins' are used to look for opposite matches. Also see the matchparen plugin for highlighting the match when moving around pi_paren.txt. Note: Use of the short form is rated PG.

If in Insert, Replace or Visual mode put a message on the last line. Use the 'M' flag in 'highlight' to set the type of highlighting for this message. When XIM may be used the message will include "XIM". But this doesn't mean XIM is really active, especially when 'imactivatekey' is not set. NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

The value of this option specifies when the line with tab page labels will be displayed: 0: never 1: only if there are at least two tab pages 2: always This is both for the GUI and non-GUI implementation of the tab pages line. See tab-page for more information about tab pages.

The minimal number of columns to scroll horizontally. Used only when the 'wrap' option is off and the cursor is moved off of the screen. When it is zero the cursor will be put in the middle of the screen. When using a slow terminal set it to a large number or 0. When using a fast terminal use a small number or 1. Not used for "zh" and "zl" commands.

The minimal number of screen columns to keep to the left and to the right of the cursor if 'nowrap' is set. Setting this option to a value greater than 0 while having 'sidescroll' also at a non-zero value makes some context visible in the line you are scrolling in horizontally (except at beginning of the line). Setting this option to a large value (like 999) has the effect of keeping the cursor horizontally centered in the window, as long as one does not come too close to the beginning of the line. After using the local value, go back the global value with one of these two:

Whether or not to draw the signcolumn. Valid values are: "auto" only when there is a sign to display "no" never "yes" always "number" display signs in the 'number' column. If the number column is not present, then behaves like "auto".

Override the 'ignorecase' option if the search pattern contains upper case characters. Only used when the search pattern is typed and 'ignorecase' option is on. Used for the commands "/", "?", "n", "N", ":g" and ":s". Not used for "", "#", "gd", tag search, etc. After "" and "#" you can make 'smartcase' used by doing a "/" command, recalling the search pattern from history and hitting <Enter>. NOTE: This option is reset when 'compatible' is set.

Do smart autoindenting when starting a new line. Works for C-like programs, but can also be used for other languages. 'cindent' does something like this, works better in most cases, but is more strict, see C-indenting. When 'cindent' is on or 'indentexpr' is set, setting 'si' has no effect. 'indentexpr' is a more advanced alternative. Normally 'autoindent' should also be on when using 'smartindent'. An indent is automatically inserted:

• After a line ending in '{'.
• After a line starting with a keyword from 'cinwords'.
• Before a line starting with '}' (only with the "O" command). When typing '}' as the first character in a new line, that line is given the same indent as the matching '{'. When typing '#' as the first character in a new line, the indent for that line is removed, the '#' is put in the first column. The indent is restored for the next line. If you don't want this, use this mapping: ":inoremap # X^H#", where ^H is entered with CTRL-V CTRL-H. When using the ">>" command, lines starting with '#' are not shifted right. NOTE: This option is reset when 'compatible' is set. This option is reset when 'paste' is set and restored when 'paste' is reset.

When on, a <Tab> in front of a line inserts blanks according to 'shiftwidth'. 'tabstop' or 'softtabstop' is used in other places. A <BS> will delete a 'shiftwidth' worth of space at the start of the line. When off, a <Tab> always inserts blanks according to 'tabstop' or 'softtabstop'. 'shiftwidth' is only used for shifting text left or right shift-left-right. What gets inserted (a <Tab> or spaces) depends on the 'expandtab' option. Also see ins-expandtab. When 'expandtab' is not set, the number of spaces is minimized by using <Tab>s. This option is reset when 'paste' is set and restored when 'paste' is reset. NOTE: This option is reset when 'compatible' is set.

Number of spaces that a <Tab> counts for while performing editing operations, like inserting a <Tab> or using <BS>. It "feels" like <Tab>s are being inserted, while in fact a mix of spaces and <Tab>s is used. This is useful to keep the 'ts' setting at its standard value of 8, while being able to edit like it is set to 'sts'. However, commands like "x" still work on the actual characters. When 'sts' is zero, this feature is off. When 'sts' is negative, the value of 'shiftwidth' is used. 'softtabstop' is set to 0 when the 'paste' option is set and restored when 'paste' is reset. See also ins-expandtab. When 'expandtab' is not set, the number of spaces is minimized by using <Tab>s. The 'L' flag in 'cpoptions' changes how tabs are used when 'list' is set. NOTE: This option is set to 0 when 'compatible' is set.

When on spell checking will be done. See spell. The languages are specified with 'spelllang'.

Pattern to locate the end of a sentence. The following word will be checked to start with a capital letter. If not then it is highlighted with SpellCap hl-SpellCap (unless the word is also badly spelled). When this check is not wanted make this option empty. Only used when 'spell' is set. Be careful with special characters, see option-backslash about including spaces and backslashes. To set this option automatically depending on the language, see set-spc-auto.

Name of the word list file where words are added for the zg and zw commands. It must end in ".{encoding}.add". You need to include the path, otherwise the file is placed in the current directory. The path may include characters from 'isfname', space, comma and '@'.

A comma-separated list of word list names. When the 'spell' option is on spellchecking will be done for these languages. Example:

A comma-separated list of options for spell checking: camel When a word is CamelCased, assume "Cased" is a separate word: every upper-case character in a word that comes after a lower case character indicates the start of a new word.

Methods used for spelling suggestions. Both for the z= command and the spellsuggest() function. This is a comma-separated list of items:

When on, splitting a window will put the new window below the current one. :split

The value of this option determines the scroll behavior when opening, closing or resizing horizontal splits.

When on, splitting a window will put the new window right of the current one. :vsplit

When "on" the commands listed below move the cursor to the first non-blank of the line. When off the cursor is kept in the same column (if possible). This applies to the commands:

• CTRL-D, CTRL-U, CTRL-B, CTRL-F, "G", "H", "M", "L", "gg"
• "d", "<<" and ">>" with a linewise operator
• "%" with a count
• buffer changing commands (CTRL-^, :bnext, :bNext, etc.)
• Ex commands that only has a line number, e.g., ":25" or ":+". In case of buffer changing commands the cursor is placed at the column where it was the last time the buffer was edited. NOTE: This option is set when 'compatible' is set.

When non-empty, this option determines the content of the status line. Also see status-line.

Files with these suffixes get a lower priority when multiple files match a wildcard. See suffixes. Commas can be used to separate the suffixes. Spaces after the comma are ignored. A dot is also seen as the start of a suffix. To avoid a dot or comma being recognized as a separator, precede it with a backslash (see option-backslash about including spaces and backslashes). See 'wildignore' for completely ignoring files. The use of :set+= and :set-= is preferred when adding or removing suffixes from the list. This avoids problems when a future version uses another default.

Comma-separated list of suffixes, which are used when searching for a file for the "gf", "[I", etc. commands. Example:

Use a swapfile for the buffer. This option can be reset when a swapfile is not wanted for a specific buffer. For example, with confidential information that even root must not be able to access. Careful: All text will be in memory: - Don't use this for big files. - Recovery will be impossible! A swapfile will only be present when 'updatecount' is non-zero and 'swapfile' is set. When 'swapfile' is reset, the swap file for the current buffer is immediately deleted. When 'swapfile' is set, and 'updatecount' is non-zero, a swap file is immediately created. Also see swap-file and 'swapsync'. If you want to open a new buffer without creating a swap file for it, use the :noswapfile modifier. See 'directory' for where the swap file is created.

This option controls the behavior when switching between buffers. This option is checked, when

• jumping to errors with the quickfix commands (:cc, :cn, :cp, etc.).
• jumping to a tag using the :stag command.
• opening a file using the CTRL-W_f or CTRL-W_F command.
• jumping to a buffer using a buffer split command (e.g. :sbuffer, :sbnext, or :sbrewind). Possible values (comma-separated list): useopen If included, jump to the first open window in the current tab page that contains the specified buffer (if there is one). Otherwise: Do not examine other windows. usetab Like "useopen", but also consider windows in other tab pages. split If included, split the current window before loading a buffer for a quickfix command that display errors. Otherwise: do not split, use current window (when used in the quickfix window: the previously used window or split if there is no other window). vsplit Just like "split" but split vertically. newtab Like "split", but open a new tab page. Overrules "split" when both are present. uselast If included, jump to the previously used window when jumping to errors with quickfix commands.

Maximum column in which to search for syntax items. In long lines the text after this column is not highlighted and following lines may not be highlighted correctly, because the syntax state is cleared. This helps to avoid very slow redrawing for an XML file that is one long line. Set to zero to remove the limit.

When this option is set, the syntax with this name is loaded, unless syntax highlighting has been switched off with ":syntax off". Otherwise this option does not always reflect the current syntax (the b:current_syntax variable does). This option is most useful in a modeline, for a file which syntax is not automatically recognized. Example, in an IDL file: /* vim: set syntax=idl : * / When a dot appears in the value then this separates two filetype names. Example: /* vim: set syntax=c.doxygen : * / This will use the "c" syntax first, then the "doxygen" syntax. Note that the second one must be prepared to be loaded as an addition, otherwise it will be skipped. More than one dot may appear. To switch off syntax highlighting for the current file, use:

When non-empty, this option determines the content of the tab pages line at the top of the Vim window. When empty Vim will use a default tab pages line. See setting-tabline for more info.

Maximum number of tab pages to be opened by the -p command line argument or the ":tab all" command. tabpage

Number of spaces that a <Tab> in the file counts for. Also see the :retab command, and the 'softtabstop' option.

When searching for a tag (e.g., for the :ta command), Vim can either use a binary search or a linear search in a tags file. Binary searching makes searching for a tag a LOT faster, but a linear search will find more tags if the tags file wasn't properly sorted. Vim normally assumes that your tags files are sorted, or indicate that they are not sorted. Only when this is not the case does the 'tagbsearch' option need to be switched off.

This option specifies how case is handled when searching the tags file: followic Follow the 'ignorecase' option followscs Follow the 'smartcase' and 'ignorecase' options ignore Ignore case match Match case smart Ignore case unless an upper case letter is used NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

This option specifies a function to be used to perform tag searches. The function gets the tag pattern and should return a List of matching tags. See tag-function for an explanation of how to write the function and an example. The value can be the name of a function, a lambda or a Funcref. See option-value-function for more information. This option cannot be set from a modeline or in the sandbox, for security reasons.

If non-zero, tags are significant up to this number of characters.

If on and using a tags file in another directory, file names in that tags file are relative to the directory where the tags file is. NOTE: This option is set to the Vi default value when 'compatible' is set and to the Vim default value when 'compatible' is reset.

Filenames for the tag command, separated by spaces or commas. To include a space or comma in a file name, precede it with backslashes (see option-backslash about including spaces/commas and backslashes). When a file name starts with "./", the '.' is replaced with the path of the current file. But only when the 'd' flag is not included in 'cpoptions'. Environment variables are expanded :set_env. Also see tags-option. "*", "" and other wildcards can be used to search for tags files in a directory tree. See file-searching. E.g., "/lib/ /tags" will find all files named "tags" below "/lib". The filename itself cannot contain wildcards, it is used as-is. E.g., "/lib/** /tags?" will find files called "tags?". The tagfiles() function can be used to get a list of the file names actually used. If Vim was compiled with the +emacs_tags feature, Emacs-style tag files are also supported. They are automatically recognized. The default value becomes "./tags,./TAGS,tags,TAGS", unless case differences are ignored (MS-Windows). emacs-tags The use of :set+= and :set-= is preferred when adding or removing file names from the list. This avoids problems when a future version uses another default.

When on, the tagstack is used normally. When off, a ":tag" or ":tselect" command with an argument will not push the tag onto the tagstack. A following ":tag" without an argument, a ":pop" command or any other command that uses the tagstack will use the unmodified tagstack, but does change the pointer to the active entry. Resetting this option is useful when using a ":tag" command in a mapping which should not change the tagstack.

The terminal is in charge of Bi-directionality of text (as specified by Unicode). The terminal is also expected to do the required shaping that some languages (such as Arabic) require. Setting this option implies that 'rightleft' will not be set when 'arabic' is set and the value of 'arabicshape' will be ignored. Note that setting 'termbidi' has the immediate effect that 'arabicshape' is ignored, but 'rightleft' isn't changed automatically. This option is reset when the GUI is started. For further details see arabic.txt.

When on, uses highlight-guifg and highlight-guibg attributes in the terminal (thus using 24-bit color).

Maximum width of text that is being inserted. A longer line will be broken after white space to get this width. A zero value disables this. 'textwidth' is set to 0 when the 'paste' option is set and restored when 'paste' is reset. When 'textwidth' is zero, 'wrapmargin' may be used. See also 'formatoptions' and ins-textwidth. When 'formatexpr' is set it will be used to break the line. NOTE: This option is set to 0 when 'compatible' is set.

List of file names, separated by commas, that are used to lookup words for thesaurus completion commands i_CTRL-X_CTRL-T. See compl-thesaurus.

This option specifies a function to be used for thesaurus completion with CTRL-X CTRL-T. i_CTRL-X_CTRL-T See compl-thesaurusfunc. The value can be the name of a function, a lambda or a Funcref. See option-value-function for more information.

When on: The tilde command "~" behaves like an operator. NOTE: This option is reset when 'compatible' is set.

(default on)

(default 1000)

When on, the title of the window will be set to the value of 'titlestring' (if it is not empty), or to: filename [+=-] (path) - VIM Where: filename the name of the file being edited - indicates the file cannot be modified, 'ma' off + indicates the file was modified = indicates the file is read-only =+ indicates the file is read-only and modified (path) is the path of the file being edited - VIM the server name v:servername or "VIM" Only works if the terminal supports setting window titles (currently Amiga console, Win32 console, all GUI versions and terminals with a non-empty 't_ts' option - these are Unix xterm and iris-ansi by default, where 't_ts' is taken from the builtin termcap).

Gives the percentage of 'columns' to use for the length of the window title. When the title is longer, only the end of the path name is shown. A '<' character before the path name is used to indicate this. Using a percentage makes this adapt to the width of the window. But it won't work perfectly, because the actual number of characters available also depends on the font used and other things in the title bar. When 'titlelen' is zero the full path is used. Otherwise, values from 1 to 30000 percent can be used. 'titlelen' is also used for the 'titlestring' option.

This option will be used for the window title when exiting Vim if the original title cannot be restored. Only happens if 'title' is on or 'titlestring' is not empty. This option cannot be set from a modeline or in the sandbox, for security reasons.

When this option is not empty, it will be used for the title of the window. This happens only when the 'title' option is on. Only works if the terminal supports setting window titles (currently Amiga console, Win32 console, all GUI versions and terminals with a non-empty 't_ts' option). When Vim was compiled with HAVE_X11 defined, the original title will be restored if possible, see X11.

These two options together determine the behavior when part of a mapped key sequence or keyboard code has been received:

The time in milliseconds that is waited for a key code or mapped key sequence to complete. Also used for CTRL-\ CTRL-N and CTRL-\ CTRL-G when part of a command has been typed. Normally only 'timeoutlen' is used and 'ttimeoutlen' is -1. When a different timeout value for key codes is desired set 'ttimeoutlen' to a non-negative number.

List of directory names for undo files, separated with commas. See 'backupdir' for details of the format. "." means using the directory of the file. The undo file name for "file.txt" is ".file.txt.un~". For other directories the file name is the full path of the edited file, with path separators replaced with "%". When writing: The first directory that exists is used. "." always works, no directories after "." will be used for writing. When reading all entries are tried to find an undo file. The first undo file that exists is used. When it cannot be read an error is given, no further entry is used. See undo-persistence. This option cannot be set from a modeline or in the sandbox, for security reasons.

When on, Vim automatically saves undo history to an undo file when writing a buffer to a file, and restores undo history from the same file on buffer read. The directory where the undo file is stored is specified by 'undodir'. For more information about this feature see undo-persistence. The undo file is not read when 'undoreload' causes the buffer from before a reload to be saved for undo. When 'undofile' is turned off the undo file is NOT deleted. NOTE: This option is reset when 'compatible' is set.

Maximum number of changes that can be undone. Since undo information is kept in memory, higher numbers will cause more memory to be used. Nevertheless, a single change can already use a large amount of memory. Set to 0 for Vi compatibility: One level of undo and "u" undoes itself:

Save the whole buffer for undo when reloading it. This applies to the ":e!" command and reloading for when the buffer changed outside of Vim. FileChangedShell The save only happens when this option is negative or when the number of lines is smaller than the value of this option. Set this option to zero to disable undo for a reload.

After typing this many characters the swap file will be written to disk. When zero, no swap file will be created at all (see chapter on recovery crash-recovery). 'updatecount' is set to zero by starting Vim with the "-n" option, see startup. When editing in readonly mode this option will be initialized to 10000. The swapfile can be disabled per buffer with 'swapfile'. When 'updatecount' is set from zero to non-zero, swap files are created for all buffers that have 'swapfile' set. When 'updatecount' is set to zero, existing swap files are not deleted. Also see 'swapsync'. This option has no meaning in buffers where 'buftype' is "nofile" or "nowrite".

If this many milliseconds nothing is typed the swap file will be written to disk (see crash-recovery). Also used for the CursorHold autocommand event.

A list of the number of spaces that a <Tab> counts for while editing, such as inserting a <Tab> or using <BS>. It "feels" like variable- width <Tab>s are being inserted, while in fact a mixture of spaces and <Tab>s is used. Tab widths are separated with commas, with the final value applying to all subsequent tabs.

A list of the number of spaces that a <Tab> in the file counts for, separated by commas. Each value corresponds to one tab, with the final value applying to all subsequent tabs. For example:

When bigger than zero, Vim will give messages about what it is doing. Currently, these messages are given:

= 1 When the viminfo file is read or written. = 2 When a file is ":source"'ed. = 4 Shell commands. = 5 Every searched tags file and include file. = 8 Files for which a group of autocommands is executed. = 9 Every executed autocommand. = 11 Finding items in a path = 12 Every executed function. = 13 When an exception is thrown, caught, finished, or discarded. = 14 Anything pending in a ":finally" clause. = 15 Every executed Ex command from a script (truncated at 200 characters). = 16 Every executed Ex command.

When not empty all messages are written in a file with this name. When the file exists messages are appended. Writing to the file ends when Vim exits or when 'verbosefile' is made empty. Writes are buffered, thus may not show up for some time. Setting 'verbosefile' to a new value is like making it empty first. The difference with :redir is that verbose messages are not displayed when 'verbosefile' is set. This option cannot be set from a modeline or in the sandbox, for security reasons.

Name of the directory where to store files for :mkview. This option cannot be set from a modeline or in the sandbox, for security reasons.

Changes the effect of the :mkview command. It is a comma-separated list of words. Each word enables saving and restoring something: word save and restore cursor cursor position in file and in window folds manually created folds, opened/closed folds and local fold options options options and mappings local to a window or buffer (not global values for local options) localoptions same as "options" slash backslashes in file names replaced with forward slashes unix with Unix end-of-line format (single <NL>), even when on MS-Windows curdir the window-local directory, if set with :lcd

A comma-separated list of these words: block Allow virtual editing in Visual block mode. insert Allow virtual editing in Insert mode. all Allow virtual editing in all modes. onemore Allow the cursor to move just past the end of the line none When used as the local value, do not allow virtual editing even when the global value is set. When used as the global value, "none" is the same as "". NONE Alternative spelling of "none".

Use a visual bell instead of beeping. The terminal code to display the visual bell is given with 't_vb'. When no beep or flash is wanted, use:

Give a warning message when a shell command is used while the buffer has been changed.

Allow specified keys that move the cursor left/right to move to the previous/next line when the cursor is on the first/last character in the line. Concatenate characters to allow this for these keys: char key mode b <BS> Normal and Visual s <Space> Normal and Visual h "h" Normal and Visual (not recommended) l "l" Normal and Visual (not recommended) < <Left> Normal and Visual > <Right> Normal and Visual ~ "~" Normal [ <Left> Insert and Replace ] <Right> Insert and Replace For example:

Character you have to type to start wildcard expansion in the command-line, as specified with 'wildmode'. More info here: cmdline-completion. The character is not recognized when used inside a macro. See 'wildcharm' for that. Some keys will not work, such as CTRL-C, <CR> and Enter. <Esc> can be used, but hitting it twice in a row will still exit command-line as a failsafe measure. Although 'wc' is a number option, you can set it to a special key:

'wildcharm' works exactly like 'wildchar', except that it is recognized when used inside a macro. You can find "spare" command-line keys suitable for this option by looking at ex-edit-index. Normally you'll never actually type 'wildcharm', just use it in mappings that automatically invoke completion mode, e.g.:

A list of file patterns. A file that matches with one of these patterns is ignored when expanding wildcards, completing file or directory names, and influences the result of expand(), glob() and globpath() unless a flag is passed to disable this. The pattern is used like with :autocmd, see autocmd-patterns. Also see 'suffixes'. Example:

When set case is ignored when completing file names and directories. Has no effect when 'fileignorecase' is set. Does not apply when the shell is used to expand wildcards, which happens when there are special characters.

When 'wildmenu' is on, command-line completion operates in an enhanced mode. On pressing 'wildchar' (usually <Tab>) to invoke completion, the possible matches are shown. When 'wildoptions' contains "pum", then the completion matches are shown in a popup menu. Otherwise they are displayed just above the command line, with the first match highlighted (overwriting the status line, if there is one). Keys that show the previous/next match, such as <Tab> or CTRL-P/CTRL-N, cause the highlight to move to the appropriate match. When 'wildmode' is used, "wildmenu" mode is used where "full" is specified. "longest" and "list" do not start "wildmenu" mode. You can check the current mode with wildmenumode(). If there are more matches than can fit in the line, a ">" is shown on the right and/or a "<" is shown on the left. The status line scrolls as needed. The "wildmenu" mode is abandoned when a key is hit that is not used for selecting a completion. While the "wildmenu" is active, the following keys have special meanings: CTRL-P - go to the previous entry CTRL-N - go to the next entry <CR> - in menu completion, when the cursor is just after a dot: move into a submenu. CTRL-E - end completion, go back to what was there before selecting a match. CTRL-Y - accept the currently selected match and stop completion.

Completion mode that is used for the character specified with 'wildchar'. It is a comma-separated list of up to four parts. Each part specifies what to do for each consecutive use of 'wildchar'. The first part specifies the behavior for the first use of 'wildchar', The second part for the second use, etc.

A list of words that change how cmdline-completion is done. The following values are supported: fuzzy Use fuzzy-matching to find completion matches. When this value is specified, wildcard expansion will not be used for completion. The matches will be sorted by the "best match" rather than alphabetically sorted. This will find more matches than the wildcard expansion. Currently fuzzy matching based completion is not supported for file and directory names and instead wildcard expansion is used. pum Display the completion matches using the popup menu in the same style as the ins-completion-menu. tagfile When using CTRL-D to list matching tags, the kind of tag and the file of the tag is listed. Only one match is displayed per line. Often used tag kinds are: d #define f function

Some GUI versions allow the access to menu entries by using the ALT key in combination with a character that appears underlined in the menu. This conflicts with the use of the ALT key for mappings and entering special characters. This option tells what to do: no Don't use ALT keys for menus. ALT key combinations can be mapped, but there is no automatic handling. This can then be done with the :simalt command. yes ALT key handling is done by the windowing system. ALT key combinations cannot be mapped. menu Using ALT in combination with a character that is a menu shortcut key, will be handled by the windowing system. Other keys can be mapped. If the menu is disabled by excluding 'm' from 'guioptions', the ALT key is never used for the menu. This option is not used for <F10>; on Win32 and with GTK <F10> will select the menu, unless it has been mapped.

Window height used for CTRL-F and CTRL-B when there is only one window and the value is smaller than 'lines' minus one. The screen will scroll 'window' minus two lines, with a minimum of one. When 'window' is equal to 'lines' minus one CTRL-F and CTRL-B scroll in a much smarter way, taking care of wrapping lines. When resizing the Vim window, the value is smaller than 1 or more than or equal to 'lines' it will be set to 'lines' minus 1. Note: Do not confuse this with the height of the Vim window, use 'lines' for that.

Keep the window height when windows are opened or closed and 'equalalways' is set. Also for CTRL-W_=. Set by default for the preview-window and quickfix-window. The height may be changed anyway when running out of room.

Keep the window width when windows are opened or closed and 'equalalways' is set. Also for CTRL-W_=. The width may be changed anyway when running out of room.

Minimal number of lines for the current window. This is not a hard minimum, Vim will use fewer lines if there is not enough room. If the focus goes to a window that is smaller, its size is increased, at the cost of the height of other windows. Set 'winheight' to a small number for normal editing. Set it to 999 to make the current window fill most of the screen. Other windows will be only 'winminheight' high. This has the drawback that ":all" will create only two windows. To avoid "vim -o 1 2 3 4" to create only two windows, set the option after startup is done, using the VimEnter event:

The minimal height of a window, when it's not the current window. This is a hard minimum, windows will never become smaller. When set to zero, windows may be "squashed" to zero lines (i.e. just a status bar) if necessary. They will return to at least one line when they become active (since the cursor has to have somewhere to go.) Use 'winheight' to set the minimal height of the current window. This option is only checked when making a window smaller. Don't use a large number, it will cause errors when opening more than a few windows. A value of 0 to 3 is reasonable.

The minimal width of a window, when it's not the current window. This is a hard minimum, windows will never become smaller. When set to zero, windows may be "squashed" to zero columns (i.e. just a vertical separator) if necessary. They will return to at least one line when they become active (since the cursor has to have somewhere to go.) Use 'winwidth' to set the minimal width of the current window. This option is only checked when making a window smaller. Don't use a large number, it will cause errors when opening more than a few windows. A value of 0 to 12 is reasonable.

Minimal number of columns for the current window. This is not a hard minimum, Vim will use fewer columns if there is not enough room. If the current window is smaller, its size is increased, at the cost of the width of other windows. Set it to 999 to make the current window always fill the screen. Set it to a small number for normal editing. The width is not adjusted after one of the commands to change the width of the current window. 'winwidth' applies to the current window. Use 'winminwidth' to set the minimal width for other windows.

This option changes how text is displayed. It doesn't change the text in the buffer, see 'textwidth' for that. When on, lines longer than the width of the window will wrap and displaying continues on the next line. When off lines will not wrap and only part of long lines will be displayed. When the cursor is moved to a part that is not shown, the screen will scroll horizontally. The line will be broken in the middle of a word if necessary. See 'linebreak' to get the break at a word boundary. To make scrolling horizontally a bit more useful, try this:

Number of characters from the right window border where wrapping starts. When typing text beyond this limit, an <EOL> will be inserted and inserting continues on the next line. Options that add a margin, such as 'number' and 'foldcolumn', cause the text width to be further reduced. This is Vi compatible. When 'textwidth' is non-zero, this option is not used. This option is set to 0 when 'paste' is set and restored when 'paste' is reset. See also 'formatoptions' and ins-textwidth.

Searches wrap around the end of the file. Also applies to ]s and [s, searching for spelling mistakes.

Allows writing files. When not set, writing a file is not allowed. Can be used for a view-only mode, where modifications to the text are still allowed. Can be reset with the -m or -M command line argument. Filtering text is still possible, even though this requires writing a temporary file.

Allows writing to any file with no need for "!" override.

Make a backup before overwriting a file. The backup is removed after the file was successfully written, unless the 'backup' option is also on. WARNING: Switching this option off means that when Vim fails to write your buffer correctly and then, for whatever reason, Vim exits, you lose both the original file and what you were writing. Only reset this option if your file system is almost full and it makes the write fail (and make sure not to exit Vim until the write was successful). See backup-table for another explanation. When the 'backupskip' pattern matches, a backup is not made anyway. Depending on 'backupcopy' the backup is a new file or the original file renamed (and a new file is written). NOTE: This option is set to the default value when 'compatible' is set.

The number of milliseconds to wait for each character sent to the screen. When non-zero, characters are sent to the terminal one by one. For debugging purposes.

Shorthand for buffers

Buffer local variables (buffers or b)

Shorthand for environment

Environment variables (environment or e)

Shorthand for globals

Global options (globalOptions or go)

Global variables (globals or g)

Shorthand for globalOptions

Shorthand for localOptions

Local options (localOptions or lo)

Shorthand for options

Options (options or o)

Shorthand for register

Register (register or r)

Shorthand for tabpages

Tabpage local variables (tabpages or t)

Shorthand for vim

Vim variables (vim or v)

Shorthand for windows

Window local variables (windows or w)

Make an assertion that actual and expected are equal, deeply. If not deeply equal, then throw.

Define an autocmd

Emit an autocmd in a buffer

Emit an autocmd in all buffers

Create an autocmd group and define/remove autocmds in that group.

List defined autocmds

Remove an autocmd

Return the last portion of a path. Trailing directory separators are ignored, and optional suffix is removed.

Call multiple denops functions sequentially without RPC overhead

Call multiple denops functions sequentially without RPC overhead and return values

Create a promise which will be rejected with DeadlineError when a given delay is exceeded.

Return the directory path of a path.

Echo message as like echo on Vim script.

Ensures that the given value satisfies the provided predicate.

Deep equality comparison used in assertions

Execute multi-lined Vim script directly

Return the absolute value of {expr}. When {expr} evaluates to a Float abs() returns a Float. When {expr} can be converted to a Number abs() returns a Number. Otherwise abs() gives an error message and returns -1. Examples:

Return the arc cosine of {expr} measured in radians, as a Float in the range of [0, pi]. {expr} must evaluate to a Float or a Number in the range [-1, 1]. Otherwise acos() returns "nan". Examples:

Append the item {expr} to List or Blob {object}. Returns the resulting List or Blob. Examples:

Bitwise AND on the two arguments. The arguments are converted to a number. A List, Dict or Float argument causes an error. Also see or() and xor(). Example:

When {text} is a List: Append each item of the List as a text line below line {lnum} in the current buffer. Otherwise append {text} as one text line below line {lnum} in the current buffer. Any type of item is accepted and converted to a String. {lnum} can be zero to insert a line before the first one. {lnum} is used like with getline(). Returns 1 for failure ({lnum} out of range or out of memory), 0 for success. When {text} is an empty list zero is returned, no matter the value of {lnum}. In Vim9 script an invalid argument or negative number results in an error. Example:

Like append() but append the text in buffer {buf}.

The result is the number of files in the argument list. See arglist. If {winid} is not supplied, the argument list of the current window is used. If {winid} is -1, the global argument list is used. Otherwise {winid} specifies the window of which the argument list is used: either the window number or the window ID. Returns -1 if the {winid} argument is invalid.

The result is the current index in the argument list. 0 is the first file. argc() - 1 is the last one. See arglist.

Return the argument list ID. This is a number which identifies the argument list being used. Zero is used for the global argument list. See arglist. Returns -1 if the arguments are invalid.

The result is the **{nr}**th file in the argument list. See arglist. "argv(0)" is the first one. Example:

Return the arc sine of {expr} measured in radians, as a Float in the range of [-pi/2, pi/2]. {expr} must evaluate to a Float or a Number in the range [-1, 1]. Returns "nan" if {expr} is outside the range [-1, 1]. Returns 0.0 if {expr} is not a Float or a Number. Examples:

Assert if x is Position by raising an AssertError when it's not.

Assert if x is ScreenPos by raising an AssertError when it's not.

Return the principal value of the arc tangent of {expr}, in the range [-pi/2, +pi/2] radians, as a Float. {expr} must evaluate to a Float or a Number. Returns 0.0 if {expr} is not a Float or a Number. Examples:

Return the arc tangent of {expr1} / {expr2}, measured in radians, as a Float in the range [-pi, pi]. {expr1} and {expr2} must evaluate to a Float or a Number. Returns 0.0 if {expr1} or {expr2} is not a Float or a Number. Examples:

Return a List containing the number value of each byte in Blob {blob}. Examples:

Put up a file requester. This only works when "has("browse")" returns TRUE (only in some GUI versions). The input fields are: {save} when TRUE, select file to write {title} title for the requester {initdir} directory to start browsing in {default} default file name An empty string is returned when the "Cancel" button is hit, something went wrong, or browsing is not possible.

Put up a directory requester. This only works when "has("browse")" returns TRUE (only in some GUI versions). On systems where a directory browser is not supported a file browser is used. In that case: select a file in the directory to be used. The input fields are: {title} title for the requester {initdir} directory to start browsing in When the "Cancel" button is hit, something went wrong, or browsing is not possible, an empty string is returned.

Add a buffer to the buffer list with name {name} (must be a String). If a buffer for file {name} already exists, return that buffer number. Otherwise return the buffer number of the newly created buffer. When {name} is an empty string then a new buffer is always created. The buffer will not have 'buflisted' set and not be loaded yet. To add some text to the buffer use this:

The result is a Number, which is TRUE if a buffer called {buf} exists. If the {buf} argument is a number, buffer numbers are used. Number zero is the alternate buffer for the current window.

The result is a Number, which is TRUE if a buffer called {buf} exists and is listed (has the 'buflisted' option set). The {buf} argument is used like with bufexists().

Ensure the buffer {buf} is loaded. When the buffer name refers to an existing file then the file is read. Otherwise the buffer will be empty. If the buffer was already loaded then there is no change. If the buffer is not related to a file then no file is read (e.g., when 'buftype' is "nofile"). If there is an existing swap file for the file of the buffer, there will be no dialog, the buffer will be loaded anyway. The {buf} argument is used like with bufexists().

The result is a Number, which is TRUE if a buffer called {buf} exists and is loaded (shown in a window or hidden). The {buf} argument is used like with bufexists().

The result is the name of a buffer. Mostly as it is displayed by the :ls command, but not using special names such as "[No Name]". If {buf} is omitted the current buffer is used. If {buf} is a Number, that buffer number's name is given. Number zero is the alternate buffer for the current window. If {buf} is a String, it is used as a file-pattern to match with the buffer names. This is always done like 'magic' is set and 'cpoptions' is empty. When there is more than one match an empty string is returned. "" or "%" can be used for the current buffer, "#" for the alternate buffer. A full match is preferred, otherwise a match at the start, end or middle of the buffer name is accepted. If you only want a full match then put "^" at the start and "$" at the end of the pattern. Listed buffers are found first. If there is a single match with a listed buffer, that one is returned. Next unlisted buffers are searched for. If the {buf} is a String, but you want to use it as a buffer number, force it to be a Number by adding zero to it:

The result is the number of a buffer, as it is displayed by the :ls command. For the use of {buf}, see bufname() above.

The result is a Number, which is the window-ID of the first window associated with buffer {buf}. For the use of {buf}, see bufname() above. If buffer {buf} doesn't exist or there is no such window, -1 is returned. Example:

Like bufwinid() but return the window number instead of the window-ID. If buffer {buf} doesn't exist or there is no such window, -1 is returned. Example:

Return the line number that contains the character at byte count {byte} in the current buffer. This includes the end-of-line character, depending on the 'fileformat' option for the current buffer. The first character has byte count one. Also see line2byte(), go and :goto.

Return byte index of the {nr}'th character in the String {expr}. Use zero for the first character, it then returns zero. If there are no multibyte characters the returned value is equal to {nr}. Composing characters are not counted separately, their byte length is added to the preceding base character. See byteidxcomp() below for counting composing characters separately. When {utf16} is present and TRUE, {nr} is used as the UTF-16 index in the String {expr} instead of as the character index. The UTF-16 index is the index in the string when it is encoded with 16-bit words. If the specified UTF-16 index is in the middle of a character (e.g. in a 4-byte character), then the byte index of the first byte in the character is returned. Refer to string-offset-encoding for more information. Example :

Like byteidx(), except that a composing character is counted as a separate character. Example:

Call function {func} with the items in List {arglist} as arguments. {func} can either be a Funcref or the name of a function. a:firstline and a:lastline are set to the cursor line. Returns the return value of the called function. {dict} is for functions with the "dict" attribute. It will be used to set the local variable "self". Dictionary-function

Return the smallest integral value greater than or equal to {expr} as a Float (round up). {expr} must evaluate to a Float or a Number. Examples:

Return the number of the most recent change. This is the same number as what is displayed with :undolist and can be used with the :undo command. When a change was made it is the number of that change. After redo it is the number of the redone change. After undo it is one less than the number of the undone change. Returns 0 if the undo list is empty.

Return Number value of the first char in {string}. Examples:

Return the character class of the first character in {string}. The character class is one of: 0 blank 1 punctuation 2 word character 3 emoji other specific Unicode class The class is used in patterns and word motions. Returns 0 if {string} is not a String.

Same as col() but returns the character index of the column position given with {expr} instead of the byte position.

Return the character index of the byte at {idx} in {string}. The index of the first character is zero. If there are no multibyte characters the returned value is equal to {idx}.

Change the current working directory to {dir}. The scope of the directory change depends on the directory of the current window: - If the current window has a window-local directory (:lcd), then changes the window local directory. - Otherwise, if the current tabpage has a local directory (:tcd) then changes the tabpage local directory. - Otherwise, changes the global directory. {dir} must be a String. If successful, returns the previous working directory. Pass this to another chdir() to restore the directory. On failure, returns an empty string.

Get the amount of indent for line {lnum} according the C indenting rules, as with 'cindent'. The indent is counted in spaces, the value of 'tabstop' is relevant. {lnum} is used just like in getline(). When {lnum} is invalid -1 is returned. See C-indenting.

Clears all matches previously defined for the current window by matchadd() and the :match commands. If {win} is specified, use the window with this number or window ID instead of the current window.

The result is a Number, which is the byte index of the column position given with {expr}. The accepted positions are: . the cursor position $ the end of the cursor line (the result is the number of bytes in the cursor line plus one) 'x position of mark x (if the mark is not set, 0 is returned) v In Visual mode: the start of the Visual area (the cursor is the end). When not in Visual mode returns the cursor position. Differs from '< in that it's updated right away. Additionally {expr} can be [lnum, col]: a List with the line and column number. Most useful when the column is "$", to get the last column of a specific line. When "lnum" or "col" is out of range then col() returns zero. With the optional {winid} argument the values are obtained for that window instead of the current window. To get the line number use line(). To get both use getpos(). For the screen column position use virtcol(). For the character position use charcol(). Note that only marks in the current file can be used. Examples:

Set the matches for Insert mode completion. Can only be used in Insert mode. You need to use a mapping with CTRL-R = (see i_CTRL-R). It does not work after CTRL-O or with an expression mapping. {startcol} is the byte offset in the line where the completed text start. The text up to the cursor is the original text that will be replaced by the matches. Use col('.') for an empty string. "col('.') - 1" will replace one character by a match. {matches} must be a List. Each List item is one match. See complete-items for the kind of items that are possible. "longest" in 'completeopt' is ignored. Note that the after calling this function you need to avoid inserting anything that would cause completion to stop. The match can be selected with CTRL-N and CTRL-P as usual with Insert mode completion. The popup menu will appear if specified, see ins-completion-menu. Example:

Add {expr} to the list of matches. Only to be used by the function specified with the 'completefunc' option. Returns 0 for failure (empty string or out of memory), 1 when the match was added, 2 when the match was already in the list. See complete-functions for an explanation of {expr}. It is the same as one item in the list that 'omnifunc' would return.

Check for a key typed while looking for completion matches. This is to be used when looking for matches takes some time. Returns TRUE when searching for matches is to be aborted, zero otherwise. Only to be used by the function specified with the 'completefunc' option.

Returns a Dictionary with information about Insert mode completion. See ins-completion. The items are: mode Current completion mode name string. See complete_info_mode for the values. pum_visible TRUE if popup menu is visible. See pumvisible(). items List of completion matches. Each item is a dictionary containing the entries "word", "abbr", "menu", "kind", "info" and "user_data". See complete-items. selected Selected item index. First index is zero. Index is -1 if no item is selected (showing typed text only, or the last completion after no item is selected when using the <Up> or <Down> keys) inserted Inserted string. [NOT IMPLEMENTED YET]

confirm() offers the user a dialog, from which a choice can be made. It returns the number of the choice. For the first choice this is 1. Note: confirm() is only supported when compiled with dialog support, see +dialog_con and +dialog_gui.

Make a copy of {expr}. For Numbers and Strings this isn't different from using {expr} directly. When {expr} is a List a shallow copy is created. This means that the original List can be changed without changing the copy, and vice versa. But the items are identical, thus changing an item changes the contents of both Lists. A Dictionary is copied in a similar way as a List. Also see deepcopy(). Can also be used as a method:

Return the cosine of {expr}, measured in radians, as a Float. {expr} must evaluate to a Float or a Number. Returns 0.0 if {expr} is not a Float or a Number. Examples:

Return the hyperbolic cosine of {expr} as a Float in the range [1, inf]. {expr} must evaluate to a Float or a Number. Returns 0.0 if {expr} is not a Float or a Number. Examples:

Return the number of times an item with value {expr} appears in String, List or Dictionary {comp}.

Positions the cursor at the column (byte count) {col} in the line {lnum}. The first column is one.

Specifically used to interrupt a program being debugged. It will cause process {pid} to get a SIGTRAP. Behavior for other processes is undefined. See terminal-debugger. only available on MS-Windows

Make a copy of {expr}. For Numbers and Strings this isn't different from using {expr} directly. When {expr} is a List a full copy is created. This means that the original List can be changed without changing the copy, and vice versa. When an item is a List or Dictionary, a copy for it is made, recursively. Thus changing an item in the copy does not change the contents of the original List. A Dictionary is copied in a similar way as a List.

Without {flags} or with {flags} empty: Deletes the file by the name {fname}.

Delete lines {first} to {last} (inclusive) from buffer {buf}. If {last} is omitted then delete line {first} only. On success 0 is returned, on failure 1 is returned.

Returns TRUE when autocommands are being executed and the FileType event has been triggered at least once. Can be used to avoid triggering the FileType event again in the scripts that detect the file type. FileType Returns FALSE when :setf FALLBACK was used. When editing another file, the counter is reset, thus this really checks if the FileType event has been triggered for the current buffer. This allows an autocommand that starts editing another buffer to set 'filetype' and load a syntax file.

Returns the number of filler lines above line {lnum}. These are the lines that were inserted at this point in another diff'ed window. These filler lines are shown in the display but don't exist in the buffer. {lnum} is used like with getline(). Thus "." is the current line, "'m" mark m, etc. Returns 0 if the current window is not in diff mode.

Returns the highlight ID for diff mode at line {lnum} column {col} (byte index). When the current line does not have a diff change zero is returned. {lnum} is used like with getline(). Thus "." is the current line, "'m" mark m, etc. {col} is 1 for the leftmost column, {lnum} is 1 for the first line. The highlight ID can be used with synIDattr() to obtain syntax information about the highlighting.

Return the digraph of {chars}. This should be a string with exactly two characters. If {chars} are not just two characters, or the digraph of {chars} does not exist, an error is given and an empty string is returned.

Return a list of digraphs. If the {listall} argument is given and it is TRUE, return all digraphs, including the default digraphs. Otherwise, return only user-defined digraphs.

Add digraph {chars} to the list. {chars} must be a string with two characters. {digraph} is a string with one UTF-8 encoded character. Be careful, composing characters are NOT ignored. This function is similar to :digraphs command, but useful to add digraphs start with a white space.

Similar to digraph_set() but this function can add multiple digraphs at once. {digraphlist} is a list composed of lists, where each list contains two strings with {chars} and {digraph} as in digraph_set(). Example:

Return the Number 1 if {expr} is empty, zero otherwise.

• A List or Dictionary is empty when it does not have any items.
• A String is empty when its length is zero.
• A Number and Float are empty when their value is zero.
• v:false, v:none and v:null are empty, v:true is not.
• A Job is empty when it failed to start.
• A Channel is empty when it is closed.
• A Blob is empty when its length is zero.

Return all of environment variables as dictionary. You can check if an environment variable exists like this:

Escape the characters in {chars} that occur in {string} with a backslash. Example:

Evaluate {string} and return the result. Especially useful to turn the result of string() back into the original value. This works for Numbers, Floats, Strings, Blobs and composites of them. Also works for Funcrefs that refer to existing functions.

Returns 1 when inside an event handler. That is that Vim got interrupted while waiting for the user to type a character, e.g., when dropping a file on Vim. This means interactive commands cannot be used. Otherwise zero is returned.

This function checks if an executable with the name {expr} exists. {expr} must be the name of the program without any arguments. executable() uses the value of $PATH and/or the normal searchpath for programs. On MS-Windows the ".exe", ".bat", etc. can optionally be included. Then the extensions in $PATHEXT are tried. Thus if "foo.exe" does not exist, "foo.exe.bat" can be found. If $PATHEXT is not set then ".com;.exe;.bat;.cmd" is used. A dot by itself can be used in $PATHEXT to try using the name without an extension. When 'shell' looks like a Unix shell, then the name is also tried without adding an extension. On MS-Windows it only checks if the file exists and is not a directory, not if it's really executable. On MS-Windows an executable in the same directory as Vim is normally found. Since this directory is added to $PATH it should also work to execute it win32-PATH. This can be disabled by setting the $NoDefaultCurrentDirectoryInExePath environment variable. The result is a Number: 1 exists 0 does not exist -1 not implemented on this system exepath() can be used to get the full path of an executable.

Execute an Ex command or commands and return the output as a string. {command} can be a string or a List. In case of a List the lines are executed one by one. This is more or less equivalent to:

If {expr} is an executable and is either an absolute path, a relative path or found in $PATH, return the full path. Note that the current directory is used when {expr} starts with "./", which may be a problem for Vim:

The result is a Number, which is TRUE if {expr} is defined, zero otherwise.

Return the exponential of {expr} as a Float in the range [0, inf]. {expr} must evaluate to a Float or a Number. Returns 0.0 if {expr} is not a Float or a Number. Examples:

Expand wildcards and the following special keywords in {string}. 'wildignorecase' applies.

Expand special items in String {string} like what is done for an Ex command such as :edit. This expands special keywords, like with expand(), and environment variables, anywhere in {string}. "~user" and "~/path" are only expanded at the start.

{expr1} and {expr2} must be both Lists or both Dictionaries.

Like extend() but instead of adding items to {expr1} a new List or Dictionary is created and returned. {expr1} remains unchanged.

Characters in {string} are queued for processing as if they come from a mapping or were typed by the user.

The result is a Number, which is TRUE when a file with the name {file} exists, and can be read. If {file} doesn't exist, or is a directory, the result is FALSE. {file} is any expression, which is used as a String. If you don't care about the file being readable you can use glob(). {file} is used as-is, you may want to expand wildcards first:

The result is a Number, which is 1 when a file with the name {file} exists, and can be written. If {file} doesn't exist, or is not writable, the result is 0. If {file} is a directory, and we can write to it, the result is 2.

{expr1} must be a List, String, Blob or Dictionary. For each item in {expr1} evaluate {expr2} and when the result is zero or false remove the item from the List or Dictionary. Similarly for each byte in a Blob and each character in a String.

Find directory {name} in {path}. Supports both downwards and upwards recursive directory searches. See file-searching for the syntax of {path}.

Just like finddir(), but find a file instead of a directory. Uses 'suffixesadd'. Example:

Flatten {list} up to {maxdepth} levels. Without {maxdepth} the result is a List without nesting, as if {maxdepth} is a very large number. The {list} is changed in place, use flattennew() if you do not want that. In Vim9 script flatten() cannot be used, you must always use flattennew().

Like flatten() but first make a copy of {list}.

Convert {expr} to a Number by omitting the part after the decimal point. {expr} must evaluate to a Float or a Number. Returns 0 if {expr} is not a Float or a Number. When the value of {expr} is out of range for a Number the result is truncated to 0x7fffffff or -0x7fffffff (or when 64-bit Number support is enabled, 0x7fffffffffffffff or -0x7fffffffffffffff). NaN results in -0x80000000 (or when 64-bit Number support is enabled, -0x8000000000000000). Examples:

Return the largest integral value less than or equal to {expr} as a Float (round down). {expr} must evaluate to a Float or a Number. Returns 0.0 if {expr} is not a Float or a Number. Examples:

Return the remainder of {expr1} / {expr2}, even if the division is not representable. Returns {expr1} - i * {expr2} for some integer i such that if {expr2} is non-zero, the result has the same sign as {expr1} and magnitude less than the magnitude of {expr2}. If {expr2} is zero, the value returned is zero. The value returned is a Float. {expr1} and {expr2} must evaluate to a Float or a Number. Returns 0.0 if {expr1} or {expr2} is not a Float or a Number. Examples:

Escape {string} for use as file name command argument. All characters that have a special meaning, such as '%' and '|' are escaped with a backslash. For most systems the characters escaped are " \t\n*?[{`$\\%#'\"|!<". For systems where a backslash appears in a filename, it depends on the value of 'isfname'. A leading '+' and '>' is also escaped (special after :edit and :write). And a "-" by itself (special after :cd). Returns an empty string on error. Example:

Modify file name {fname} according to {mods}. {mods} is a string of characters like it is used for file names on the command line. See filename-modifiers. Example:

The result is a Number. If the line {lnum} is in a closed fold, the result is the number of the first line in that fold. If the line {lnum} is not in a closed fold, -1 is returned. {lnum} is used like with getline(). Thus "." is the current line, "'m" mark m, etc.

The result is a Number. If the line {lnum} is in a closed fold, the result is the number of the last line in that fold. If the line {lnum} is not in a closed fold, -1 is returned. {lnum} is used like with getline(). Thus "." is the current line, "'m" mark m, etc.

The result is a Number, which is the foldlevel of line {lnum} in the current buffer. For nested folds the deepest level is returned. If there is no fold at line {lnum}, zero is returned. It doesn't matter if the folds are open or closed. When used while updating folds (from 'foldexpr') -1 is returned for lines where folds are still to be updated and the foldlevel is unknown. As a special case the level of the previous line is usually available. {lnum} is used like with getline(). Thus "." is the current line, "'m" mark m, etc.

Returns a String, to be displayed for a closed fold. This is the default function used for the 'foldtext' option and should only be called from evaluating 'foldtext'. It uses the v:foldstart, v:foldend and v:folddashes variables. The returned string looks like this:

Returns the text that is displayed for the closed fold at line {lnum}. Evaluates 'foldtext' in the appropriate context. When there is no closed fold at {lnum} an empty string is returned. {lnum} is used like with getline(). Thus "." is the current line, "'m" mark m, etc. Useful when exporting folded text, e.g., to HTML. not available when compiled without the +folding feature

Get the full command name from a short abbreviated command name; see 20.2 for details on command abbreviations.

Just like function(), but the returned Funcref will lookup the function by reference, not by name. This matters when the function {name} is redefined later.

Return a Funcref variable that refers to function {name}. {name} can be the name of a user defined function or an internal function.

Cleanup unused Lists, Dictionaries, Channels and Jobs that have circular references.

Get item {idx} from List {list}. When this item is not available return {default}. Return zero when {default} is omitted. Preferably used as a method:

Get information about buffers as a List of Dictionaries.

Return a List with the lines starting from {lnum} to {end} (inclusive) in the buffer {buf}. If {end} is omitted, a List with only the line {lnum} is returned. See getbufoneline() for only getting the line.

Just like getbufline() but only get one line and return it as a string.

The result is the value of option or local buffer variable {varname} in buffer {buf}. Note that the name without "b:" must be used. The {varname} argument is a string. When {varname} is empty returns a Dictionary with all the buffer-local variables. When {varname} is equal to "&" returns a Dictionary with all the buffer-local options. Otherwise, when {varname} starts with "&" returns the value of a buffer-local option. This also works for a global or buffer-local option, but it doesn't work for a global variable, window-local variable or window-local option. For the use of {buf}, see bufname() above. When the buffer or variable doesn't exist {def} or an empty string is returned, there is no error message. Examples:

Returns a List of cell widths of character ranges overridden by setcellwidths(). The format is equal to the argument of setcellwidths(). If no character ranges have their cell widths overridden, an empty List is returned.

Returns the changelist for the buffer {buf}. For the use of {buf}, see bufname() above. If buffer {buf} doesn't exist, an empty list is returned.

Get a single character from the user or input stream. If [expr] is omitted, wait until a character is available. If [expr] is 0, only get a character when one is available. Return zero otherwise. If [expr] is 1, only check if a character is available, it is not consumed. Return zero if no character available. If you prefer always getting a string use getcharstr().

The result is a Number which is the state of the modifiers for the last obtained character with getchar() or in another way. These values are added together: 2 shift 4 control 8 alt (meta) 16 meta (when it's different from ALT) 32 mouse double click 64 mouse triple click 96 mouse quadruple click (== 32 + 64) 128 command (Macintosh only) Only the modifiers that have not been included in the character itself are obtained. Thus Shift-a results in "A" without a modifier. Returns 0 if no modifiers are used.

Get the position for String {expr}. Same as getpos() but the column number in the returned List is a character index instead of a byte index. If getpos() returns a very large column number, equal to v:maxcol, then getcharpos() will return the character index of the last character.

Return the current character search information as a {dict} with the following entries:

Get a single character from the user or input stream as a string. If [expr] is omitted, wait until a character is available. If [expr] is 0 or false, only get a character when one is available. Return an empty string otherwise. If [expr] is 1 or true, only check if a character is available, it is not consumed. Return an empty string if no character is available. Otherwise this works like getchar(), except that a number result is converted to a string.

Return the type of the current command-line completion. Only works when the command line is being edited, thus requires use of c_CTRL-\_e or c_CTRL-R_=. See :command-completion for the return string. Also see getcmdtype(), setcmdpos(), getcmdline() and setcmdline(). Returns an empty string when completion is not defined.

Return the current command-line. Only works when the command line is being edited, thus requires use of c_CTRL-\_e or c_CTRL-R_=. Example:

Return the position of the cursor in the command line as a byte count. The first column is 1. Only works when editing the command line, thus requires use of c_CTRL-\_e or c_CTRL-R_= or an expression mapping. Returns 0 otherwise. Also see getcmdtype(), setcmdpos(), getcmdline() and setcmdline().

Return the screen position of the cursor in the command line as a byte count. The first column is 1. Instead of getcmdpos(), it adds the prompt position. Only works when editing the command line, thus requires use of c_CTRL-\_e or c_CTRL-R_= or an expression mapping. Returns 0 otherwise. Also see getcmdpos(), setcmdpos(), getcmdline() and setcmdline().

Return the current command-line type. Possible return values are: : normal Ex command > debug mode command debug-mode / forward search command ? backward search command @ input() command - :insert or :append command = i_CTRL-R_= Only works when editing the command line, thus requires use of c_CTRL-\_e or c_CTRL-R_= or an expression mapping. Returns an empty string otherwise. Also see getcmdpos(), setcmdpos() and getcmdline().

Return the current command-line-window type. Possible return values are the same as getcmdtype(). Returns an empty string when not in the command-line window.

Return a list of command-line completion matches. The String {type} argument specifies what for. The following completion types are supported:

Get the position of the cursor. This is like getpos('.'), but includes an extra "curswant" item in the list: [0, lnum, col, off, curswant] The "curswant" number is the preferred column when moving the cursor vertically. After $ command it will be a very large number equal to v:maxcol. Also see getcursorcharpos() and getpos(). The first "bufnum" item is always zero. The byte position of the cursor is returned in 'col'. To get the character position, use getcursorcharpos().

Same as getcurpos() but the column number in the returned List is a character index instead of a byte index.

The result is a String, which is the name of the current working directory. 'autochdir' is ignored.

Return the value of environment variable {name}. The {name} argument is a string, without a leading '$'. Example:

Without an argument returns the name of the normal font being used. Like what is used for the Normal highlight group hl-Normal. With an argument a check is done whether String {name} is a valid font name. If not then an empty string is returned. Otherwise the actual font name is returned, or {name} if the GUI does not support obtaining the real name. Only works when the GUI is running, thus not in your vimrc or gvimrc file. Use the GUIEnter autocommand to use this function just after the GUI has started. Note that the GTK GUI accepts any font name, thus checking for a valid name does not work.

The result is a String, which is the read, write, and execute permissions of the given file {fname}. If {fname} does not exist or its directory cannot be read, an empty string is returned. The result is of the form "rwxrwxrwx", where each group of "rwx" flags represent, in turn, the permissions of the owner of the file, the group the file belongs to, and other users. If a user does not have a given permission the flag for this is replaced with the string "-". Examples:

The result is a Number, which is the size in bytes of the given file {fname}. If {fname} is a directory, 0 is returned. If the file {fname} can't be found, -1 is returned. If the size of {fname} is too big to fit in a Number then -2 is returned.

The result is a Number, which is the last modification time of the given file {fname}. The value is measured as seconds since 1st Jan 1970, and may be passed to strftime(). See also localtime() and strftime(). If the file {fname} can't be found -1 is returned.

The result is a String, which is a description of the kind of file of the given file {fname}. If {fname} does not exist an empty string is returned. Here is a table over different kinds of files and their results: Normal file "file" Directory "dir" Symbolic link "link" Block device "bdev" Character device "cdev" Socket "socket" FIFO "fifo" All other "other" Example:

Returns the jumplist for the specified window.

Without {end} the result is a String, which is line {lnum} from the current buffer. Example:

Returns a List with all the entries in the location list for window {nr}. {nr} can be the window number or the window-ID. When {nr} is zero the current window is used.

Without the {buf} argument returns a List with information about all the global marks. mark

Returns a List with all matches previously defined for the current window by matchadd() and the :match commands. getmatches() is useful in combination with setmatches(), as setmatches() can restore a list of matches saved by getmatches(). If {win} is specified, use the window with this number or window ID instead of the current window. If {win} is invalid, an empty list is returned. Example:

Returns a Dictionary with the last known position of the mouse. This can be used in a mapping for a mouse click or in a filter of a popup window. The items are: screenrow screen row screencol screen column winid Window ID of the click winrow row inside "winid" wincol column inside "winid" line text line inside "winid" column text column inside "winid" coladd offset (in screen columns) from the start of the clicked char All numbers are 1-based.

Return a Number which is the process ID of the Vim process. On Unix and MS-Windows this is a unique number, until Vim exits.

Get the position for String {expr}. For possible values of {expr} see line(). For getting the cursor position see getcurpos(). The result is a List with four numbers: [bufnum, lnum, col, off] "bufnum" is zero, unless a mark like '0 or 'A is used, then it is the buffer number of the mark. "lnum" and "col" are the position in the buffer. The first column is 1. The "off" number is zero, unless 'virtualedit' is used. Then it is the offset in screen columns from the start of the character. E.g., a position within a <Tab> or after the last character. Note that for '< and '> Visual mode matters: when it is "V" (visual line mode) the column of '< is zero and the column of '> is a large number equal to v:maxcol. The column number in the returned List is the byte position within the line. To get the character position in the line, use getcharpos(). A very large column number equal to v:maxcol can be returned, in which case it means "after the end of the line". If {expr} is invalid, returns a list with all zeros. This can be used to save and restore the position of a mark:

Returns a List with all the current quickfix errors. Each list item is a dictionary with these entries: bufnr number of buffer that has the file name, use bufname() to get the name module module name lnum line number in the buffer (first line is 1) end_lnum end of line number if the item is multiline col column number (first column is 1) end_col end of column number if the item has range vcol TRUE: "col" is visual column FALSE: "col" is byte index nr error number pattern search pattern used to locate the error text description of the error type type of the error, 'E', '1', etc. valid TRUE: recognized error message user_data custom data associated with the item, can be any type.

The result is a String, which is the contents of register {regname}. Example:

Returns detailed information about register {regname} as a Dictionary with the following entries: regcontents List of lines contained in register {regname}, like getreg({regname}, 1, 1). regtype the type of register {regname}, as in getregtype(). isunnamed Boolean flag, v:true if this register is currently pointed to by the unnamed register. points_to for the unnamed register, gives the single letter name of the register currently pointed to (see quotequote). For example, after deleting a line with dd, this field will be "1", which is the register that got the deleted text.

The result is a String, which is type of register {regname}. The value will be one of: "v" for characterwise text "V" for linewise text "<CTRL-V>{width}" for blockwise-visual text "" for an empty or unknown register <CTRL-V> is one character with value 0x16. The {regname} argument is a string. If {regname} is "", the unnamed register '"' is used. If {regname} is not specified, v:register is used. In Vim9-script {regname} must be one character.

Returns a List with information about all the sourced Vim scripts in the order they were sourced, like what :scriptnames shows.

If {tabnr} is not specified, then information about all the tab pages is returned as a List. Each List item is a Dictionary. Otherwise, {tabnr} specifies the tab page number and information about that one is returned. If the tab page does not exist an empty List is returned.

Get the value of a tab-local variable {varname} in tab page {tabnr}. t:var Tabs are numbered starting with one. The {varname} argument is a string. When {varname} is empty a dictionary with all tab-local variables is returned. Note that the name without "t:" must be used. When the tab or variable doesn't exist {def} or an empty string is returned, there is no error message.

Get the value of window-local variable {varname} in window {winnr} in tab page {tabnr}. The {varname} argument is a string. When {varname} is empty a dictionary with all window-local variables is returned. When {varname} is equal to "&" get the values of all window-local options in a Dictionary. Otherwise, when {varname} starts with "&" get the value of a window-local option. Note that {varname} must be the name without "w:". Tabs are numbered starting with one. For the current tabpage use getwinvar(). {winnr} can be the window number or the window-ID. When {winnr} is zero the current window is used. This also works for a global option, buffer-local option and window-local option, but it doesn't work for a global variable or buffer-local variable. When the tab, window or variable doesn't exist {def} or an empty string is returned, there is no error message. Examples:

The result is a Dict, which is the tag stack of window {winnr}. {winnr} can be the window number or the window-ID. When {winnr} is not specified, the current window is used. When window {winnr} doesn't exist, an empty Dict is returned.

Translate String {text} if possible. This is mainly for use in the distributed Vim scripts. When generating message translations the {text} is extracted by xgettext, the translator can add the translated message in the .po file and Vim will lookup the translation when gettext() is called. For {text} double quoted strings are preferred, because xgettext does not understand escaping in single quoted strings.

Returns information about windows as a List with Dictionaries.

The result is a List with two numbers, the result of getwinposx() and getwinposy() combined: [x-pos, y-pos] {timeout} can be used to specify how long to wait in msec for a response from the terminal. When omitted 100 msec is used. Use a longer time for a remote terminal. When using a value less than 10 and no response is received within that time, a previously reported position is returned, if available. This can be used to poll for the position and do some work in the meantime:

The result is a Number, which is the X coordinate in pixels of the left hand side of the GUI Vim window. Also works for an xterm (uses a timeout of 100 msec). The result will be -1 if the information is not available. The value can be used with :winpos.

The result is a Number, which is the Y coordinate in pixels of the top of the GUI Vim window. Also works for an xterm (uses a timeout of 100 msec). The result will be -1 if the information is not available. The value can be used with :winpos.

Like gettabwinvar() for the current tabpage. Examples:

Expand the file wildcards in {expr}. See wildcards for the use of special characters.

Convert a file pattern, as used by glob(), into a search pattern. The result can be used to match with a string that is a file name. E.g.

Perform glob() for String {expr} on all directories in {path} and concatenate the results. Example:

Returns 1 if {feature} is supported, 0 otherwise. The {feature} argument is a feature name like "nvim-0.2.1" or "win32", see below. See also exists().

The result is a Number, which is TRUE if Dictionary {dict} has an entry with key {key}. FALSE otherwise. The {key} argument is a string. In Vim9 script a number is also accepted (and converted to a string) but no other types. In legacy script the usual automatic conversion to string is done.

The result is a Number: 1 when the window has set a local directory via :lcd 2 when the tab-page has set a local directory via :tcd 0 otherwise.

The result is a Number, which is TRUE if there is a mapping that contains {what} in somewhere in the rhs (what it is mapped to) and this mapping exists in one of the modes indicated by {mode}. The arguments {what} and {mode} are strings. When {abbr} is there and it is TRUE use abbreviations instead of mappings. Don't forget to specify Insert and/or Command-line mode. Both the global mappings and the mappings local to the current buffer are checked for a match. If no matching mapping is found FALSE is returned. The following characters are recognized in {mode}: n Normal mode v Visual and Select mode x Visual mode s Select mode o Operator-pending mode i Insert mode l Language-Argument ("r", "f", "t", etc.) c Command-line mode When {mode} is omitted, "nvo" is used.

Add the String {item} to the history {history} which can be one of: "cmd" or ":" command line history "search" or "/" search pattern history "expr" or "=" typed expression history "input" or "@" input line history "debug" or ">" debug command history empty the current or last used history The {history} string does not need to be the whole name, one character is sufficient. If {item} does already exist in the history, it will be shifted to become the newest entry. The result is a Number: TRUE if the operation was successful, otherwise FALSE is returned.

Clear {history}, i.e. delete all its entries. See hist-names for the possible values of {history}.

The result is a String, the entry with Number {index} from {history}. See hist-names for the possible values of {history}, and :history-indexing for {index}. If there is no such entry, an empty String is returned. When {index} is omitted, the most recent item from the history is used.

The result is the Number of the current entry in {history}. See hist-names for the possible values of {history}. If an error occurred, -1 is returned.

The result is a Number, which is TRUE if a highlight group called {name} exists. This is when the group has been defined in some way. Not necessarily when highlighting has been defined for it, it may also have been used for a syntax item.

The result is a Number, which is the ID of the highlight group with name {name}. When the highlight group doesn't exist, zero is returned. This can be used to retrieve information about the highlight group. For example, to get the background color of the "Comment" group:

The result is a String, which is the name of the machine on which Vim is currently running. Machine names greater than 256 characters long are truncated.

The result is a String, which is the text {string} converted from encoding {from} to encoding {to}. When the conversion completely fails an empty string 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". Most conversions require Vim to be compiled with the +iconv feature. Otherwise only UTF-8 to latin1 conversion and back can be done. This can be used to display messages with special characters, no matter what 'encoding' is set to. Write the message in UTF-8 and use:

The result is a Number, which is indent of line {lnum} in the current buffer. The indent is counted in spaces, the value of 'tabstop' is relevant. {lnum} is used just like in getline(). When {lnum} is invalid -1 is returned. In Vim9 script an error is given.

Find {expr} in {object} and return its index. See indexof() for using a lambda to select the item.

Returns the index of an item in {object} where {expr} is v:true. {object} must be a List or a Blob.

The result is a String, which is whatever the user typed on the command-line. The {prompt} argument is either a prompt string, or a blank string (for no prompt). A '\n' can be used in the prompt to start a new line. The highlighting set with :echohl is used for the prompt. The input is entered just like a command-line, with the same editing commands and mappings. There is a separate history for lines typed for input(). Example:

{textlist} must be a List of strings. This List is displayed, one string per line. The user will be prompted to enter a number, which is returned. The user can also select an item by clicking on it with the mouse, if the mouse is enabled in the command line ('mouse' is "a" or includes "c"). For the first string 0 is returned. When clicking above the first item a negative number is returned. When clicking on the prompt one more than the length of {textlist} is returned. Make sure {textlist} has less than 'lines' entries, otherwise it won't work. It's a good idea to put the entry number at the start of the string. And put a prompt in the first item. Example:

Restore typeahead that was saved with a previous inputsave(). Should be called the same number of times inputsave() is called. Calling it more often is harmless though. Returns TRUE when there is nothing to restore, FALSE otherwise.

Preserve typeahead (also from mappings) and clear it, so that a following prompt gets input from the user. Should be followed by a matching inputrestore() after the prompt. Can be used several times, in which case there must be just as many inputrestore() calls. Returns TRUE when out of memory, FALSE otherwise.

This function acts much like the input() function with but two exceptions: a) the user's response will be displayed as a sequence of asterisks ("*") thereby keeping the entry secret, and b) the user's response will not be recorded on the input history stack. The result is a String, which is whatever the user actually typed on the command-line in response to the issued prompt. NOTE: Command-line completion is not supported.

When {object} is a List or a Blob insert {item} at the start of it.

Interrupt script execution. It works more or less like the user typing CTRL-C, most commands won't execute and control returns to the user. This is useful to abort execution from lower down, e.g. in an autocommand. Example:

Bitwise invert. The argument is converted to a number. A List, Dict or Float argument causes an error. Example:

The result is a Number, which is TRUE when a directory with the name {directory} exists. If {directory} doesn't exist, or isn't a directory, the result is FALSE. {directory} is any expression, which is used as a String.

Return 1 if {expr} is a positive infinity, or -1 a negative infinity, otherwise 0.

The result is a Number, which is TRUE when {expr} is the name of a locked variable. The string argument {expr} must be the name of a variable, List item or Dictionary entry, not the variable itself! Example:

Return TRUE if {expr} is a float with value NaN.

Return true if the value is Position.

Return true if the value is ScreenPos.

Check if the value is valid BuiltinCompletion

Return a List with all the key-value pairs of {dict}. Each List item is a list with two items: the key of a {dict} entry and the value of this entry. The List is in arbitrary order. Also see keys() and values(). Example:

Join the items in {list} together into one String. When {sep} is specified it is put in between the items. If {sep} is omitted a single space is used. Note that {sep} is not added at the end. You might want to add it there too:

This parses a JSON formatted string and returns the equivalent in Vim values. See json_encode() for the relation between JSON and Vim values. The decoding is permissive:

• A trailing comma in an array and object is ignored, e.g. "[1, 2, ]" is the same as "[1, 2]".
• Integer keys are accepted in objects, e.g. {1:2} is the same as {"1":2}.
• More floating point numbers are recognized, e.g. "1." for "1.0", or "001.2" for "1.2". Special floating point values "Infinity", "-Infinity" and "NaN" (capitalization ignored) are accepted.
• Leading zeroes in integer numbers are ignored, e.g. "012" for "12" or "-012" for "-12".
• Capitalization is ignored in literal names null, true or false, e.g. "NULL" for "null", "True" for "true".
• Control characters U+0000 through U+001F which are not escaped in strings are accepted, e.g. " " (tab character in string) for "\t".
• An empty JSON expression or made of only spaces is accepted and results in v:none.
• Backslash in an invalid 2-character sequence escape is ignored, e.g. "\a" is decoded as "a".
• A correct surrogate pair in JSON strings should normally be a 12 character sequence such as "\uD834\uDD1E", but json_decode() silently accepts truncated surrogate pairs such as "\uD834" or "\uD834\u"

Encode {expr} as JSON and return this as a string. The encoding is specified in: https://tools.ietf.org/html/rfc7159.html Vim values are converted as follows: Number decimal number Float floating point number Float nan "NaN" Float inf "Infinity" Float -inf "-Infinity" String in double quotes (possibly null) Funcref not possible, error List as an array (possibly null); when used recursively: [] Dict as an object (possibly null); when used recursively: {} Blob as an array of the individual bytes v:false "false" v:true "true" v:none "null" v:null "null" Note that NaN and Infinity are passed on as values. This is missing in the JSON standard, but several implementations do allow it. If not then you will get an error. If a string contains an illegal character then the replacement character 0xfffd is used.

Return a List with all the keys of {dict}. The List is in arbitrary order. Also see items() and values().

Turn the internal byte representation of keys into a form that can be used for :map. E.g.

The result is a Number, which is the length of the argument. When {expr} is a String or a Number the length in bytes is used, as with strlen(). When {expr} is a List the number of items in the List is returned. When {expr} is a Blob the number of bytes is returned. When {expr} is a Dictionary the number of entries in the Dictionary is returned. Otherwise an error is given and returns zero.

Call function {funcname} in the run-time library {libname} with single argument {argument}. This is useful to call functions in a library that you especially made to be used with Vim. Since only one argument is possible, calling standard library functions is rather limited. The result is the String returned by the function. If the function returns NULL, this will appear as an empty string "" to Vim. If the function returns a number, use libcallnr()! If {argument} is a number, it is passed to the function as an int; if {argument} is a string, it is passed as a null-terminated string. This function will fail in restricted-mode.

Just like libcall(), but used for a function that returns an int instead of a string. only in Win32 on some Unix versions, when the +libcall feature is present Examples:

The result is a Number, which is the line number of the file position given with {expr}. The {expr} argument is a string. The accepted positions are: . the cursor position $ the last line in the current buffer 'x position of mark x (if the mark is not set, 0 is returned) w0 first line visible in current window (one if the display isn't updated, e.g. in silent Ex mode) w$ last line visible in current window (this is one less than "w0" if no lines are visible) v In Visual mode: the start of the Visual area (the cursor is the end). When not in Visual mode returns the cursor position. Differs from '< in that it's updated right away. Note that a mark in another file can be used. The line number then applies to another buffer. To get the column number use col(). To get both use getpos(). With the optional {winid} argument the values are obtained for that window instead of the current window. Returns 0 for invalid values of {expr} and {winid}. Examples:

Return the byte count from the start of the buffer for line {lnum}. This includes the end-of-line character, depending on the 'fileformat' option for the current buffer. The first line returns 1. 'encoding' matters, 'fileencoding' is ignored. This can also be used to get the byte count for the line just below the last line:

Get the amount of indent for line {lnum} according the lisp indenting rules, as with 'lisp'. The indent is counted in spaces, the value of 'tabstop' is relevant. {lnum} is used just like in getline(). When {lnum} is invalid -1 is returned. In Vim9 script an error is given.

Return a Blob concatenating all the number values in {list}. Examples:

Convert each number in {list} to a character string can concatenate them all. Examples:

Return the current time, measured as seconds since 1st Jan 1970. See also strftime(), strptime() and getftime().

Return the natural logarithm (base e) of {expr} as a Float. {expr} must evaluate to a Float or a Number in the range (0, inf]. Returns 0.0 if {expr} is not a Float or a Number. Examples:

Return the logarithm of Float {expr} to base 10 as a Float. {expr} must evaluate to a Float or a Number. Returns 0.0 if {expr} is not a Float or a Number. Examples:

{expr1} must be a List, String, Blob or Dictionary. When {expr1} is a List or Dictionary, replace each item in {expr1} with the result of evaluating {expr2}. For a Blob each byte is replaced. For a String, each character, including composing characters, is replaced. If the item type changes you may want to use mapnew() to create a new List or Dictionary. This is required when using Vim9 script.

When {dict} is omitted or zero: Return the rhs of mapping {name} in mode {mode}. The returned String has special characters translated like in the output of the ":map" command listing. When {dict} is TRUE a dictionary is returned, see below. To get a list of all mappings see maplist().

Check if there is a mapping that matches with {name} in mode {mode}. See maparg() for {mode} and special names in {name}. When {abbr} is there and it is TRUE use abbreviations instead of mappings. A match happens with a mapping that starts with {name} and with a mapping which is equal to the start of {name}.

Restore a mapping from a dictionary, possibly returned by maparg() or maplist(). A buffer mapping, when dict.buffer is true, is set on the current buffer; it is up to the caller to ensure that the intended buffer is the current buffer. This feature allows copying mappings from one buffer to another. The dict.mode value may restore a single mapping that covers more than one mode, like with mode values of '!', ' ', 'nox', or 'v'.

When {expr} is a List then this returns the index of the first item where {pat} matches. Each item is used as a String, Lists and Dictionaries are used as echoed.

Defines a pattern to be highlighted in the current window (a "match"). It will be highlighted with {group}. Returns an identification number (ID), which can be used to delete the match using matchdelete(). The ID is bound to the window. Matching is case sensitive and magic, unless case sensitivity or magicness are explicitly overridden in {pattern}. The 'magic', 'smartcase' and 'ignorecase' options are not used. The "Conceal" value is special, it causes the match to be concealed.

Same as matchadd(), but requires a list of positions {pos} instead of a pattern. This command is faster than matchadd() because it does not require to handle regular expressions and sets buffer line boundaries to redraw screen. It is supposed to be used when fast match additions and deletions are required, for example to highlight matching parentheses.

Selects the {nr} match item, as set with a :match, :2match or :3match command. Return a List with two elements: The name of the highlight group used The pattern used. When {nr} is not 1, 2 or 3 returns an empty List. When there is no match item set returns ['', '']. This is useful to save and restore a :match. Highlighting matches using the :match commands are limited to three matches. matchadd() does not have this limitation.

Deletes a match with ID {id} previously defined by matchadd() or one of the :match commands. Returns 0 if successful, otherwise -1. See example for matchadd(). All matches can be deleted in one operation by clearmatches(). If {win} is specified, use the window with this number or window ID instead of the current window.

Same as match(), but return the index of first character after the match. Example:

If {list} is a list of strings, then returns a List with all the strings in {list} that fuzzy match {str}. The strings in the returned list are sorted based on the matching score.

Same as matchfuzzy(), but returns the list of matched strings, the list of character positions where characters in {str} matches and a list of matching scores. You can use byteidx() to convert a character position to a byte position.

Same as match(), but return a List. The first item in the list is the matched string, same as what matchstr() would return. Following items are submatches, like "\1", "\2", etc. in :substitute. When an optional submatch didn't match an empty string is used. Example:

Same as match(), but return the matched string. Example:

Same as matchstr(), but return the matched string, the start position and the end position of the match. Example:

Return the maximum value of all items in {expr}. Example:

Return information about the specified menu {name} in mode {mode}. The menu name should be specified without the shortcut character ('&'). If {name} is "", then the top-level menu names are returned.

Return the minimum value of all items in {expr}. Example:

Create directory {name}.

Return a string that indicates the current mode. If [expr] is supplied and it evaluates to a non-zero Number or a non-empty String (non-zero-arg), then the full mode is returned, otherwise only the first letter is returned. Also see state().

Return the line number of the first line at or below {lnum} that is not blank. Example:

Return a string with a single character, which has the number value {expr}. Examples:

Bitwise OR on the two arguments. The arguments are converted to a number. A List, Dict or Float argument causes an error. Also see and() and xor(). Example:

Shorten directory names in the path {path} and return the result. The tail, the file name, is kept as-is. The other components in the path are reduced to {len} letters in length. If {len} is omitted or smaller than 1 then 1 is used (single letters). Leading '~' and '.' characters are kept. Examples:

Evaluate Perl expression {expr} in scalar context and return its result converted to Vim data structures. If value can't be converted, it is returned as a string Perl representation. Note: If you want an array or hash, {expr} must return a reference to it. Example:

Return the power of {x} to the exponent {y} as a Float. {x} and {y} must evaluate to a Float or a Number. Returns 0.0 if {x} or {y} is not a Float or a Number. Examples:

Return the line number of the first line at or above {lnum} that is not blank. Example:

Return a String with {fmt}, where "%" items are replaced by the formatted form of their respective arguments. Example:

Returns the effective prompt text for buffer {buf}. {buf} can be a buffer name or number. See prompt-buffer.

Set prompt callback for buffer {buf} to {expr}. When {expr} is an empty string the callback is removed. This has only effect if {buf} has 'buftype' set to "prompt".

Set a callback for buffer {buf} to {expr}. When {expr} is an empty string the callback is removed. This has only effect if {buf} has 'buftype' set to "prompt".

Set prompt for buffer {buf} to {text}. You most likely want {text} to end in a space. The result is only visible if {buf} has 'buftype' set to "prompt". Example:

If the popup menu (see ins-completion-menu) is not visible, returns an empty Dictionary, otherwise, returns a Dictionary with the following keys: height nr of items visible width screen cells row top screen row (0 first row) col leftmost screen column (0 first col) size total nr of items scrollbar TRUE if scrollbar is visible

Returns non-zero when the popup menu is visible, zero otherwise. See ins-completion-menu. This can be used to avoid some things that would remove the popup menu.

Evaluate Python expression {expr} and return its result converted to Vim data structures. Numbers and strings are returned as they are (strings are copied though, Unicode strings are additionally converted to 'encoding'). Lists are represented as Vim List type. Dictionaries are represented as Vim Dictionary type with keys converted to strings. Note that in a :def function local variables are not visible to {expr}.

Evaluate Python expression {expr} and return its result converted to Vim data structures. Numbers and strings are returned as they are (strings are copied though). Lists are represented as Vim List type. Dictionaries are represented as Vim Dictionary type, non-string keys result in error. Note that in a :def function local variables are not visible to {expr}.

Evaluate Python expression {expr} and return its result converted to Vim data structures. Uses Python 2 or 3, see python_x and 'pyxversion'. See also: pyeval(), py3eval()

Return a pseudo-random Number generated with an xoshiro128** algorithm using seed {expr}. The returned number is 32 bits, also on 64 bits systems, for consistency. {expr} can be initialized by srand() and will be updated by rand(). If {expr} is omitted, an internal seed value is used and updated. Returns -1 if {expr} is invalid.

Returns a List with Numbers:

• If only {expr} is specified: [0, 1, ..., {expr} - 1]
• If {max} is specified: [{expr}, {expr} + 1, ..., {max}]
• If {stride} is specified: [{expr}, {expr} + {stride}, ..., {max}] (increasing {expr} with {stride} each time, not producing a value past {max}). When the maximum is one before the start the result is an empty list. When the maximum is more than one before the start this is an error. Examples:

Read file {fname} in binary mode and return a Blob. If {offset} is specified, read the file from the specified offset. If it is a negative value, it is used as an offset from the end of the file. E.g., to read the last 12 bytes:

Return a list with file and directory names in {directory}. You can also use glob() if you don't need to do complicated things, such as limiting the number of matches. The list will be sorted (case sensitive), see the {dict} argument below for changing the sort order.

Read file {fname} and return a List, each line of the file as an item. Lines are broken at NL characters. Macintosh files separated with CR will result in a single long line (unless a NL appears somewhere). All NUL characters are replaced with a NL character. When {type} contains "b" binary mode is used:

• When the last line ends in a NL an extra empty list item is added.
• No CR characters are removed. Otherwise:
• CR characters that appear before a NL are removed.
• Whether the last line ends in a NL or not does not matter.
• When 'encoding' is Unicode any UTF-8 byte order mark is removed from the text. When {max} is given this specifies the maximum number of lines to be read. Useful if you only want to check the first ten lines of a file:

{func} is called for every item in {object}, which can be a String, List or a Blob. {func} is called with two arguments: the result so far and current item. After processing all items the result is returned.

Returns the single letter name of the register being executed. Returns an empty string when no register is being executed. See @.

Returns the single letter name of the register being recorded. Returns an empty string when not recording. See q.

Return an item that represents a time value. The item is a list with items that depend on the system. In Vim 9 script the type list can be used. The item can be passed to reltimestr() to convert it to a string or reltimefloat() to convert to a Float. For example, to see the time spent in function Work():

Return a Float that represents the time value of {time}. Example:

Return a String that represents the time value of {time}. This is the number of seconds, a dot and the number of microseconds. Example:

Without {end}: Remove the item at {idx} from List {list} and return the item. With {end}: Remove items from {idx} to {end} (inclusive) and return a List with these items. When {idx} points to the same item as {end} a list with one item is returned. When {end} points to an item before {idx} this is an error. See list-index for possible values of {idx} and {end}. Returns zero on error. Example:

Rename the file by the name {from} to the name {to}. This should also work to move files across file systems. The result is a Number, which is 0 if the file was renamed successfully, and non-zero when the renaming failed. NOTE: If {to} exists it is overwritten without warning. This function is not available in the sandbox.

Repeat {expr} {count} times and return the concatenated result. Example:

On MS-Windows, when {filename} is a shortcut (a .lnk file), returns the path the shortcut points to in a simplified form. When {filename} is a symbolic link or junction point, return the full path to the target. If the target of junction is removed, return {filename}. On Unix, repeat resolving symbolic links in all path components of {filename} and return the simplified result. To cope with link cycles, resolving of symbolic links is stopped after 100 iterations. On other systems, return the simplified {filename}. The simplification step is done as by simplify(). resolve() keeps a leading path component specifying the current directory (provided the result is still a relative path name) and also keeps a trailing path separator.

Reverse the order of items in {object}. {object} can be a List, a Blob or a String. For a List and a Blob the items are reversed in-place and {object} is returned. For a String a new String is returned. Returns zero if {object} is not a List, Blob or a String. If you want a List or Blob to remain unmodified make a copy first:

Round off {expr} to the nearest integral value and return it as a Float. If {expr} lies halfway between two integral values, then use the larger one (away from zero). {expr} must evaluate to a Float or a Number. Returns 0.0 if {expr} is not a Float or a Number. Examples:

Evaluate Ruby expression {expr} and return its result converted to Vim data structures. Numbers, floats and strings are returned as they are (strings are copied though). Arrays are represented as Vim List type. Hashes are represented as Vim Dictionary type. Other objects are represented as strings resulted from their "Object#to_s" method. Note that in a :def function local variables are not visible to {expr}.

Like screenchar(), but return the attribute. This is a rather arbitrary number that can only be used to compare to the attribute at other positions. Returns -1 when row or col is out of range.

The result is a Number, which is the character at position [row, col] on the screen. This works for every possible screen position, also status lines, window separators and the command line. The top left position is row one, column one The character excludes composing characters. For double-byte encodings it may only be the first byte. This is mainly to be used for testing. Returns -1 when row or col is out of range.

The result is a List of Numbers. The first number is the same as what screenchar() returns. Further numbers are composing characters on top of the base character. This is mainly to be used for testing. Returns an empty List when row or col is out of range.

The result is a Number, which is the current screen column of the cursor. The leftmost column has number 1. This function is mainly used for testing.

The result is a Dict with the screen position of the text character in window {winid} at buffer line {lnum} and column {col}. {col} is a one-based byte index. The Dict has these members: row screen row col first screen column endcol last screen column curscol cursor screen column If the specified position is not visible, all values are zero. The "endcol" value differs from "col" when the character occupies more than one screen cell. E.g. for a Tab "col" can be 1 and "endcol" can be 8. The "curscol" value is where the cursor would be placed. For a Tab it would be the same as "endcol", while for a double width character it would be the same as "col". The conceal feature is ignored here, the column numbers are as if 'conceallevel' is zero. You can set the cursor to the right position and use screencol() to get the value with conceal taken into account. If the position is in a closed fold the screen position of the first character is returned, {col} is not used. Returns an empty Dict if {winid} is invalid.

The result is a Number, which is the current screen row of the cursor. The top line has number one. This function is mainly used for testing. Alternatively you can use winline().

The result is a String that contains the base character and any composing characters at position [row, col] on the screen. This is like screenchars() but returning a String with the characters. This is mainly to be used for testing. Returns an empty String when row or col is out of range.

Search for regexp pattern {pattern}. The search starts at the cursor position (you can use cursor() to set it).

Get or update the last search count, like what is displayed without the "S" flag in 'shortmess'. This works even if 'shortmess' does contain the "S" flag.

Search for the declaration of {name}.

Search for the match of a nested start-end pair. This can be used to find the "endif" that matches an "if", while other if/endif pairs in between are ignored. The search starts at the cursor. The default is to search forward, include 'b' in {flags} to search backward. If a match is found, the cursor is positioned at it and the line number is returned. If no match is found 0 or -1 is returned and the cursor doesn't move. No error message is given.

Same as searchpair(), but returns a List with the line and column position of the match. The first element of the List is the line number and the second element is the byte index of the column position of the match. If no match is found, returns [0, 0].

Same as search(), but returns a List with the line and column position of the match. The first element of the List is the line number and the second element is the byte index of the column position of the match. If no match is found, returns [0, 0]. Example:

Return a list of available server names, one per line. When there are no servers or the information is not available an empty string is returned. See also clientserver. only available when compiled with the +clientserver feature Example:

Set line {lnum} to {text} in buffer {buf}. This works like setline() for the specified buffer.

Set option or local variable {varname} in buffer {buf} to {val}. This also works for a global or local window option, but it doesn't work for a global or local window variable. For a local window option the global value is unchanged. For the use of {buf}, see bufname() above. The {varname} argument is a string. Note that the variable name without "b:" must be used. Examples:

Specify overrides for cell widths of character ranges. This tells Vim how wide characters are when displayed in the terminal, counted in screen cells. The values override 'ambiwidth'. Example:

Same as setpos() but uses the specified column number as the character index instead of the byte index in the line.

Set the current character search information to {dict}, which contains one or more of the following entries:

Set the command line to {str} and set the cursor position to {pos}. If {pos} is omitted, the cursor is positioned after the text. Returns 0 when successful, 1 when not editing the command line.

Set the cursor position in the command line to byte position {pos}. The first position is 1. Use getcmdpos() to obtain the current position. Only works while editing the command line, thus you must use c_CTRL-\_e, c_CTRL-R_= or c_CTRL-R_CTRL-R with '='. For c_CTRL-\_e and c_CTRL-R_CTRL-R with '=' the position is set after the command line is set to the expression. For c_CTRL-R_= it is set after evaluating the expression but before inserting the resulting text. When the number is too big the cursor is put at the end of the line. A number smaller than one has undefined results. Returns 0 when successful, 1 when not editing the command line.

Same as cursor() but uses the specified column number as the character index instead of the byte index in the line.

Set environment variable {name} to {val}. Example:

Set the file permissions for {fname} to {mode}. {mode} must be a string with 9 characters. It is of the form "rwxrwxrwx", where each group of "rwx" flags represent, in turn, the permissions of the owner of the file, the group the file belongs to, and other users. A '-' character means the permission is off, any other character means on. Multi-byte characters are not supported.

Set line {lnum} of the current buffer to {text}. To insert lines use append(). To set lines in another buffer use setbufline(). Any text properties in {lnum} are cleared.

Create or replace or add to the location list for window {nr}. {nr} can be the window number or the window-ID. When {nr} is zero the current window is used.

Restores a list of matches saved by getmatches() for the current window. Returns 0 if successful, otherwise -1. All current matches are cleared before the list is restored. See example for getmatches(). If {win} is specified, use the window with this number or window ID instead of the current window.

Set the position for String {expr}. Possible values: . the cursor 'x mark x

Create or replace or add to the quickfix list.

Set the register {regname} to {value}. If {regname} is "" or "@", the unnamed register '"' is used. The {regname} argument is a string. In Vim9-script {regname} must be one character.

Set tab-local variable {varname} to {val} in tab page {tabnr}. t:var The {varname} argument is a string. Note that autocommands are blocked, side effects may not be triggered, e.g. when setting 'filetype'. Note that the variable name without "t:" must be used. Tabs are numbered starting with one. This function is not available in the sandbox.

Set option or local variable {varname} in window {winnr} to {val}. Tabs are numbered starting with one. For the current tabpage use setwinvar(). {winnr} can be the window number or the window-ID. When {winnr} is zero the current window is used. Note that autocommands are blocked, side effects may not be triggered, e.g. when setting 'filetype' or 'syntax'. This also works for a global or local buffer option, but it doesn't work for a global or local buffer variable. For a local buffer option the global value is unchanged. Note that the variable name without "w:" must be used. Examples: