CONTENTS vimtex-contents

INTRODUCTION vimtex-introduction

COMMENT ON INTERNAL TEX PLUGIN vimtex-comment-internal

FEATURE OVERVIEW vimtex-features

REQUIREMENTS vimtex-requirements

let g:vimtex_version_check = 0

autocmd FileType tex set encoding=utf-8

if empty(v:servername) && exists('*remote_startserver')
  call remote_startserver('VIM')
endif

alias vim='vim --servername VIM'

SUPPORT FOR MULTI-FILE PROJECTS vimtex-multi-file

augroup VimTeX
  autocmd!
  autocmd BufReadPre /path/to/project/*.tex
        \ let b:vimtex_main = '/path/to/project/main.tex'
augroup END

%! TEX root = /path/to/my-main.tex
% ! TeX root = ../*.tex
%!Tex Root=**/main.tex
%! TeX root: ../main.tex

main.tex
sub/sub.tex

path/file.tex
path/file.tex.latexmain
path/sections/file1.tex
path/sections/file2.tex

SUPPORT FOR TEX DIRECTIVES vimtex-tex-directives

%! TeX program = lualatex
%! TEX TS-program = xelatex

PACKAGE DETECTION vimtex-package-detection

INTEGRATION WITH OTHER PLUGINS vimtex-and-friends

\left( \frac{a}{b} \middle| q \right)

let g:matchup_override_vimtex = 1

let g:matchup_matchparen_deferred = 1

USAGE vimtex-usage

DEFAULT MAPPINGS vimtex-default-mappings

nmap <space>li <plug>(vimtex-info)

OPTIONS vimtex-options

function! SetCompilerMethod(mainfile)
  if filereadable(a:mainfile)
    for line in readfile(a:mainfile, '', 5)
      if line =~# '^%\s*arara'
        return 'arara'
      endif
    endfor
  endif

  return 'latexmk'
endfunction

let g:vimtex_compiler_method = 'SetCompilerMethod'

let g:vimtex_compiler_clean_paths = ['_minted*']

let g:vimtex_compiler_latexmk = {
    \ 'aux_dir' : '',
    \ 'out_dir' : '',
    \ 'callback' : 1,
    \ 'continuous' : 1,
    \ 'clean_ext' : '',
    \ 'executable' : 'latexmk',
    \ 'hooks' : [],
    \ 'options' : [
    \   '-verbose',
    \   '-file-line-error',
    \   '-synctex=1',
    \   '-interaction=nonstopmode',
    \ ],
    \}

file_info = {
  root = …
  target = …
  target_basename = …
  target_name = …
  jobname = …
}

let g:vimtex_compiler_latexmk = {'aux_dir': {_ -> expand("%:t:r")}}

function! Callback(msg)
  let l:m = matchlist(a:msg, '\vRun number (\d+) of rule ''(.*)''')
  if !empty(l:m)
    echomsg l:m[2] . ' (' . l:m[1] . ')'
  endif
endfunction
let g:vimtex_compiler_latexmk = { 'hooks': [function('Callback')] }

let g:vimtex_compiler_latexmk_engines = {
    \ '_'                : '-pdf',
    \ 'pdfdvi'           : '-pdfdvi',
    \ 'pdfps'            : '-pdfps',
    \ 'pdflatex'         : '-pdf',
    \ 'luatex'           : '-lualatex',
    \ 'lualatex'         : '-lualatex',
    \ 'xelatex'          : '-xelatex',
    \ 'context (pdftex)' : '-pdf -pdflatex=texexec',
    \ 'context (luatex)' : '-pdf -pdflatex=context',
    \ 'context (xetex)'  : '-pdf -pdflatex=''texexec --xtx''',
    \}

let g:vimtex_compiler_latexrun = {
    \ 'out_dir' : '',
    \ 'options' : [
    \   '-verbose-cmds',
    \   '--latex-args="-synctex=1"',
    \ ],
    \}

let g:vimtex_compiler_latexrun_engines = {
    \ '_'                : 'pdflatex',
    \ 'pdflatex'         : 'pdflatex',
    \ 'lualatex'         : 'lualatex',
    \ 'xelatex'          : 'xelatex',
    \}

let g:vimtex_compiler_tectonic = {
    \ 'out_dir' : '',
    \ 'hooks' : [],
    \ 'options' : [
    \   '--keep-logs',
    \   '--synctex'
    \ ],
    \}

