FAQ

General Questions

What’s the difference between vscode-ltex, ltex-ls, and LanguageTool?

LT_EX uses the Language Server Protocol (LSP). The idea of the LSP is as follows: When a new programming language is invented, support for the new language (such as syntax highlighting, linting, etc.) has to be added to all existing editors. Conversely, when a new text editor is created, support for all existing languages has to be added to the new editor.

The LSP solves this by separating the language support from the editor support. For each language, an editor-independent language server has to be written. Compatible editors only have to implement a single language client, with lightweight boilerplate code for each language.

In the case of LT_EX, the “language” is not a single natural language, but all natural languages supported by LanguageTool.

• vscode-ltex is an extension for Visual Studio Code that implements a language client. When a L^AT_EX or Markdown document should be checked, it is passed to ltex-ls.
• ltex-ls (LT_EX LS) is an editor-independent language server (although it has only been tested with VS Code) written in Kotlin. Incoming L^AT_EX or Markdown code is parsed, converted to plaintext, and passed to LanguageTool.
• LanguageTool is a grammar and spell checker written in Java. It can be used via its Java API or standalone. LanguageTool is responsible for the actual checking.

When talking about LT_EX, we usually mean the combination of vscode-ltex (or another editor extension) and ltex-ls.

Why does LT_EX have such a high CPU load?

LanguageTool is not only a simple spell checker that just looks up some words in a dictionary. It is a powerful grammar checker that checks thousands of grammar rules at once. This means that checking a document for the first time, either after activating the LT_EX extension or after opening a document to be checked, may take a while. The exact duration depends on the length of the document and the power of the computer, but it is usually around 30 seconds and may be up to two minutes. After this initial check, edits are checked very quickly due to the feature of sentence caching (see ltex.sentenceCacheSize), and should not cause any significant CPU load.

How can I check multiple languages at once?

This depends on whether the multiple languages only occur in different files (i.e., every file is written in a single language), or whether multiple languages occur in one file.

• If you are using L^AT_EX, you can use the babel package to indicate the languages used. This allows LT_EX to switch the checking language mid-file.
• Another way, which also works for Markdown, is using magic comments.
• If each file is written in a single language, it is possible to use multi-root workspaces. This enables you to have one settings.json per folder, and allows you to set ltex.language just for that folder.

Why does LT_EX check in a different language than expected?

ltex.language is not the only source that LT_EX uses to decide in which language to check a document:

• For L^AT_EX documents: Commands or environments of the babel package (note that LT_EX is not a L^AT_EX compiler, e.g., it won’t detect if the babel command is inside a \newcommand definition)
• For Markdown documents: lang variable in YAML front matter
• For all supported document types: Magic comments

How can I fix multiple spelling errors at the same time?

If you have a technical text with many unknown words, adding them one by one to the user dictionary can be tedious. To add multiple words at once, select text that contains the words and execute the Add all unknown words in selection to dictionary quick fix, which you can select by pressing Ctrl+. (control and period keys together). Similarly, you can execute the other quick fixes for multiple words at once:

• Replace multiple occurrences of the same misspelled word
• Ignore all errors in the selection
• Disable all LanguageTool rules with matches in the selection

How can I prevent \text{...} in math mode from producing false positives?

Many L^AT_EX authors use \text for subscripts and superscripts, e.g., $h_{\text{up}}$. In some languages, LT_EX might display spelling errors as it thinks up is a part of the sentence structure. More specifically, LT_EX feeds all text in L^AT_EX’s text mode to LanguageTool after replacing all math mode formulae with placeholders. Since \text switches to text mode, its contents will be included in the check.

However, for subscripts and superscripts in L^AT_EX, \text should not be used. The reason is that contents of \text will be typeset according to the current text font, which might be bold or italic (e.g., in a standard “proposition” environment), leading to wrong bold or italic subscripts and superscripts. Instead of \text, \mathrm (or \mathsf, if you are using a sans-serif math font) should be used. This will also eliminate the false positive produced by LT_EX. Use \text only for real text, i.e., only in places where you could semantically close the formula and open another one after the text.

What does LT_EX stand for?

LT_EX is a portmanteau word from LT (LanguageTool) and T_EX/L^AT_EX. T_EX itself is an abbreviation of the Greek “τέχνη” (art/craft), while L^AT_EX is short for “Lamport T_EX” after its creator Leslie Lamport. The X is pronounced like the “ch” in “loch”.

Where can I ask a question that’s not answered here?

Head over to our GitHub repo! Before you open an issue, be sure to read the instructions on contributing.

Questions about vscode-ltex

How can I prevent vscode-ltex from redownloading ltex-ls after every update?

As explained above, ltex-ls is a necessary component of LT_EX. Due to file size restrictions of the Visual Studio Marketplace, it is not possible to include ltex-ls in the extension itself. You can install ltex-ls locally on your computer by setting ltex.ltex-ls.path. However, this is not recommended as automatic updates of LT_EX might break compatibility with ltex-ls.

Where does vscode-ltex save its settings (e.g., dictionary, false positives)?

Most settings are saved in the settings.json files of VS Code (press Ctrl+, to open them).

Some settings, such as when you add a word to the dictionary or when you hide a false positive, are saved by default to external setting files. The locations depend on your system, but they usually look as follows:

• Linux:
  • If no workspace is open: /home/USERNAME/.config/Code/User/globalStorage/valentjn.vscode-ltex
  • If a workspace is open: /PATH_TO_WORKSPACE/.vscode
• Windows:
  • If no workspace is open: C:\Users\USERNAME\AppData\Roaming\Code\User\globalStorage\valentjn.vscode-ltex
  • If a workspace is open: C:\PATH_TO_WORKSPACE\.vscode

How can I map the Use '...' quick fix to a keyboard shortcut in VS Code?

Execute the command Preferences: Open Keyboard Shortcuts (JSON) from the Command Palette (Ctrl+Shift+P) and add the following JSON object to the file that opens:

{
  "key": "ctrl+alt+p",
  "command": "editor.action.codeAction",
  "args": {
    "kind": "quickfix.ltex.acceptSuggestions"
  }
}

Now, you can press Ctrl+Alt+P at an underlined word to run the Use '...' quick fix (without having to press Ctrl+. first). If there is only one suggestion, VS Code will use it without any further keystrokes. If there are multiple suggestions, a context menu will open that only contains the Use '...' quick fixes.