Ce guide met en place un correcteur grammatical local complet sous Linux :
LanguageTool dans Docker, l’extension LanguageTool pour Firefox, WritingTool dans LibreOffice,
les modèles n-grams français et anglais, la détection de langue fastText et la mise à jour automatique
de WritingTool avec Topgrade.

La configuration a été validée sous une distribution Arch avec Xfce, Firefox et LibreOffice.
Elle convient directement à EndeavourOS, CachyOS et Manjaro avec seulement de petites différences
dans le gestionnaire AUR utilisé.

Architecture

Firefox
   |
   +-- LanguageTool Firefox
          |
          +-- http://127.0.0.1:8010/v2
                   |
                   +-- LanguageTool Docker
                        + n-grams anglais
                        + n-grams français
                        + fastText

LibreOffice
   |
   +-- WritingTool
        + LanguageTool
        + Hunspell
        + règles de style personnalisées

Tout le traitement grammatical reste sur la machine.
Le serveur LanguageTool n’est exposé que sur 127.0.0.1.

1. Installer les prérequis

Sur EndeavourOS, CachyOS et Manjaro :

sudo pacman -Syu --needed \
  docker \
  docker-compose \
  curl \
  jq \
  firefox \
  libreoffice-still \
  libreoffice-still-fr \
  jre17-openjdk \
  hunspell-en_us \
  hunspell-fr-classical

On peut remplacer hunspell-fr-classical par une autre variante du dictionnaire français
si on le souhaite.

Démarrer Docker :

sudo systemctl enable --now docker

Vérifier :

docker ps

La suite suppose que cette commande fonctionne depuis le compte utilisateur courant.

2. Installer LanguageTool dans Docker

On utilise l’image :

meyay/languagetool:latest

Créer les répertoires :

mkdir -p ~/docker/languagetool/{ngrams,fasttext}
cd ~/docker/languagetool

Créer le fichier .env :

printf 'LT_UID=%s\nLT_GID=%s\n' \
  "$(id -u)" "$(id -g)" \
  > .env

Créer compose.yml :

cat > compose.yml <<'EOF'
services:
  languagetool:
    image: meyay/languagetool:latest
    container_name: languagetool

    restart: unless-stopped

    user: "${LT_UID}:${LT_GID}"

    read_only: true

    tmpfs:
      - /tmp:exec

    cap_drop:
      - ALL

    security_opt:
      - no-new-privileges:true

    ports:
      - "127.0.0.1:8010:8081"

    environment:
      download_ngrams_for_langs: en,fr
      langtool_languageModel: /ngrams
      langtool_fasttextModel: /fasttext/lid.176.bin

      JAVA_XMS: 512m
      JAVA_XMX: 2g

    volumes:
      - ./ngrams:/ngrams
      - ./fasttext:/fasttext
EOF

Lancer le conteneur :

docker compose up -d

Suivre le premier démarrage :

docker logs -f languagetool

Le premier lancement peut prendre du temps : les modèles n-grams sont volumineux.
Sur notre installation de référence, ils occupaient environ :

• 15 Gio pour l’anglais ;
• 3,2 Gio pour le français ;
• 126 Mio pour le modèle fastText.

Vérifier ensuite :

docker ps --filter name=languagetool

3. Tester LanguageTool

Test du serveur :

curl -fsS \
  http://127.0.0.1:8010/v2/healthcheck

Test grammatical français :

curl -s -X POST \
  'http://127.0.0.1:8010/v2/check' \
  --data-urlencode 'language=fr' \
  --data-urlencode 'text=Bonjour, ceci est un teste.' \
  | jq

LanguageTool doit détecter l’erreur sur teste et proposer notamment test.

4. Vérifier fastText

Le modèle fastText sert à détecter automatiquement la langue.
C’est particulièrement utile si on alterne français et anglais américain.

curl -s -X POST \
  'http://127.0.0.1:8010/v2/check' \
  --data-urlencode 'language=auto' \
  --data-urlencode 'text=Bonjour, ceci est une phrase écrite en français.' \
  | jq '.language.detectedLanguage'