let g:vimtex_compiler_arara = {
    \ 'options' : ['--log'],
    \ 'hooks' : [],
    \}

let g:vimtex_compiler_texpresso = {
    \ 'options' : [],
    \}

let g:vimtex_compiler_generic = {
    \ 'command' : '',
    \ 'hooks' : [],
    \}

if executable('bibparse')
  let g:vimtex_parser_bib_backend = 'bibparse'
endif

% command                number of args
% -------                --------------
\foo{bar}{baz}           % 2
\foo{bar} {baz}          % 1
\foo{bar}
{baz}                    % 2
\foo{bar}
  {baz}                  % 2
\foo{bar}__
  {baz}                  % 1 (_ indicates spaces)

@author_all    Full author list
@author_short  Shortened author list
@key           The bibtex key
@title         Title
@type          Type of entry
@year          Publication year

let g:vimtex_complete_bib = { 'simple': 1 }

let g:vimtex_complete_ref = {
   \ 'custom_patterns': ['\\figref\*\?{[^}]*$']
   \ }

{
\ 'name' : [
\   ['\(', '\)'],
\   ['\[', '\]'],
\   ['$$', '$$'],
\   ['$', '$'],
\ ],
\ 're' : [
\   ['\\(', '\\)'],
\   ['\\\@<!\\\[', '\\\]'],
\   ['\$\$', '\$\$'],
\   ['\$', '\$'],
\ ],
\}

let g:vimtex_delim_list = {
      \ 'mods' : {
      \   'name' : [ "..." ],
      \ }
      \}

let g:vimtex_delim_list = {
    \ 'delim_tex' : {
    \   'name' : [
    \     ['[', ']'],
    \     ['{', '}'],
    \     ['\glq', '\grq'],
    \     ['\glqq', '\grqq'],
    \     ['\flq', '\frq'],
    \     ['\flqq', '\frqq'],
    \    ]
    \  }
    \}

let g:vimtex_delim_list = {'mods' : {}}
let g:vimtex_delim_list.mods.name = [
      \ ['\left', '\right'],
      \ ['\mleft', '\mright'],
      \ ['\bigl', '\bigr'],
      \ ['\Bigl', '\Bigr'],
      \ ['\biggl', '\biggr'],
      \ ['\Biggl', '\Biggr'],
      \ ['\big', '\big'],
      \ ['\Big', '\Big'],
      \ ['\bigg', '\bigg'],
      \ ['\Bigg', '\Bigg'],
      \]
let g:vimtex_delim_toggle_mod_list = [
  \ ['\left', '\right'],
  \ ['\mleft', '\mright'],
  \]

let g:vimtex_delim_toggle_mod_list = [
  \ ['\bigl', '\bigr'],
  \ ['\Bigl', '\Bigr'],
  \ ['\biggl', '\biggr'],
  \ ['\Biggl', '\Biggr'],
  \]

Open documentation for usepackage: foobar? [y]es/[n]o

let g:vimtex_doc_handlers = ['vimtex#doc#handlers#texdoc']

let g:vimtex_env_toggle_map = {
      \ 'itemize': 'enumerate',
      \ 'enumerate': 'itemize',
      \}

let g:vimtex_env_toggle_math_map = {
      \ '$': '\[',
      \ '\[': 'equation',
      \ '$$': '\[',
      \ '\(': '$',
      \}

setlocal foldmethod=expr
setlocal foldexpr=vimtex#fold#level(v:lnum)
setlocal foldtext=vimtex#fold#text()

let g:vimtex_fold_types = #{
      \ markers : #{text : {line, level -> foldtext()}}
      \}

vim.g.vimtex_fold_types = {
  markers = {
    text = function(line, level) return vim.fn.foldtext() end
  }
}

% fakepart title
% Fakechapter title
% Fakesection title
% fakesubsection title

\begin{axis}[    --->    \begin{axis}[...]
    width=6cm,
    height=8cm,
    ...,
]

\hypersetup{    --->    \hypersetup{...}
  option 1,
  ...,
  option n
  }

\usepackage[    --->    \usepackage[...]{name}
  option 1,
  ...,
  option n
  ]{name}

\newcommand{\xx}[3]{    --->    \newcommand{\xx} ...
  Hello #1, #2, and #3.
}

\addplot+[] table[] {    --->    \addplot+[] table[] {...};
  table data
};

