NORMAL ~/wkd/p/language/help :set skin=modern utf-8

language.txt

Spell, grammar and translation tooling — language.nvim

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 *language-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-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 *language-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 *language-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 *language-commands*

Each command is its own lib.nvim.bindings.usercmd.composer verb (a flat root route,
no subcommand tree). An unrecognized --flag on :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. selction
for selection) 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.kit float 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 through run_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=. --nocode skips fenced code blocks and
    inline-code lines. scope is selection (default with a range) |
    buffer | cwd | path=<p> — for cwd/path=<dir> this picks and
    overwrites multiple files in place, for path=<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 show over 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 is on_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, else EN.
    - 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 = false in |language-config| switches it off.
    - :checkhealth language reports whether it is registered and flagged
      on_request.
:Translate <lang> cword is 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 at lib.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 is
                        translate.default_target, else chosen from
                        translate.default_langs
    - The path of the node is taken as it is (blanks, $), not through the
      path=<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 = false does not offer them.
Without a tree that reads the registry nothing changes.

5. SCOPING *language-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 *language-spell-providers*

    native      Neovim's own vim.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 the typos CLI (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" to spell.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" to spell.providers.cwd. parse returns a list of
                `{ path, lnum, col, end_col?, word, kind?, message?,
                suggestions? }; bufnr/source` are filled in automatically.
                Mirrors translate.custom. A cmd/parse that throws,
                returns the wrong shape, or whose entries are missing
                word/path is reported via notify rather than read as a
                clean (issue-free) scan.

Which providers run per scope is controlled by spell.providers (see
|language-config|).

7. TRANSLATE ENGINES *language-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()
result has exactly as many lines as lines (#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). #anchor link targets follow the translated headings. Units are
cached (memory, and stdpath("cache")/language.nvim/translate_markdown.json
unless translate.markdown.disk_cache = false) and sent in batches of at most
max_chars / max_units, concurrency at a time. cb runs 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 = true never 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 via translate.keymaps):
    operator   <lhs>{motion} translates the moved-over text object, e.g.
               <lhs>ip for a paragraph or <lhs>iw for 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 is translate.default_target when set, otherwise chosen
from translate.default_langs via a picker. These are rewrite-in-place
operators (like gu/gq) — they always replace, independent of
translate.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 *language-panel*

With spell.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. a on 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-in thesaurus.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); set
thesaurus.source = "custom" with thesaurus.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

Set spell.live = true for always-on inline diagnostics that update as you
edit (debounced by scan_debounce_ms). It is decoupled from the panel and runs
only for spell.filetypes. With spell.live_scope = "visible" (default) it
scans just the visible window range and follows the viewport; set it to
"buffer" to scan the whole buffer. The max_file_lines, readonly and
max_highlights gates apply. Whole-buffer native scans are cached by
changedtick, 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 = true aborts :w on spell.filetypes
buffers 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. Set view = "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 own vim.diagnostic.config(). Set
spell.highlights.enable = true to 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 :hi can override
them): LanguageSpellHighlight (spelling/rare/caps) and
LanguageGrammarHighlight (grammar/style). spell.highlights.style selects
"underline" (default) or "undercurl".
    require("language").setup({
      spell = { highlights = { enable = true, style = "undercurl" } },
    })

9. CONFIGURATION *language-config*

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 *language-health*

    :checkhealth language
Reports Neovim/lib.nvim availability, spell provider tools, grammar LSP
clients, curl and DeepL key status, and 'spelllang'.

keys

j / k
next / previous line
gg / G
first / last line
⏎
open the line under the cursor
/
search plugins and apps (app: x or plugin: x narrows)
:
command line — Tab completes
:help x
vimdoc of a plugin (:e x = plugin page)
:ls · :apps · :play · :log · :stack
plugin list · app list · play area · activity stream · dependency graph
:log apps
the stream of one area (plugins or apps)
:colo x
colorscheme
:set skin=
modern | tui
?
this help
esc
close