On doit obtenir une réponse contenant notamment :

{
  "code": "fr",
  "source": "fasttext"
}

Tester également l’anglais :

curl -s -X POST \
  'http://127.0.0.1:8010/v2/check' \
  --data-urlencode 'language=auto' \
  --data-urlencode 'text=This sentence is written in American English.' \
  | jq '.language.detectedLanguage'

5. Configurer l’extension LanguageTool dans Firefox

Installer l’extension officielle LanguageTool pour Firefox.

Si plusieurs profils Firefox sont utilisés, les réglages doivent être reproduits dans chaque profil.
La copie directe des bases IndexedDB de l’extension n’est pas fiable.

Adresse du serveur

Dans le champ permettant d’utiliser son propre serveur LanguageTool, saisir :

http://127.0.0.1:8010/v2

Le /v2 est important.

Avec uniquement :

http://127.0.0.1:8010

l’extension Firefox 11.3.1 envoyait :

POST /check

et LanguageTool répondait :

400 Bad Request

Avec :

http://127.0.0.1:8010/v2

la requête devient :

POST /v2/check

et le serveur répond correctement en HTTP 200.

Pour vérifier :

docker logs --since 1m languagetool 2>&1 \
  | grep -E 'Handling POST|Check done|sending code'

6. Réglages LanguageTool conseillés dans Firefox

Configuration utilisée :

• Mode méticuleux : activé
• Correction automatique : activée
• Tous les domaines : activés
• Langue maternelle : français
• Langues préférées : français + anglais
• Variété anglaise : English (US)
• Limiter la détection aux langues préférées : activé
• Raccourci IA : désactivé
• Menu contextuel : activé
• Synonymes au double clic : activés

Le dictionnaire personnel de l’extension peut bien sûr rester actif.

7. Installer WritingTool dans LibreOffice

WritingTool ajoute à LibreOffice une interface de correction plus complète et utilise LanguageTool
pour la grammaire et le style.

Vérifier Java :

java -version

Java 17 ou supérieur convient.

Si LibreOffice ne détecte pas Java :

Outils
  → Options
  → LibreOffice
  → Avancé

Sélectionner ensuite le runtime Java disponible.

8. Mettre WritingTool à jour automatiquement

Plutôt que dépendre du catalogue d’extensions LibreOffice, on récupère la dernière version directement
depuis les releases officielles WritingTool.

Créer le script :

mkdir -p ~/.local/bin

cat > ~/.local/bin/update-writingtool <<'EOF'
#!/usr/bin/env bash
set -euo pipefail

REPO="writingtool-org/writingtool"
EXT_ID="org.openoffice.writingtool.oxt"

if pgrep -x soffice.bin >/dev/null 2>&1; then
    echo "WritingTool: LibreOffice est ouvert, mise à jour ignorée."
    exit 0
fi

json="$(
    curl -fsSL \
      -H 'Accept: application/vnd.github+json' \
      "https://api.github.com/repos/${REPO}/releases/latest"
)"

latest="$(
    jq -r '.tag_name // empty' <<<"$json" \
    | sed 's/^v//'
)"

url="$(
    jq -r '
      .assets[]
      | select(.name | test("\\.oxt$"))
      | .browser_download_url
    ' <<<"$json" \
    | head -1
)"

if [[ -z "$latest" || -z "$url" ]]; then
    echo "WritingTool: impossible de déterminer la dernière release."
    exit 1
fi

installed="$(
    unopkg list 2>/dev/null \
    | awk -v id="$EXT_ID" '
        $0 ~ "Identifier: " id {
            found=1
            next
        }

        found && /Version:/ {
            sub(/^.*Version:[[:space:]]*/, "")
            print
            exit
        }

        found && /^Identifier:/ {
            exit
        }
    '
)"

if [[ "$installed" == "$latest" ]]; then
    echo "WritingTool: OK ($installed)"
    exit 0
fi