let  g:vimtex_fold_types = {
       \ 'preamble' : {'enabled' : 0},
       \ 'envs' : {
       \   'blacklist' : ['figure', 'table'],
       \ },
       \}

let g:vimtex_grammar_textidote = {
      \ 'jar': '',
      \ 'args': '',
      \}

let g:vimtex_grammar_vlty = {
      \ 'lt_directory': '~/lib/LanguageTool',
      \ 'lt_command': '',
      \ 'lt_disable': 'WHITESPACE_RULE',
      \ 'lt_enable': '',
      \ 'lt_disablecategories': '',
      \ 'lt_enablecategories': '',
      \ 'server': 'no',
      \ 'shell_options': '',
      \ 'show_suggestions': 0,
      \ 'encoding': 'auto',
      \}

let g:vimtex_indent_delims = {
      \ 'open' : ['{'],
      \ 'close' : ['}'],
      \ 'close_indented' : 0,
      \ 'include_modified_math' : 1,
      \}

let g:vimtex_mappings_disable = {
    \ 'n': ['tse', 'tsd'],
    \ 'x': ['tsd'],
    \}

" Disable custom warnings based on regexp
let g:vimtex_quickfix_ignore_filters = [
      \ 'Marginpar on page',
      \]

let g:vimtex_syntax_conceal = {
      \ 'accents': 1,
      \ 'ligatures': 1,
      \ 'cites': 1,
      \ 'fancy': 1,
      \ 'texTabularChar': 1,
      \ 'spacing': 1,
      \ 'greek': 1,
      \ 'math_bounds': 1,
      \ 'math_delimiters': 1,
      \ 'math_fracs': 1,
      \ 'math_super_sub': 1,
      \ 'math_symbols': 1,
      \ 'sections': 0,
      \ 'styles': 1,
      \}

let g:vimtex_syntax_conceal_cites = {
      \ 'type': 'brackets',
      \ 'icon': '📖',
      \ 'verbose': v:true,
      \}

\cmdname[optional]{argument}

let g:vimtex_syntax_custom_cmds = [
      \ {'name': 'vct', 'mathmode': 1, 'argstyle': 'bold'},
      \ {'name': 'R', 'cmdre': 'R>', 'mathmode': 1, 'concealchar': 'ℝ'},
      \ {'name': 'mathnote', 'mathmode': 1, 'nextgroup': 'texMathTextArg'},
      \ {'name': 'nospell', 'argspell': 0},
      \]

$\ket{x}$ and $\binom{n}{k}$

% will now look like this:

|x> and (n|k)

\begin{env_name}[optional argument]
  …
\end{env_name}

let g:vimtex_syntax_custom_envs = [
      \ {
      \   'name': 'MyMathEnv',
      \   'math': v:true
      \ },
      \ {
      \   'name': 'python_code',
      \   'region': 'texPythonCodeZone',
      \   'nested': 'python',
      \ },
      \ {
      \   'name': 'code',
      \   'region': 'texCodeZone',
      \   'nested': {
      \     'python': 'language=python',
      \     'c': 'language=C',
      \     'rust': 'language=rust',
      \   },
      \ },
      \]

let g:vimtex_syntax_nested = {
      \ 'aliases' : {
      \   'C' : 'c',
      \   'csharp' : 'cs',
      \ },
      \ 'ignored' : {
      \   'sh' : ['shSpecial'],
      \   'bash' : ['shSpecial'],
      \   'cs' : [
      \     'csBraces',
      \   ],
      \   'python' : [
      \     'pythonEscape',
      \     'pythonBEscape',
      \     'pythonBytesEscape',
      \   ],
      \   'java' : [
      \     'javaError',
      \   ],
      \   'haskell' : [
      \     'hsVarSym',
      \   ],
      \ }
      \}

let g:vimtex_syntax_packages = {
      \ 'amsmath': {'conceal': 1, 'load': 2},
      \ 'babel': {'conceal': 1},
      \ 'hyperref': {'conceal': 1},
      \ 'fontawesome5': {'conceal': 1},
      \ 'robust_externalize': {
      \   'presets': [
      \     ['bash', 'bash'],
      \     ['python', 'python'],
      \     ['gnuplot', 'gnuplot'],
      \     ['tikz', '@texClusterTikz'],
      \     ['latex', 'TOP'],
      \   ],
      \ },
      \}

