doc/language.txt — rendered from the plugin's own vimdoc
*language.txt* Spell, grammar and translation tooling *language.nvim* language.nvim manual~ Author: Stefan Bartl
CONTENTS
1. Introduction ......................... |language-introduction| 2. Requirements ......................... |language-requirements| 3. Setup ................................ |language-setup| 4. Commands ............................. |language-commands| 5. Scoping .............................. |language-scoping| 6. Spell providers ...................... |language-spell-providers| 7. Translate engines .................... |language-translate-engines| 8. The review panel ..................... |language-panel| 9. Configuration ........................ |language-config| 10. Health ............................... |language-health|
1. INTRODUCTION
language.nvim bundles three text-language tools behind a small set of commands:
:Spellcheck spelling + grammar review, worked through in one place
:Translate translate a range/selection, shown in a popup (default)
:TranslateReplace translate a range/selection and replace it in place
:TranslateOffice translate a .pptx / .docx into a copy next to it
It is built on lib.nvim as a hard dependency — including for UI (the
translation popup, pickers, menus use ui.kit). Translation is
native — no external Neovim plugin is required; only curl (the default
Google engine is keyless and works out of the box).
Both domains share one explicit scope model (|language-scoping|) and run
long/blocking work asynchronously with cancellation and timeouts.
2. REQUIREMENTS
- Neovim >= 0.9 (0.10+ recommended for vim.system)
- WKDSteve/lib.nvim
- curl (for translation)
- Optional: folke/trouble.nvim (nicer list; pcall-guarded)
- Optional spell CLIs: typos, cspell, codespell
- Optional grammar LSP: harper_ls, ltex
- Optional: trans (translate-shell) for the "shell" engine
3. SETUP
require("language").setup({})
Call once. See |language-config| for the full option tree. With lazy.nvim:
{
"WKDSteve/language.nvim",
dependencies = { "WKDSteve/lib.nvim", "folke/trouble.nvim" },
event = "VeryLazy",
config = function() require("language").setup({}) end,
}
4. COMMANDS
Each command is its own lib.nvim.bindings.usercmd.composer verb (a flat root route, no subcommand tree). An unrecognized--flagon :Translate/:TranslateReplace now reports a clear error instead of being silently ignored, as it was before this command layer was rebuilt on the composer; dispatch for valid input is otherwise unchanged. Likewise, a positional token that is neither the language nor a recognized scope word (typically a typo, e.g.selctionforselection) is reported as an error rather than silently dropped and defaulting to the whole-buffer scope. *:Spellcheck* :Spellcheck [lang] [scope|verb] Run a spell/grammar review. Optional first argument is a language code (e.g.en,de,en,de). The scope/verb may be one of: buffer current buffer (default) visible the visible window range only cwd recursively across the working directory path=<p> a file or directory clear end the session, remove diagnostics refresh re-scan the current buffer session Examples:
:Spellcheck
:Spellcheck en cwd
:Spellcheck de path=~/notes
:Spellcheck clear
*:Translate* :[range]Translate <lang> [--nocode] [--output=<mode>] [scope] Translate the given range/selection to <lang> and **show the result** without touching the buffer (default output:popup, a read-only, focusable, closable (q/<Esc>)ui.kitfloat near the cursor — scroll/yank freely, nothing is written back). Options: --nocode skip fenced code blocks and inline-code lines (only takes effect together with --output=replace) --output=<mode> popup (default) | replace | buffer | vsplit | split | tab | insert | clipboard | notify --files=<mode> output mode when scope is cwd/path=<p> — see |language-translate-files| scope selection (default with a range) | buffer | cwd | path=<p> (a file or directory) | cword (the word under the cursor, character-exact throughrun_region) Examples:
:Translate DE cword " the word under the cursor, in the popup
:'<,'>Translate DE " popup near the cursor, buffer untouched
:Translate EN --output=vsplit " open the translation in a vertical split
:Translate FR --output=buffer " open the translation in a new buffer
*:TranslateOffice* :TranslateOffice <file> <lang> Translate a PowerPoint (.pptx) or Word (.docx) file into the copy <name>.<lang>.<ext> next to it; the original is never written. Text runs of a paragraph are translated as one sentence, formatting stays. Needs unzip, bsdtar or 7z to unpack and zip, bsdtar or 7z to pack. *:TranslateReplace* :[range]TranslateReplace <lang> [--nocode] [scope] Translate the given range/selection to <lang> and **replace it in place** — the direct, mutating counterpart to :Translate (this is what :Translate did before language.nvim gained a non-mutating default; the name/behavior matches the classic:TranslateReplace). Always replaces; there is no--output=.--nocodeskips fenced code blocks and inline-code lines.scopeisselection(default with a range) |buffer|cwd|path=<p>— forcwd/path=<dir>this picks and overwrites multiple files in place, forpath=<file>that one file (both with a confirmation prompt), see |language-translate-files|. Examples:
:'<,'>TranslateReplace DE
:TranslateReplace EN --nocode
:TranslateReplace DE cwd " pick files, overwrite in place
The target span/file is re-verified against its current content
immediately before writing; if it changed while the translation was in
flight (an edit elsewhere, another process touching the file), the write
is skipped and reported rather than blindly overwriting newer content.
Both :Translate and :TranslateReplace preserve each line's leading indentation
across the round trip: providers (notably Google's gtx endpoint) normalize
away leading whitespace, so a translated list item like - foo would
otherwise come back as - bar with the indent dropped to column 0. The indent
is stripped before the request and re-applied to the matching output line
(skipped when the provider merges/splits lines, since the 1:1 mapping no longer
holds).
*:Translate!*
:[range]Translate![lang]
Open the interactive translation window (|language-translate-window|),
prefilled from the range if given. The target is [lang], else
translate.default_target, else a picker.
*language-translate-files*
:Translate <lang> cwd
:Translate <lang> path=<p> [--files=<mode>]
:TranslateReplace <lang> cwd
:TranslateReplace <lang> path=<p>
path=<p> is a file or a directory; a path that does not exist is
reported as an error. A single file is translated directly, without the
chooser, with the same output modes below.
Translate multiple files. Gathers translatable files under the directory
(by translate.files.extensions, skipping .git/node_modules/…), opens a
multi-select chooser (<Tab> to toggle, <CR> to confirm), then translates
each picked file. Output per file:
suffix write a sibling name.<LANG>.ext (default, non-destructive)
replace overwrite the file in place (asks for confirmation first)
buffers open each translation in a scratch buffer (no disk write)
:Translate … --files=<mode> overrides translate.files.output for one
call; :TranslateReplace … cwd|path=<p> always forces replace.
Note: --nocode code-skipping applies to buffer/selection translation,
not to whole-file translation. In replace mode, each file is
re-verified against its on-disk content immediately before it is
overwritten; a file that changed during its (sequential, one-at-a-time)
translation is skipped rather than overwritten, and the final summary
counts files actually written, not files picked. If the directory walk
that gathers translatable files fails partway (permissions, a vanishing
entry, …), the file list may be incomplete rather than "this directory
has nothing to translate" going unremarked; a notify warning names the
directory and the reason.
*language-translate-subtitles*
Subtitles (SRT and WebVTT)
Subtitle text is recognised by file name (.srt, .vtt), filetype, or,
in an unnamed buffer, by a WEBVTT header or by being made of cue blocks
only (each block opens with a timing line, or with an index line followed
by one); one prose paragraph, and the text is prose. A pasted fragment
may start in the middle of a cue (its first block, the cue's text tail,
is translated, when at least two whole cues follow) and may end with the
index of the next cue. Only the text
lines of each cue are translated; the index, the timing line, the WEBVTT
header and NOTE/STYLE/REGION blocks are copied byte for byte. Tags
(<i>, <c.class>, <v Name>, <00:00:01.000>) and {\an8}
overrides are protected and put back. All cues go out in one request,
separated by blank lines; a cue with several lines stays together.
This applies to every way of translating: :Translate,
:TranslateReplace (also with --nocode, which is not needed), the
window, and cwd/path= (srt and vtt are in
translate.files.extensions). There is no switch. A cue whose tags the
engine damaged keeps its source text and is reported; an engine answer
with another line structure writes nothing. A range without any cue
text is reported, not shown as its own translation.
A sentence that runs across two cues is translated cue by cue.
*language-hover*
The word under the cursor (hover.nvim)
With hover.nvim installed,:Hover showover a word answers with its translation in the hover float. Optional in both directions: without hover.nvim nothing registers and nothing is missing. - Only on request. The contribution ison_request, so the automatic hover trigger never sends the word under the cursor to a translation endpoint; only:Hover show(or a key bound to it) does. - Target language:translate.default_target, elseEN. - It waits for the answer, at most 2 seconds (hover.nvim asks synchronously); a failure is shown in the float, not as an error. -hover = falsein |language-config| switches it off. -:checkhealth languagereports whether it is registered and flaggedon_request.:Translate <lang> cwordis the same word into a language you name, in the popup. See docs/FEATURES/HOVER.md. *language-tree*
A file or folder in a tree view (filetree.nvim)
setup()registers two actions atlib.nvim.tree.registry. The own tree of filetree.nvim (adapter = "native") offers them on every file and folder, in its context menu and its action list: language.check:Spellcheck path=<node>language.translate:Translate <lang> path=<node>; the language istranslate.default_target, else chosen fromtranslate.default_langs- The path of the node is taken as it is (blanks,$), not through thepath=<p>token of a command line. - With several nodes marked the action runs on the first and says so. -tree = { key = { check = "<lhs>", translate = "<lhs>" } }in |language-config| also puts them on keys in the tree buffer;tree = falsedoes not offer them. Without a tree that reads the registry nothing changes.
5. SCOPING
Every action operates over an explicit scope, parsed once from the command
arguments:
buffer whole current buffer
visible only the visible window range (fast; good for live scanning)
cwd recursively across the working directory (always async)
path=<p> a file OR a directory (recursive)
selection a visual/line range (mainly for :Translate)
cword the word under the cursor (:Translate; character-exact through
run_region, see |language-hover|)
path=<p> expands ~ and environment variables only (not Vim's %/#/
<cfile>/<cword> specials, and no shell/backtick command substitution) —
exactly what a path typed on a command line needs, nothing more.
For cwd/path scopes with many files, an external CLI spell provider is
preferred (one process over the tree, fastest); otherwise the native scanner
recursively walks the directory on disk (not just already-open buffers),
async and chunked (20 files per tick) so the editor never freezes. Live
(unsaved) buffer content is used for files that happen to be open; closed
files are read fresh from disk. Vendor directories (.git, node_modules, .venv,
dist, build, target, .cache, __pycache__) are skipped, as are files above 5 MB
or spell.max_file_lines.
6. SPELL PROVIDERS
native Neovim's ownvim.spell(always available). Respects'spelllang'. Splits CamelCase/snake_case identifiers and only reports genuinely misspelled subwords; restricts checking to Treesitter @spell regions (comments/strings/prose) and skips URLs/emails. For cwd/path scopes it recursively scans every matching file on disk (see |language-scoping|), not only already-open buffers. typos fast tree-wide scanning via thetyposCLI (async), used for cwd/path scopes when available. cspell, external CLIs (opt-in) for cwd/path scopes. codespell All three exit non-zero on a normal "found something" run, so a genuine failure (the process times out, never starts, or crashes) is told apart by producing no output at all rather than by its exit code; that case is reported via notify instead of showing as a clean 0-issue scan. cspell_server a persistent Node sidecar that keeps cspell-lib loaded, for fast, code-aware, live buffer checks (needs node + cspell). Opt in by adding "cspell_server" tospell.providers.buffer. If it never starts, dies, or a check exceeds its ~6s guard, the other configured providers' results are still shown; a one-time-per-session notify warns that cspell's own contribution is missing, rather than that being silent. harper/ltex grammar diagnostics from a running language server are harvested and shown alongside spelling issues (kind = grammar). custom escape hatch for a checker without a bundled adapter (cwd/path scopes). Configure `spell.providers.custom = { cmd = fun(scope, cfg) -> argv, parse = fun(out, base) -> partial-issue[] }` and add "custom" tospell.providers.cwd.parsereturns a list of `{ path, lnum, col, end_col?, word, kind?, message?, suggestions? };bufnr/source` are filled in automatically. Mirrorstranslate.custom. Acmd/parsethat throws, returns the wrong shape, or whose entries are missingword/pathis reported via notify rather than read as a clean (issue-free) scan. Which providers run per scope is controlled byspell.providers(see |language-config|).
7. TRANSLATE ENGINES
google default, keyless (only curl). Modern gtx endpoint.
deepl official DeepL API. Key from translate.deepl.api_key or the
DEEPL_API_KEY environment variable. Free keys (suffix ":fx")
use api-free.deepl.com automatically.
shell the trans CLI (translate-shell).
ai ai.nvim (Claude, Ollama, OpenAI, Gemini ...), a soft
dependency; see |language-translate-ai|.
custom any CLI: provide `translate.custom = { cmd = fun(lines,
target, source) -> argv, parse = fun(stdout) -> lines }`.
A stdin field (string) of the returned argv is written to
the process instead of the command line. On Windows put
non-ASCII text there: a program without a Unicode entry
point (e.g. Git for Windows' curl.exe) receives an argv
element in the ANSI code page (ü -> 0xFC, CJK -> ?).
translate.engine selects the engine; translate.fallback is a chain tried
when the chosen engine is unavailable (e.g. deepl without a key -> google) or
when its request fails (timeout, HTTP error, no translation in the answer):
the call then goes on with the next engine of the chain, and a hint names the
one that answered. Only engines you listed are ever tried; nothing is
switched for an error of the input, and never away from the ai engine.
Large inputs are split on line boundaries (blank lines preferred) into blocks
that fit the engine, translated one after the other and joined again with the
line count unchanged, so a whole README no longer overruns the Windows
command-line limit (~32 700 characters). Budget per block, in bytes (DeepL:
bytes + 8 per line for the JSON quoting): google 15 000 (the text is a POST
body on stdin), shell and custom 6000 on Windows / 20 000 elsewhere, deepl
50 lines / 60 000. DeepL sends key and body on stdin (never argv); shell
hands the block to trans on stdin too, which translates it line by line
(one request and one timeout_ms per non-empty line).
translate.max_chars (default 0 = engine default) can only lower the budget;
translate.custom.max_bytes replaces the custom engine's budget (for a cmd
that does not put the text into argv).
Blank lines at the edge of a block are not sent (the engines trim them) and
are put back, so paragraphs are never merged. A single line over the budget is
cut at sentence ends, else at white space, and the translated pieces are
re-joined with a space into one line; only a line without any such boundary
(one giant token) fails the call, with a message naming the line.
translate.max_blocks (default 50, 0 = no limit) refuses an input that would
need more requests than that before the first one is sent.
translate.timeout_ms applies to each request, not to the whole call;
translate.deadline_ms (default 0 = none) bounds the whole call.
translate.block_pause_ms is the pause between two requests of one call
(nil = engine default: 300 ms for google and shell, whose keyless endpoint
answers a burst with HTTP 429; 0 for the others). google names HTTP 429,
another error status or an HTML page instead of JSON plainly. A block that
comes back with another line count than was sent is reported with a warning.
A failing block fails the whole call.
On Windows a .cmd/.bat launcher (not an .exe) runs through cmd.exe /c;
a command whose text contains " % ^ & | < > or a line break is
refused there instead of being run.
*language-translate-ai*
Engine ai (translate.engine = "ai"): the text goes through ai.nvim's bulk
profile (ai.ask with bulk), so ai.nvim's size and budget caps, concurrency
and strict policy apply. The request is a system prompt (target, optional
source, glossary, style; code, identifiers, URLs, {n} placeholders and
Markdown syntax unchanged) and the lines as a JSON array; the answer must be a
JSON array of the same length, every placeholder kept (a fence around it is
tolerated, nothing else). A deviation is asked once more, then the call fails
and translate_markdown keeps the original unit. A policy refusal or a bulk limit
is reported as it is, never retried, never routed to another engine; a
configured ai engine that is unusable (ai.nvim missing, provider outside the
allow-list) is an error and does not fall back to google. The unit cache of
translate_markdown includes provider, model and prompt version, so a model
switch never serves old translations.
translate = { engine = "ai", ai = {
provider = nil, model = nil, -- nil = what ai.nvim is configured with
glossary = nil, -- { Term = "Begriff" } or { "Neovim" }
style = nil, -- e.g. "formal"
max_chars = 6000, -- largest request, in characters
concurrency = 2, -- requests in flight per run
max_total_chars = 500000, -- per run (a document); false = no cap
} }
:checkhealth language shows the engine and the policy. See
docs/FEATURES/TRANSLATE.md.
*language-translate-markdown*
Markdown documents (Lua API, no command):
local h = require("language").translate_markdown(lines, {
target = "EN", -- required
-- source, engine, model (joins the cache key), token, max_chars, max_units, concurrency,
-- keep, cache, cache_only, on_unit
}, function(ok, result, info) end)
h.cancel()
resulthas exactly as many lines aslines(#result == #lines, a hard invariant). Front matter, fenced/indented code, HTML blocks, reference definitions and table delimiter rows are never sent; headings, paragraphs, list items, quotes, footnotes and every table cell are units. Inline code, link and image targets, autolinks and URLs are masked as{n}(plain ASCII: a Unicode placeholder was destroyed on the Windows curl path) and restored. Each answer is validated, retried once, and on failure the original unit stays: a failed unit is never cached. A translation is wrapped onto the line count of its source and never broken in front of a block-start token (-*+1.#>|fences).#anchorlink targets follow the translated headings. Units are cached (memory, andstdpath("cache")/language.nvim/translate_markdown.jsonunlesstranslate.markdown.disk_cache = false) and sent in batches of at mostmax_chars/max_units,concurrencyat a time.cbruns exactly once;token = { generation = n, current = fn }makes a superseded run end with(false, "stale"); a document of 2 000 lines or 64 kB or more is worked on in slices of about 8 ms (slice_ms) so the editor stays responsive;on_unit(ev)reports every finished block (first,last,lines,status);cache_only = truenever asks the engine. Config: `translate.markdown = { concurrency, max_chars, disk_cache, cache_max_kb, keep }.require("language").translate_markdown_clear_cache()` forgets the cache. See docs/FEATURES/TRANSLATE.md. *language-translate-maps* Motion / visual mappings (opt-in viatranslate.keymaps): operator<lhs>{motion}translates the moved-over text object, e.g.<lhs>ipfor a paragraph or<lhs>iwfor a word. visual<lhs>translates the current visual selection. Char-wise motions and char-wise visual selections translate and replace the exact byte span (multibyte-safe); line-wise (V) uses the whole line range. The target language istranslate.default_targetwhen set, otherwise chosen fromtranslate.default_langsvia a picker. These are rewrite-in-place operators (likegu/gq) — they always replace, independent oftranslate.default_output(which only affects :Translate).
require("language").setup({
translate = {
default_target = "DE", -- skip the picker
keymaps = { operator = "gtr", visual = "gtr" },
},
})
8. THE REVIEW PANEL
Withspell.ui.view = "picker"(default), :Spellcheck opens an interactive panel listing every issue.<CR>on an item opens its action menu: Spelling issues: Choose suggestion… pick a replacement (fuzzy) Replace all in buffer… apply a replacement to every occurrence Add to dictionary zg-equivalent (persistent or session) Ignore (session) drop this word for the session Ignore (persistent) drop this word permanently (ignore file) Jump to location go to the issue Grammar/style issues (harper_ls/ltex): Apply LSP fix… run the language server's code actions at the issue Ignore (session/persistent), Jump to location The panel list itself also has direct keys for the actions above, so common ones don't need the menu round-trip: a Add to dictionary i / I Ignore (session / persistent) L Apply LSP fix (grammar/style issues) gd, o Jump to location (closes the panel) ? Show this cheatsheet A key not applicable to the issue under cursor (e.g.aon a grammar issue) is reported rather than silently ignored. *language-translate-window*
Interactive translation window
:Translate! opens two stacked floats: an editable input (top) and a read-only
output (bottom) that translates as you type (debounced). Actions are NORMAL-mode
keys (press <Esc> first) so insert-mode typing keeps its native keys:
<C-l> change target language
<C-r> reverse: use the translation as the new input, then pick a target
(round-trip / translate onward)
<C-h> open the translation-history picker
<C-y> copy the translation to the clipboard (also records to history)
q,<Esc> close (also <C-c> in insert mode)
The window uses the configured engine/fallback like every other translation.
*language-thesaurus*
Thesaurus / synonyms
require("language").synonyms()(or the opt-inthesaurus.keymap) looks up synonyms for the word under the cursor and replaces it with your pick. The default source is the free, keyless Datamuse API (English); setthesaurus.source = "custom"withthesaurus.custom = fun(word, cb)for another source or language.
require("language").setup({
thesaurus = { keymap = "<leader>sy" }, -- opt-in
})
The word's span is re-verified right before the replacement is written; if
the text under it changed while the lookup/menu was open (an edit elsewhere,
another window), the replacement is discarded and reported instead of being
written over unrelated text. A lookup failure (the request fails, or
thesaurus.custom throws) is reported via notify rather than read as "no
synonyms for this word" -- the same distinction the CLI spell providers make
between a genuinely clean result and a broken one.
Live scanning
Setspell.live = truefor always-on inline diagnostics that update as you edit (debounced byscan_debounce_ms). It is decoupled from the panel and runs only forspell.filetypes. Withspell.live_scope = "visible"(default) it scans just the visible window range and follows the viewport; set it to "buffer" to scan the whole buffer. Themax_file_lines, readonly andmax_highlightsgates apply. Whole-buffer native scans are cached bychangedtick, so re-opening the panel or re-scanning an unchanged buffer is instant. *language-spell-silencing*
Silencing false positives
Besides the dictionary (zg / "Add to dictionary") and the ignore list, inline
directives silence spots without touching any list:
language:disable-line skip the line the directive is on
language:disable-next-line skip the following line
language:disable-file skip the whole buffer
Put them in a comment so they don't show in rendered output.
*language-spell-guard*
Block writing on errors (opt-in)
spell.guard.block_write_on_error = trueaborts:wonspell.filetypesbuffers while spelling errors remain (grammar is advisory and never blocks). Bypass a single write with:noautocmd w. *language-spell-replace-all*spell.dictionary.replace_all = true(default) makes "Choose suggestion…" in the panel apply the pick to every occurrence of the word in the buffer; set it to false to replace only the exact occurrence. After each action the panel re-scans and re-opens. Setview = "quickfix"for the classic diagnostics + quickfix/Trouble session flow with z= fixing. *language-spell-highlights*
Buffer highlights (opt-in)
Visibility normally runs entirely through|vim.diagnostic|, whose appearance follows the user's ownvim.diagnostic.config(). Setspell.highlights.enable = trueto additionally mark issues directly in the buffer via extmarks, independent of that config — useful when diagnostics virtual text/underline is muted globally or filtered elsewhere. Two highlight groups are defined (default = true, so a colorscheme or:hican override them):LanguageSpellHighlight(spelling/rare/caps) andLanguageGrammarHighlight(grammar/style).spell.highlights.styleselects"underline"(default) or"undercurl".
require("language").setup({
spell = { highlights = { enable = true, style = "undercurl" } },
})
9. CONFIGURATION
Defaults (abridged; see lua/language/config/DEFAULTS.lua):
require("language").setup({
spell = {
providers = {
buffer = { "native", "lsp" },
cwd = { "typos", "native" },
lsp = { enable = true, servers = { "harper_ls", "ltex" } },
custom = nil, -- { cmd = fun(scope,cfg)->argv, parse = fun(out,base)->issues }
},
filetypes = { "markdown","text","gitcommit","tex","rst","asciidoc","help" },
default_scope = "buffer",
live = false, live_scope = "visible", scan_debounce_ms = 400,
word_split = { enable = true, min_length = 4 },
regions = { treesitter_spell = true, skip_urls = true, skip_emails = true },
programming_dict = false,
extra_wordlists = {}, -- { ["my-list"] = { "word1", ... } }, session-only
max_highlights = 100, max_file_lines = 20000, skip_readonly = true,
ui = { view = "picker", preview = true, group_by = "file", dedupe = true },
dictionary = {
ignore_file = vim.fn.stdpath("state") .. "/language/spell_ignore.txt",
use_spellfile = true, replace_all = true,
},
highlights = { enable = false, style = "underline" }, -- opt-in buffer extmarks
keymaps = { panel = "<leader>ss", next = "]s",
fix = "<leader>z=", fix1 = "<leader>z1" },
},
translate = {
engine = "google", fallback = { "google" },
default_output = "popup", default_input = "selection",
nocode_default = false, timeout_ms = 8000,
deepl = { api_key = nil },
files = { output = "suffix" }, -- :Translate cwd/path=<p> default
},
hover = true, -- register the word-under-cursor translation with hover.nvim
tree = true, -- check / translate on a node of a tree view, |language-tree|
commands = true,
})
10. HEALTH
:checkhealth language
Reports Neovim/lib.nvim availability, spell provider tools, grammar LSP
clients, curl and DeepL key status, and 'spelllang'.