tmp="$(mktemp --suffix=.oxt)"
trap 'rm -f "$tmp"' EXIT

echo "WritingTool: ${installed:-non installé} -> $latest"

curl -fL --retry 3 \
  "$url" \
  -o "$tmp"

unopkg add --force "$tmp"

echo "WritingTool: mise à jour terminée."
EOF

chmod +x ~/.local/bin/update-writingtool

Lancer une première fois :

~/.local/bin/update-writingtool

Vérifier ensuite :

unopkg list \
  | grep -A4 -B2 'org.openoffice.writingtool.oxt'

9. Configurer LibreOffice

Dans :

Outils
  → Options
  → Langues et locales
  → Linguistique

La configuration utilisée est :

• WritingTool : activé
• Hunspell : activé
• LanguageTool Remote Checker : désactivé
• Grammalecte grammar checker : désactivé
• Graphspell grammar checker : désactivé

Grammalecte peut rester installé pour ses autres outils, mais mieux vaut éviter de faire tourner
plusieurs moteurs grammaticaux simultanément.

10. Adresse LanguageTool dans WritingTool

Attention : WritingTool ne demande pas nécessairement la même forme d’URL que l’extension Firefox.

Dans WritingTool, le serveur local utilisé est :

http://127.0.0.1:8010

Alors que Firefox utilise :

http://127.0.0.1:8010/v2

Récapitulatif :

Firefox
http://127.0.0.1:8010/v2

WritingTool
http://127.0.0.1:8010

API LanguageTool directe
http://127.0.0.1:8010/v2/check

C’est un détail important : une mauvaise variante d’URL peut provoquer des erreurs HTTP 400.

11. Réglages WritingTool

Pour les règles grammaticales, mieux vaut conserver les réglages par défaut et éviter d’activer
aveuglément toutes les règles.

Pour les catégories françaises de style :

Anglicismes non adaptés     ON
Archaïsmes                  OFF
Calques                     ON
Pléonasmes                  ON
Règles de base              ON
Régionalismes               OFF
Répétitions                 ON
Style                       ON
repetitions style           ON
style rules                 ON

Règles pratiques conservées :

Paragraphe > 220 mots       ON
Phrase > 40 mots            ON
Synonymes mots répétés      ON

Dans cette configuration, la règle « écriture inclusive » est désactivée.

12. IA dans Firefox et WritingTool

Pour cette installation :

IA LanguageTool Firefox     désactivée
IA WritingTool              désactivée

La correction repose ici sur LanguageTool, WritingTool et Hunspell.
Un modèle local peut être ajouté plus tard séparément si nécessaire.

13. Installer Topgrade

Topgrade permet de centraliser les mises à jour du système et d’exécuter des commandes personnalisées.

Avec Paru :

paru -S topgrade-bin

Avec Yay :

yay -S topgrade-bin

Avec Pamac :

pamac build topgrade-bin

14. Ajouter WritingTool à Topgrade

Créer ou modifier :

~/.config/topgrade.toml

Ajouter :

[commands]
"WritingTool" = "~/.local/bin/update-writingtool"

Si une section [commands] existe déjà, ajouter seulement la ligne WritingTool.
Il ne faut pas créer deux sections [commands].

Tester :

~/.local/bin/update-writingtool

Exemple de sortie :

WritingTool: OK (26.7)

Si LibreOffice est ouvert :

WritingTool: LibreOffice est ouvert, mise à jour ignorée.

Le prochain passage de Topgrade réessaiera.

15. Gérer aussi les conteneurs Docker avec Topgrade

Dans ~/.config/topgrade.toml :

[containers]
runtime = "docker"
use_sudo = false

Cela convient si :

docker ps

fonctionne déjà sans sudo.

L’image LanguageTool utilise :

meyay/languagetool:latest

Les volumes n-grams et fastText restent conservés lors des mises à jour du conteneur.

16. Mise à jour complète

La commande habituelle devient simplement :

topgrade

Elle peut alors couvrir notamment :