let g:vimtex_toggle_star_cmds = [
      \ 'part',
      \ '%(sub)*section',
      \ '%(sub)*paragraph',
      \ '[vh]space',
      \ '\w*cite\w*',
      \ '\w*ref',
      \ '%(re)?newcommand',
      \ 'providecommand',
      \ 'DeclareRobustCommand',
      \ 'DeclareMathOperator',
      \ '%(re)?newenvironment',
      \ 'includegraphics',
      \ 'verb',
      \]

{ 'content': 1,
  'label': 1,
  'todo': 1,
  'include': 1 }

{ 'content': 'C',
  'label': 'L',
  'todo': 'T',
  'include': 'I'}

augroup VimTeX
  autocmd!
  autocmd BufWritePost *.tex call vimtex#toc#refresh()
augroup END

nnoremap <silent> <localleader>lf :call vimtex#toc#refresh()

let g:vimtex_toc_config_matchers = {
      \ 'MATCHER1': {OPTIONS},
      \ 'MATCHER2': {OPTIONS},
      \}

let g:vimtex_toc_config_matchers = {
      \ 'beamer_frame': {'disable': 1},
      \ 'todo_fixme': {'priority': -1},
      \ 'index': {'title': 'MyFancy Index Title'},
      \}

let g:vimtex_toc_custom_matchers = [
        \ { 'title' : 'My Custom Environment',
        \   're' : '\v^\s*\\begin\{mycustomenv\}' }
        \]

" On neovim
let g:vimtex_ui_method = {
      \ 'confirm': 'nvim',
      \ 'input': 'nvim',
      \ 'select': 'nvim',
      \}

" Otherwise
let g:vimtex_ui_method = {
      \ 'confirm': 'legacy',
      \ 'input': 'legacy',
      \ 'select': 'legacy',
      \}

COMMANDS vimtex-commands

:start,end VimtexCompileSelected

texcount -nosub -sum [-letter] -merge -q -1 FILE

'range' : [1, line('$')]
'count_letters' : 0/1
'detailed' : 0

texcount -nosub -sum [-letter] -inc FILE

MAP DEFINITIONS vimtex-mappings

nmap tss <plug>(vimtex-cmd-toggle-star-agn)

                  ts$        \[
$f(x) = 1$         ↔            f(x) = 1
                             \]

imap <buffer> <f7> <plug>(vimtex-cmd-create)}<left>

INSERT MODE MAPPINGS vimtex-imaps

let add_map_arg = {
  \ 'lhs' : lhs,
  \ 'rhs' : rhs,
  \ 'expr' : bool,
  \ 'leader' : leader_key,
  \ 'wrapper' : function_name,
  \ 'context' : value,
  \ }

" Using neosnippet#anonymous
inoremap <silent><expr> __ neosnippet#anonymous('_${1}${0}')
inoremap <silent><expr> ^^ neosnippet#anonymous('^${1}${0}')

" Using UltiSnips#Anon
inoremap <silent> __ __<c-r>=UltiSnips#Anon('_{$1}$0', '__', '', 'i')<cr>
inoremap <silent> ^^ ^^<c-r>=UltiSnips#Anon('^{$1}$0', '^^', '', 'i')<cr>

EVENTS vimtex-events

COMPLETION vimtex-completion

COMPLETE CITATIONS vimtex-complete-cites

@book{knuth1981,
  author = "Donald E. Knuth",
  title = "Seminumerical Algorithms",
  publisher = "Addison-Wesley",
  year = "1981"
}

\cite{Knuth 1981<CTRL-X><CTRL-O>
\cite{algo<CTRL-X><CTRL-O>
\cite{Don.*Knuth<CTRL-X><CTRL-O>

COMPLETE LABELS vimtex-complete-labels

\ref{sec:<CTRL-X><CTRL-O>

\ref{<base><CTRL-X><CTRL-O>

COMPLETE COMMANDS AND ENVIRONMENTS vimtex-complete-commands

COMPLETE FILE NAMES vimtex-complete-filenames

COMPLETE INCLUDE GLOSSARY ENTRIES vimtex-complete-glossary

COMPLETE PACKAGE FILES vimtex-complete-packages

kpsewhich --all ls-R

kpsewhich --var-value TEXMFHOME

COMPLETE BEAMER THEMES vimtex-complete-beamer

AUTOCOMPLETE vimtex-complete-auto

" This is new style
call deoplete#custom#var('omni', 'input_patterns', {
        \ 'tex': g:vimtex#re#deoplete
        \})

" This is old style (deprecated)
if !exists('g:deoplete#omni#input_patterns')
    let g:deoplete#omni#input_patterns = {}
endif
let g:deoplete#omni#input_patterns.tex = g:vimtex#re#deoplete

if !exists('g:neocomplete#sources#omni#input_patterns')
  let g:neocomplete#sources#omni#input_patterns = {}
endif
let g:neocomplete#sources#omni#input_patterns.tex =
      \ g:vimtex#re#neocomplete

augroup my_cm_setup
  autocmd!
  autocmd BufEnter * call ncm2#enable_for_buffer()
  autocmd Filetype tex call ncm2#register_source({
          \ 'name' : 'vimtex-cmds',
          \ 'priority': 8,
          \ 'complete_length': -1,
          \ 'scope': ['tex'],
          \ 'matcher': {'name': 'prefix', 'key': 'word'},
          \ 'word_pattern': '\w+',
          \ 'complete_pattern': g:vimtex#re#ncm2#cmds,
          \ 'on_complete': ['ncm2#on_complete#omni', 'vimtex#complete#omnifunc'],
          \ })
  autocmd Filetype tex call ncm2#register_source({
          \ 'name' : 'vimtex-labels',
          \ 'priority': 8,
          \ 'complete_length': -1,
          \ 'scope': ['tex'],
          \ 'matcher': {'name': 'combine',
          \             'matchers': [
          \               {'name': 'substr', 'key': 'word'},
          \               {'name': 'substr', 'key': 'menu'},
          \             ]},
          \ 'word_pattern': '\w+',
          \ 'complete_pattern': g:vimtex#re#ncm2#labels,
          \ 'on_complete': ['ncm2#on_complete#omni', 'vimtex#complete#omnifunc'],
          \ })
  autocmd Filetype tex call ncm2#register_source({
          \ 'name' : 'vimtex-files',
          \ 'priority': 8,
          \ 'complete_length': -1,
          \ 'scope': ['tex'],
          \ 'matcher': {'name': 'combine',
          \             'matchers': [
          \               {'name': 'abbrfuzzy', 'key': 'word'},
          \               {'name': 'abbrfuzzy', 'key': 'abbr'},
          \             ]},
          \ 'word_pattern': '\w+',
          \ 'complete_pattern': g:vimtex#re#ncm2#files,
          \ 'on_complete': ['ncm2#on_complete#omni', 'vimtex#complete#omnifunc'],
          \ })
  autocmd Filetype tex call ncm2#register_source({
          \ 'name' : 'bibtex',
          \ 'priority': 8,
          \ 'complete_length': -1,
          \ 'scope': ['tex'],
          \ 'matcher': {'name': 'combine',
          \             'matchers': [
          \               {'name': 'prefix', 'key': 'word'},
          \               {'name': 'abbrfuzzy', 'key': 'abbr'},
          \               {'name': 'abbrfuzzy', 'key': 'menu'},
          \             ]},
          \ 'word_pattern': '\w+',
          \ 'complete_pattern': g:vimtex#re#ncm2#bibtex,
          \ 'on_complete': ['ncm2#on_complete#omni', 'vimtex#complete#omnifunc'],
          \ })
augroup END

augroup my_cm_setup
  autocmd!
  autocmd User CmSetup call cm#register_source({
        \ 'name': 'vimtex',
        \ 'priority': 8,
        \ 'scoping': 1,
        \ 'scopes': ['tex'],
        \ 'abbreviation': 'tex',
        \ 'cm_refresh_patterns': g:vimtex#re#ncm,
        \ 'cm_refresh': {'omnifunc': 'vimtex#complete#omnifunc'},
        \ })
augroup END

if !exists('g:ycm_semantic_triggers')
  let g:ycm_semantic_triggers = {}
endif
au VimEnter * let g:ycm_semantic_triggers.tex=g:vimtex#re#youcompleteme

augroup VimCompletesMeTex
  autocmd!
  autocmd FileType tex
      \ let b:vcm_omni_pattern = g:vimtex#re#neocomplete
augroup END