• les paquets Arch ;
• Firefox ;
• LibreOffice ;
• les images Docker ;
• LanguageTool ;
• WritingTool via la commande personnalisée.

17. Vérification rapide sur une nouvelle machine

echo "=== Docker ==="
docker ps --filter name=languagetool

echo
echo "=== Healthcheck ==="
curl -fsS \
  http://127.0.0.1:8010/v2/healthcheck
echo

echo
echo "=== Français + fastText ==="
curl -s -X POST \
  'http://127.0.0.1:8010/v2/check' \
  --data-urlencode 'language=auto' \
  --data-urlencode 'text=Bonjour, ceci est un teste.' \
  | jq '{
      version:.software.version,
      detected:.language.detectedLanguage,
      matches:[.matches[].rule.id]
    }'

echo
echo "=== WritingTool ==="
unopkg list \
  | grep -A4 -B2 'org.openoffice.writingtool.oxt'

On doit retrouver quelque chose de ce genre :

Docker              Up
Healthcheck          OK
LanguageTool         6.8
Détection            fr / fasttext
WritingTool          installé

18. Diagnostic Firefox : erreur 400

Si Firefox affiche :

Un problème est survenu lors de la vérification de votre texte. (400)

Lancer immédiatement :

docker logs --since 2m languagetool

Si on trouve :

Handling POST /check
...
sending code 400

le serveur Firefox a probablement été configuré sans /v2.

Corriger en :

http://127.0.0.1:8010/v2

Le résultat correct est :

Handling POST /v2/check
...
sending code 200

19. Diagnostic LibreOffice

Vérifier :

java -version
libreoffice --version
unopkg list | grep -A4 -B2 WritingTool

WritingTool ne doit pas être mis à jour pendant que LibreOffice est ouvert.

Un ancien verrou LibreOffice peut parfois rester ici :

~/.config/libreoffice/4/.lock

Avant de le supprimer, toujours vérifier qu’aucun processus LibreOffice n’est actif :

pgrep -af 'libreoffice|soffice'

20. Xfce : problème de thème LibreOffice

Sur certaines anciennes installations Xfce, LibreOffice peut afficher des listes ou menus noirs,
illisibles ou mal dessinés.

Dans notre cas, le problème venait du thème GTK :

Materia-light

Le passage à :

Matcha-light-azul

a corrigé immédiatement l’affichage.

LibreOffice utilisait déjà normalement le backend GTK3 :

libvclplug_gtk3lo.so

Il n’était donc pas nécessaire de forcer durablement :

SAL_USE_VCLPLUGIN=qt6

21. Fichiers à sauvegarder pour migrer vers un autre ordinateur

Les fichiers importants sont essentiellement :

~/docker/languagetool/compose.yml
~/docker/languagetool/.env
~/.local/bin/update-writingtool
~/.config/topgrade.toml

On peut également sauvegarder :

~/docker/languagetool/ngrams
~/docker/languagetool/fasttext

mais ce n’est pas obligatoire : le conteneur peut les télécharger à nouveau.

Pour Firefox, refaire les réglages de l’extension dans chaque profil reste plus fiable que copier
directement les fichiers internes de stockage de l’extension.

Configuration finale

LanguageTool Docker
  image      meyay/languagetool:latest
  adresse    127.0.0.1
  port       8010
  API        /v2
  n-grams    français + anglais
  fastText   activé
  Java heap  512 Mio à 2 Gio

Firefox
  serveur    http://127.0.0.1:8010/v2
  niveau     méticuleux
  langues    français + anglais US
  IA         désactivée

LibreOffice
  version    libreoffice-still
  Java       17+
  moteur     WritingTool
  Hunspell   activé
  IA         désactivée

WritingTool
  serveur    http://127.0.0.1:8010
  mise à jour via GitHub + unopkg

Topgrade
  système
  Docker
  WritingTool

Sources utiles

• 
  Image Docker meyay/languagetool
  
• 
  WritingTool
  
• 
  Releases WritingTool
  
• 
  LanguageTool
  
• 
  Topgrade
  
• 
  Paquets Arch Linux