local cmp = require('cmp')
cmp.setup {
  -- global configuration goes here
  sources = {
    { name = 'buffer' },
    -- other sources (GLOBAL)
  },
}
cmp.setup.filetype("tex", {
  sources = {
    { name = 'vimtex' },
    { name = 'buffer' },
    -- other sources
  },
}

local cmp = require('cmp')
cmp.setup {
  -- global configuration goes here
  sources = {
    { name = 'buffer' },
    -- other sources (GLOBAL)
  },
}
cmp.setup.filetype("tex", {
  formatting = {
    -- nvim-cmp overrides the standard completion-menu formatting. We use
    -- a custom format function to preserve the format as provided by
    -- VimTeX's omni completion function:
    format = function(entry, vim_item)
        vim_item.menu = ({
          omni = (vim.inspect(vim_item.menu):gsub('%"', "")),
          buffer = "[Buffer]",
          -- formatting for other sources
          })[entry.source.name]
        return vim_item
      end,
  },
  sources = {
    { name = "omni", trigger_characters = { "{", "\\" } },
    { name = 'buffer' },
    -- other sources
  },
}

require('compe').setup({
    source = {
        omni = {
            filetypes = {'tex'},
        },
    },
    -- the rest of your compe config...
})

let g:compe.source = {
      \ 'omni': {
      \  'filetypes': ['tex'],
      \ }
      \}

let g:mucomplete#can_complete = {}
let g:mucomplete#can_complete.tex =
  \ { 'omni': { t -> t =~# g:vimtex#re#neocomplete . '$' } }

FOLDING vimtex-folding

set foldmethod=expr
set foldexpr=vimtex#fold#level(v:lnum)
set foldtext=vimtex#fold#text()

set fillchars=fold:\

INDENTATION vimtex-indent

SYNTAX HIGHLIGHTING vimtex-syntax

% VimTeX: SynIgnore on
\catcode`\$=11
$
\catcode`\$=3
% VimTeX: SynIgnore off

%%begin novalidate
\catcode`\$=11
$
\catcode`\$=3
%%end novalidate

SYNTAX CONCEAL vimtex-syntax-conceal

SYNTAX CORE SPECIFICATION vimtex-syntax-core

SYNTAX PACKAGE SPECIFICATION vimtex-syntax-packages

SYNTAX GROUP REFERENCE vimtex-syntax-reference

GROUP                DEFAULT
----------------------------------------------------------------------------
VimtexMsg            ModeMsg
VimtexInfo           Question
VimtexTodo           Todo
VimtexWarning        WarningMsg
VimtexError          ErrorMsg
VimtexFatal          Error
VimtexSuccess        Statement
texCmdType           Type
texParm              Special
texZone              PreCondit
texSymbol            SpecialChar
texError             VimtexError

GROUP                DEFAULT      EXAMPLE
----------------------------------------------------------------------------
texComment           Comment      % COMMENT
texCommentTodo       VimtexTodo   % TODO
texDelim             Delimiter    {, }, [, and ]
texCmd               Statement    \CMD
texOpt               Identifier   \cmd[OPT]
texOptSep            NormalNC     [a, b] (commas)
texOptEqual          texSymbol    [a=b]
texArg               Include      \cmd[...]{ARG}
texSpecialChar       SpecialChar  \S, \P, \$, \;, ...
texCmdInput          texCmd       \INPUT
                                  \INCLUDE
                                  \INCLUDEONLY
                                  \INCLUDEGRAPHICS
texCmdBib            texCmd       \BIBLIOGRAPHY
                                  \BIBLIOGRAPHYSTYLE
texCmdClass          texCmd       \DOCUMENTCLASS
texCmdPackage        texCmd       \USEPACKAGE
                                  \REQUIREPACKAGE
texFileOpt           texOpt       \includegraphics[PACKAGE OPTIONS]
                                  \documentclass[CLASS OPTIONS]
texFileArg           texArg       \input{FILE}
                                  \include{FILE}
                                  \includegraphics[...]{FILE}
                                  \bibliographystyle{FILE}
                                  \documentclass[...]{CLASS}
texFilesOpt          texFileOpt   \usepackage[PACKAGE OPTIONS]
                                  \RequirePackage[PACKAGE OPTIONS]
texFilesArg          texFileArg   \includeonly{FILE1, FILE2}
                                  \bibliography{FILE1, FILE2}
                                  \usepackage[...]{PACKAGE1, PACKAGE2}
                                  \RequirePackage[...]{PACKAGE1, PACKAGE2}
texCmdTitle          texCmd       \TITLE
texTitleArg          Underlined   \title{MAIN TITLE}
texCmdAuthor         texCmd       \AUTHOR
texAuthorOpt         texOpt       \author[OPT]
texAuthorArg         NONE         \author[...]{AUTHOR LIST}
texCmdPart           texCmd       \(SUB*)SECTION
texPartArgTitle      String       \(sub*)section{TITLE}
texCmdEnv            texCmd       \BEGIN; \END
texEnvArgName        PreCondit    \begin{ENVNAME}
texCmdRef            texCmd       \CITE; \LABEL
texRefArg            Special      \cite{REFERENCE}; \label{REF}
texE3Variable        texCmd       \G_MYFILE_NAME_STR
texE3Constant        texE3Variable
                                  \C_MYFILE_NAME_STR
texE3Function        texCmdType   \STR_NEW:n
texE3Type            texParm      \str_new:N
texCmdParbox         texCmd       \PARBOX[p][h][i]{w}{c}
texBoxOptPosVal      texSymbol    \parbox[P][h][i]{w}{c}
                                  \begin{minipage}[P][h][i]{w}
texBoxOptIPosVal     texBoxOptPosVal
                                  \parbox[p][h][I]{w}{c}
                                  \begin{minipage}[p][h][I]{w}

GROUP                    DEFAULT           EXAMPLE
----------------------------------------------------------------------------
texMathZone              Special
texMathZoneLI            texMathZone       \( HERE \)
texMathZoneLD            texMathZone       \[ HERE \]
texMathZoneTI            texMathZone       $ HERE $
texMathZoneTD            texMathZone       $$ HERE $$
texMathZoneEnv           texMathZone       \begin{menv}  HERE \end{menv}
texMathZoneEnvStarred    texMathZone       \begin{menv*} HERE \end{menv*}
texMathZoneEnsured       texMathZone       \ensuremath{HERE}
texMathDelimZone         texDelim
texMathDelimZoneLI       texMathDelimZone  \(; \)
texMathDelimZoneLD       texMathDelimZone  \[; \]
texMathDelimZoneTI       texMathDelimZone  $
texMathDelimZoneTD       texMathDelimZone  $$
texCmdMathEnv            texCmdEnv         \BEGIN; \END
                                           (Only for math environments.)
texMathEnvArgName        Delimiter         \begin{EQUATION}
texCmdMath               texCmd            \ENSUREMATH
texMathDelim             Type              \LVERT
texMathDelimMod          texMathDelim      \LEFT\lvert \RIGHT\rvert
texMathOper              Operator          Basic operators: +-=/
texMathSuperSub          texMathOper       Sub and super operators (^, _)
texMathError             texError          Unmatched region endings

GROUP                DEFAULT         EXAMPLE
----------------------------------------------------------------------------
texLength            Number          Length units, e.g. "4 cm". Only when
                                     contained e.g. in option groups.
texLigature          texSymbol       --; ---; ``; ''; ,,
texCmdAccent         texCmd          \"{a}
texCmdLigature       texSpecialChar  \ss; \ae
texCmdSpaceCodeChar  Special         Catcodes. For more info, see:
                                     https://en.wikibooks.org/wiki/TeX/catcode
texCmdTodo           VimtexTodo      \TODOSOMETHING
texCmdVerb           texCmd          \VERB
texVerbZoneInline    texZone         \verb+VERB TEXT+
texVerbZone          texZone         \begin{verbatim} VERB TEXT \end{verbatim}
texCmdDef            texCmdNew       \DEF
texDefArgName        texArgNew       \def\NAME
texDefParm           texParm         \def\name #1
texCmdItem           texCmd          \item

INCLUDE EXPRESSION vimtex-includeexpr

TABLE OF CONTENTS vimtex-toc

% vimtex-include: /path/to/file

augroup vimtex_customization
  autocmd!
  autocmd FileType tex call CreateTocs()
augroup END

function CreateTocs()
  let g:custom_toc1 = vimtex#toc#new({
      \ 'layers' : ['label', 'todo'],
      \ 'todo_sorted' : 0,
      \ 'show_help' : 0,
      \ 'show_numbers' : 0,
      \ 'mode' : 4,
      \})
  nnoremap <silent> \ly :call g:custom_toc1.open()<cr>

  let g:custom_toc2 = vimtex#toc#new({
      \ 'layers' : ['include'],
      \ 'show_help' : 0,
      \})
  nnoremap <silent> \lY :call g:custom_toc2.open()<cr>
endfunction

DENITE AND UNITE SOURCES vimtex-denite

nnoremap <localleader>lt :<c-u>Denite vimtex<cr>
nnoremap <localleader>lt :<c-u>Unite vimtex<cr>

FZF INTEGRATION vimtex-fzf

:call vimtex#fzf#run('cl')

:call vimtex#fzf#run('ctli', g:fzf_layout)

FZF-LUA INTEGRATION vimtex-fzf-lua

SNACKS INTEGRATION vimtex-snacks

Snacks.picker "vimtex_toc"

Snacks.picker("vimtex_toc", {
  layers = "ctl",
  layout = { preset = "dropdown" },
})

vim.keymap.set("n", "<localleader>lt", function()
  return require("vimtex.snacks").toc()
end)

COMPILER vimtex-compiler

LATEXMK vimtex-compiler-latexmk

$compiling_cmd = "xdotool search --name \"%D\" " .
                 "set_window --name \"%D compiling...\"";
$success_cmd   = "xdotool search --name \"%D\" " .
                 "set_window --name \"%D OK\"";
$failure_cmd   = "xdotool search --name \"%D\" " .
                 "set_window --name \"%D FAILURE\"";

LATEXRUN vimtex-compiler-latexrun

TECTONIC vimtex-compiler-tectonic

let g:vimtex_compiler_method = 'generic'
let g:vimtex_compiler_generic = {
      \ 'command': 'ls *.tex | entr -c tectonic /_ --synctex --keep-logs',
      \}

ARARA vimtex-compiler-arara

TEXPRESSO vimtex-compiler-texpresso

killall -SIGUSR1 texpresso

GENERIC COMPILER vimtex-compiler-generic

SYNTAX CHECKING (LINTING) vimtex-lint

GRAMMAR CHECKING vimtex-grammar

:compiler {checker}|lmake

TEXTIDOTE vimtex-grammar-textidote

VLTY vimtex-grammar-vlty

sudo pacman -S languagetool

pip install --user yalafi

let g:vimtex_grammar_vlty = {'lt_directory': 'path/to/LanguageTool'}
set spelllang=en_gb

let g:vimtex_grammar_vlty = {'lt_command': 'languagetool'}
set spelllang=en_gb

VIEW vimtex-view

VIEWER CONFIGURATION vimtex-view-configuration

let g:vimtex_view_general_viewer = 'evince'

let g:vimtex_view_method = 'galley'

defaults write com.github.munepi.galley customEditorCommand \
    "/path/to/vim -v --not-a-term -T dumb -c \"VimtexInverseSearch %line '%file'\""

defaults write com.github.munepi.galley customEditorCommand \
    "/path/to/nvim --headless -c \"VimtexInverseSearch %line '%file'\""

let g:vimtex_view_method = 'mupdf'

let g:vimtex_view_general_viewer = 'okular'
let g:vimtex_view_general_options = '--unique file:@pdf\#src:@line@tex'

vim -v --not-a-term -T dumb -c "VimtexInverseSearch %l '%f'"

nvim --headless -c "VimtexInverseSearch %l '%f'"

let g:vimtex_view_general_viewer = 'qpdfview'
let g:vimtex_view_general_options
  \ = '--unique @pdf\#src:@tex:@line:@col'

vim -v --not-a-term -T dumb -c "VimtexInverseSearch %2 '%1'"

nvim --headless -c "VimtexInverseSearch %2 '%1'"

let g:vimtex_view_method = 'sioyek'

let g:vimtex_view_method = 'skim'

vim -v --not-a-term -T dumb -c "VimtexInverseSearch %line '%file'"

nvim --headless -c "VimtexInverseSearch %line '%file'"

Command = /opt/homebrew/bin/nvim
Arguments = --headless -c "VimtexInverseSearch %line '%file'"

let g:vimtex_view_general_viewer = 'SumatraPDF'
let g:vimtex_view_general_options
    \ = '-reuse-instance -forward-search @tex @line @pdf'

InverseSearchCmdLine = cmd /c start /min "" vim -v --not-a-term -T dumb -c "VimtexInverseSearch %l '%f'"

let g:vimtex_view_method = 'texshop'

chmod +x /usr/local/bin/othereditor

" Main variant with xdotool
let g:vimtex_view_method = 'zathura'

" For simple variant without xdotool
let g:vimtex_view_method = 'zathura_simple'