Administrer avec Neovim

Vous maîtrisez Vim mais vous êtes frustré par son langage de configuration archaïque, l'absence de LSP natif et la lenteur de certains plugins ? Neovim reprend tout ce qui fait la force de Vim, modes, motions, text objects, et y ajoute une API Lua moderne, un client LSP intégré, Tree-sitter pour une coloration syntaxique précise, et un terminal asynchrone. Ce guide vous accompagne de l'installation jusqu'à un environnement productif avec autocomplétion, diagnostic, recherche fuzzy et explorateur de fichiers. Toute la configuration présentée a été chargée sans erreur sur Neovim 0.12.5, la version stable du moment, dans un conteneur Debian 13.

Ce que vous allez apprendre

• Installer Neovim sur votre distribution Linux
• Comprendre la structure de configuration en Lua (init.lua)
• Configurer les options et raccourcis essentiels
• Installer des plugins avec le gestionnaire lazy.nvim
• Activer le LSP pour l'autocomplétion et le diagnostic en temps réel
• Utiliser Tree-sitter pour une coloration syntaxique intelligente
• Chercher des fichiers et du texte avec Telescope
• Naviguer dans les fichiers avec un explorateur intégré

Prérequis

Ce guide suppose que vous connaissez les bases de Vim : les modes (normal, insertion, visuel, commande), la navigation avec hjkl, les opérateurs (d, c, y), les text objects (ci", daw), et la configuration avec .vimrc. Si ces notions ne vous sont pas familières, commencez par le guide sur Vim, il couvre tout ce qu'il faut savoir en 20 minutes.

Ce que Neovim apporte par rapport à Vim

Neovim est un fork de Vim lancé en 2014 avec un objectif clair : moderniser le code source de Vim sans casser la compatibilité. En pratique, si vous connaissez Vim, vous connaissez déjà Neovim, les modes, les raccourcis et la philosophie sont identiques. Ce qui change, c'est tout ce qui se passe sous le capot et dans l'écosystème de plugins.

Fonctionnalité	Vim	Neovim
Langage de configuration	VimScript uniquement	Lua natif (plus rapide, plus lisible)
Client LSP	Via plugin (coc.nvim, vim-lsp)	Intégré (vim.lsp), zéro plugin nécessaire
Tree-sitter	Non	Intégré, coloration syntaxique basée sur l'AST
Terminal intégré	Basique	Asynchrone avec API complète
API externe	Limitée	API RPC, contrôler Neovim depuis un programme externe
Exécution asynchrone	Limitée (Vim 8+)	Native, les plugins ne bloquent pas l'éditeur
Valeurs par défaut	Minimalistes	Modernes (syntax on, filetype on, incsearch, souris activée)
Presse-papier	Requiert +clipboard à la compilation	Utilise un provider externe (xclip, wl-copy)
Compatibilité Vim	Sans objet	La plupart des plugins Vim fonctionnent dans Neovim
Santé du système	Pas d'équivalent	:checkhealth diagnostique la configuration

Glissez pour voir

Pour résumer : Vim est un éditeur puissant avec 30 ans d'héritage. Neovim garde cette puissance et y ajoute une architecture moderne qui rend les plugins plus rapides, la configuration plus lisible et les fonctionnalités d'IDE accessibles nativement.

Faut-il migrer de Vim à Neovim ?

Si votre .vimrc vous convient et que vous n'avez pas besoin du LSP ou de Tree-sitter, Vim reste un excellent choix, il est plus léger et pré-installé partout. Migrez vers Neovim si vous voulez l'autocomplétion intelligente, le diagnostic en temps réel ou un écosystème de plugins Lua plus rapide.

Installer Neovim

La configuration de ce guide vise Neovim 0.12 : le plugin Tree-sitter qu'elle utilise exige cette version au minimum. Or les paquets des distributions sont en retard, mesurés le 1er octobre 2026 : 0.9.5 sur Ubuntu 24.04, 0.10.4 sur Debian 13, 0.11.6 sur Fedora 43. Le PPA neovim-ppa/stable, longtemps conseillé, ne publie que la 0.7.2, et seulement pour Ubuntu 20.04 et 22.04. L'archive officielle est donc la méthode recommandée sur toute distribution.

Archive officielle (toutes distributions)

Le projet publie une archive par version, et GitHub en affiche l'empreinte SHA-256 sur la page de la release. Vérifiez-la avant toute extraction : la commande sha256sum --check doit répondre OK.

NVIM_VERSION=v0.12.5
curl -sSLO "https://github.com/neovim/neovim/releases/download/${NVIM_VERSION}/nvim-linux-x86_64.tar.gz"
echo "bce0f56eda1f1b1db6eee8f4133d7a38813ea07933837dd1777411ca384c6875  nvim-linux-x86_64.tar.gz" \
  | sha256sum --check
sudo tar -xzf nvim-linux-x86_64.tar.gz -C /opt
sudo ln -sf /opt/nvim-linux-x86_64/bin/nvim /usr/local/bin/nvim

L'empreinte change à chaque version : relevez la nouvelle sur la page de la release avant de monter NVIM_VERSION. L'ancien nom nvim.appimage n'existe plus depuis la 0.10.4, d'où les erreurs 404 des tutoriels qui l'utilisent encore ; l'AppImage s'appelle désormais nvim-linux-x86_64.appimage et exige FUSE, rarement présent sur un serveur.

Arch Linux

Distribution en publication continue, Arch suit la version stable :

sudo pacman -S neovim

macOS

brew install neovim

Vérification : confirmez l'installation en affichant la version :

nvim --version | head -2

Avec l'archive ci-dessus, la sortie est :

NVIM v0.12.5
Build type: Release

Diagnostic de l'installation

Neovim inclut une commande de diagnostic unique qui vérifie que tout est correctement configuré, providers Python/Node, presse-papier, terminal :

nvim +checkhealth

Cette commande ouvre un rapport détaillé. Les lignes en vert (OK) sont bonnes, les lignes en jaune (WARNING) sont des améliorations optionnelles, et les lignes en rouge (ERROR) nécessitent une action.

Installer une Nerd Font

Plusieurs plugins (Neo-tree, lualine, which-key) utilisent des icônes Unicode pour afficher les types de fichiers, les modes et les raccourcis. Ces icônes nécessitent une police Nerd Font, une police monospace enrichie avec des glyphes supplémentaires.

Linux

# Télécharger et installer FiraCode Nerd Font (version figée, empreinte vérifiée)
mkdir -p ~/.local/share/fonts
cd ~/.local/share/fonts
curl -fLO https://github.com/ryanoasis/nerd-fonts/releases/download/v3.5.1/FiraCode.zip
echo "239395baf60c89b2eaf4862b6b09db0ef95605cd3e8eef51c00345822a81a665  FiraCode.zip" \
  | sha256sum --check
unzip -o FiraCode.zip -d FiraCodeNerdFont
rm FiraCode.zip
fc-cache -fv

Configurez ensuite votre émulateur de terminal pour utiliser la police FiraCode Nerd Font Mono (ou une autre Nerd Font de votre choix).

Windows Terminal (WSL)

Si vous utilisez Neovim dans WSL via Windows Terminal, la police doit être installée côté Windows (pas dans WSL) :

1. Téléchargez la police depuis nerdfonts.com/font-downloads, par exemple FiraCode Nerd Font

2. Extrayez le zip, sélectionnez tous les fichiers .ttf, clic droit → Installer

3. Ouvrez les Settings de Windows Terminal (Ctrl+,), sélectionnez votre profil WSL/Ubuntu, onglet Apparence, et choisissez FiraCode Nerd Font comme police

   Ou ajoutez dans le settings.json de Windows Terminal (Ctrl+Shift+,) :

   {
     "profiles": {
       "list": [
         {
           "name": "Ubuntu",
           "font": {
             "face": "FiraCode Nerd Font",
             "size": 12
           }
         }
       ]
     }
   }

VS Code (terminal intégré)

La police est installée côté système (Linux ou Windows), mais VS Code a son propre paramètre pour le terminal intégré. Ajoutez dans vos Settings (Ctrl+, → chercher "terminal font") :

"terminal.integrated.fontFamily": "'FiraCode Nerd Font Mono'"

macOS

brew install font-fira-code-nerd-font

Configurez ensuite iTerm2 ou Terminal.app pour utiliser FiraCode Nerd Font Mono.

Sans Nerd Font, les icônes apparaissent comme des carrés

Si vous voyez des caractères □ ou ? au lieu des icônes dans Neo-tree ou lualine, c'est que votre terminal n'utilise pas une Nerd Font. Vérifiez que la police est installée et configurée dans votre émulateur de terminal. Sur WSL, la police doit être installée côté Windows, pas dans la distribution Linux.

Structure de la configuration

La configuration de Neovim se trouve dans ~/.config/nvim/. C'est le premier changement par rapport à Vim : au lieu d'un unique ~/.vimrc, Neovim utilise un dossier structuré qui permet d'organiser la configuration en modules Lua, un fichier par sujet, faciles à versionner.

~/.config/nvim/
├── init.lua              # Point d'entrée (équivalent du .vimrc)
├── lua/
│   ├── options.lua       # Options de l'éditeur
│   ├── keymaps.lua       # Raccourcis personnalisés
│   └── plugins/          # Configuration de chaque plugin
│       ├── colorscheme.lua
│       ├── cmp.lua
│       ├── gitsigns.lua
│       ├── lsp.lua
│       ├── lualine.lua
│       ├── misc.lua
│       ├── neo-tree.lua
│       ├── telescope.lua
│       └── treesitter.lua

Créez cette arborescence complète avec les commandes suivantes :

# Créer le dossier de configuration et les sous-dossiers
mkdir -p ~/.config/nvim/lua/plugins

# Créer tous les fichiers de la configuration
touch ~/.config/nvim/init.lua
touch ~/.config/nvim/lua/options.lua
touch ~/.config/nvim/lua/keymaps.lua
touch ~/.config/nvim/lua/plugins/{colorscheme,cmp,gitsigns,lsp,lualine,misc,neo-tree,telescope,treesitter}.lua

Vérification : la commande find doit afficher tous les fichiers créés :

find ~/.config/nvim -type f -name "*.lua" | sort

Résultat attendu

/home/user/.config/nvim/init.lua
/home/user/.config/nvim/lua/keymaps.lua
/home/user/.config/nvim/lua/options.lua
/home/user/.config/nvim/lua/plugins/cmp.lua
/home/user/.config/nvim/lua/plugins/colorscheme.lua
/home/user/.config/nvim/lua/plugins/gitsigns.lua
/home/user/.config/nvim/lua/plugins/lsp.lua
/home/user/.config/nvim/lua/plugins/lualine.lua
/home/user/.config/nvim/lua/plugins/misc.lua
/home/user/.config/nvim/lua/plugins/neo-tree.lua
/home/user/.config/nvim/lua/plugins/telescope.lua
/home/user/.config/nvim/lua/plugins/treesitter.lua

Les sections suivantes de ce guide détaillent le contenu de chaque fichier, dans l'ordre logique de configuration.

Le fichier init.lua est le point d'entrée, Neovim le charge automatiquement au démarrage. Depuis ce fichier, vous pouvez importer (require) d'autres fichiers Lua pour organiser votre configuration.

VimScript fonctionne encore

Si vous avez un .vimrc existant, Neovim peut le lire. Il suffit de créer un init.vim dans ~/.config/nvim/ au lieu d'un init.lua. Les deux formats fonctionnent, mais Lua est recommandé pour les nouvelles configurations car il est plus rapide, plus lisible et supporte les fonctionnalités modernes de Neovim. Vous pouvez aussi mélanger les deux avec la commande vim.cmd('source ~/.vimrc') dans votre init.lua.

Configurer les options de base

Créez le fichier ~/.config/nvim/lua/options.lua pour regrouper toutes les options de l'éditeur. La syntaxe Lua est plus lisible que le VimScript équivalent.

-- ~/.config/nvim/lua/options.lua

-- === PATH (mise + Mason) ===
-- Les serveurs LSP installés via Mason et les outils mis en place via mise
-- doivent être accessibles dans le PATH de Neovim
vim.env.PATH = vim.fn.expand("~/.local/share/nvim/mason/bin") .. ":" .. vim.env.PATH
-- Ajouter node/python de mise si présents
local mise_shims = vim.fn.expand("~/.local/share/mise/shims")
if vim.fn.isdirectory(mise_shims) == 1 then
  vim.env.PATH = mise_shims .. ":" .. vim.env.PATH
end

-- === Apparence ===
vim.opt.number = true         -- Numéros de ligne
vim.opt.relativenumber = true -- Numéros relatifs (utile pour 5j, 12k)
vim.opt.cursorline = true     -- Surligne la ligne du curseur
vim.opt.signcolumn = "yes"    -- Colonne de signes toujours visible (Git, diagnostics)
vim.opt.termguicolors = true  -- Active les couleurs 24 bits (true color)
vim.opt.showmode = false      -- Cache le mode (le plugin lualine l'affichera)
vim.opt.colorcolumn = "80"    -- Ligne verticale à 80 caractères

-- === Indentation ===
vim.opt.tabstop = 4           -- Une tabulation vaut 4 espaces à l'écran
vim.opt.shiftwidth = 4        -- L'indentation automatique décale de 4 espaces
vim.opt.expandtab = true      -- Insère des espaces au lieu de tabulations
vim.opt.smartindent = true    -- Indentation intelligente après {, if, etc.

-- === Recherche ===
vim.opt.ignorecase = true     -- Recherche insensible à la casse
vim.opt.smartcase = true      -- SAUF si vous tapez une majuscule
vim.opt.hlsearch = true       -- Surligne toutes les occurrences
vim.opt.incsearch = true      -- Résultats en temps réel

-- === Comportement ===
vim.opt.mouse = "a"           -- Souris activée partout
vim.opt.clipboard = "unnamedplus" -- Presse-papier système partagé
vim.opt.scrolloff = 8         -- Garde 8 lignes au-dessus/en-dessous du curseur
vim.opt.undofile = true       -- Persistent undo (historique sauvegardé sur disque)
vim.opt.swapfile = false      -- Pas de fichier swap (moins de messages au démarrage)
vim.opt.updatetime = 250      -- Délai réduit (meilleure réactivité Git/diagnostics)
vim.opt.splitright = true     -- Les splits verticaux s'ouvrent à droite
vim.opt.splitbelow = true     -- Les splits horizontaux s'ouvrent en bas

-- === Wrapping ===
vim.opt.wrap = false          -- Pas de retour à la ligne automatique
vim.opt.linebreak = true      -- Si wrap activé, coupe aux mots (pas au milieu)

Chaque option vim.opt.X = valeur correspond au set X=valeur de VimScript. La différence : en Lua, les booléens sont true/false (pas set X / set noX), et les chaînes utilisent des guillemets.

Vérification : ouvrez Neovim et vérifiez que les options sont bien appliquées :

" Vérifier une option booléenne (doit afficher "number")
:set number?

" Vérifier une valeur numérique (doit afficher 4)
:lua print(vim.opt.tabstop:get())

" Voir toutes les options modifiées par rapport aux défauts
:set

Trouver la documentation d'une option

Chaque option Neovim est documentée. Pour comprendre ce que fait une option :

" Afficher l'aide d'une option spécifique
:help 'scrolloff'
:help 'expandtab'
:help 'signcolumn'

La commande :options ouvre une fenêtre interactive qui liste toutes les options par catégorie, pratique pour découvrir des options que vous ne connaissez pas.

Neovim active par ailleurs par défaut certaines options que Vim laisse désactivées : syntax on, filetype plugin indent on, incsearch, hlsearch, autoindent, et la souris (mouse=nvi, soit les modes normal, visuel et insertion). Si vous migrez depuis Vim, vous pouvez retirer ces lignes de votre configuration, elles sont déjà actives.

Configurer les raccourcis

Créez le fichier ~/.config/nvim/lua/keymaps.lua pour vos raccourcis personnalisés. La touche Leader est la base de tous les raccourcis personnalisés, elle sert de préfixe pour éviter les conflits avec les commandes Vim natives.

-- ~/.config/nvim/lua/keymaps.lua

-- Définir la touche Leader (Espace)
vim.g.mapleader = " "
vim.g.maplocalleader = " "

-- Raccourci helper
local map = vim.keymap.set

-- === Fichiers ===
map("n", "<leader>w", "<cmd>w<cr>", { desc = "Sauvegarder" })
map("n", "<leader>q", "<cmd>q<cr>", { desc = "Quitter" })
map("n", "<leader>x", "<cmd>x<cr>", { desc = "Sauvegarder et quitter" })

-- === Navigation entre splits ===
map("n", "<C-h>", "<C-w>h", { desc = "Aller au split gauche" })
map("n", "<C-j>", "<C-w>j", { desc = "Aller au split bas" })
map("n", "<C-k>", "<C-w>k", { desc = "Aller au split haut" })
map("n", "<C-l>", "<C-w>l", { desc = "Aller au split droit" })

-- === Redimensionner les splits ===
map("n", "<C-Up>", "<cmd>resize +2<cr>", { desc = "Agrandir split horizontal" })
map("n", "<C-Down>", "<cmd>resize -2<cr>", { desc = "Réduire split horizontal" })
map("n", "<C-Left>", "<cmd>vertical resize -2<cr>", { desc = "Réduire split vertical" })
map("n", "<C-Right>", "<cmd>vertical resize +2<cr>", { desc = "Agrandir split vertical" })

-- === Buffers ===
map("n", "<S-l>", "<cmd>bnext<cr>", { desc = "Buffer suivant" })
map("n", "<S-h>", "<cmd>bprevious<cr>", { desc = "Buffer précédent" })
map("n", "<leader>bd", "<cmd>bdelete<cr>", { desc = "Fermer le buffer" })

-- === Confort ===
map("n", "<leader>h", "<cmd>nohlsearch<cr>", { desc = "Effacer le surlignage recherche" })
map("n", "<Esc>", "<cmd>nohlsearch<cr>", { desc = "Effacer le surlignage" })
map("v", "J", ":m '>+1<cr>gv=gv", { desc = "Déplacer la sélection vers le bas" })
map("v", "K", ":m '<-2<cr>gv=gv", { desc = "Déplacer la sélection vers le haut" })
map("n", "J", "mzJ`z", { desc = "Joindre les lignes sans déplacer le curseur" })

-- === Terminal ===
map("n", "<leader>t", "<cmd>terminal<cr>", { desc = "Ouvrir un terminal" })
map("t", "<Esc><Esc>", "<C-\\><C-n>", { desc = "Quitter le mode terminal" })

La syntaxe vim.keymap.set(mode, touche, action, options) est l'équivalent Lua de nnoremap / vnoremap en VimScript. Le champ desc est important : il permet aux plugins comme which-key d'afficher une description pour chaque raccourci.

Vérification : vérifiez que vos raccourcis sont bien enregistrés :

" Lister tous les raccourcis du mode normal commençant par Leader
:nmap <leader>

" Chercher un raccourci précis
:verbose nmap <leader>w

" Lister TOUS les raccourcis (long, mais exhaustif)
:map

La commande :verbose nmap affiche en plus où le raccourci a été défini (fichier et numéro de ligne), très utile pour comprendre les conflits entre plugins.

Quitter le terminal intégré

Le terminal de Neovim fonctionne dans un mode terminal spécial. Pour en sortir et revenir en mode normal, appuyez sur Esc Esc (deux fois Échap, grâce au raccourci ci-dessus). Sans ce raccourci, la combinaison par défaut est Ctrl+\ Ctrl+n, moins intuitive.

Le fichier init.lua

Le fichier d'entrée importe les modules que vous venez de créer et prépare le terrain pour les plugins :

-- ~/.config/nvim/init.lua

-- Charger les options et raccourcis
require("options")
require("keymaps")

-- Le gestionnaire de plugins sera chargé ici (section suivante)

require("options") cherche le fichier lua/options.lua dans le dossier de configuration. C'est le mécanisme d'import standard de Lua.

Vérification : à ce stade (avant les plugins), lancez Neovim pour vérifier que la base fonctionne :

# Lancer Neovim
nvim

Vous devriez voir les numéros de ligne, la ligne curseur surlignée et la colonne à 80 caractères. Si une erreur apparaît, la ligne fautive est indiquée dans le message, corrigez-la avant de continuer.

" Vérifier l'état de santé complet de Neovim
:checkhealth

:checkhealth analyse toute l'installation et affiche un rapport détaillé. Chaque section montre OK, WARNING ou ERROR. Concentrez-vous sur les ERROR, les WARNING sont souvent des fonctionnalités optionnelles, comme un provider Python que vous n'utiliserez pas.

Où trouver de l'aide dans Neovim

Neovim embarque une documentation complète accessible depuis l'éditeur :

" Aide générale
:help

" Aide sur un sujet précis
:help vim.opt
:help vim.keymap.set
:help autocmd

" Chercher dans l'aide (fuzzy, avec Telescope)
:Telescope help_tags

" Aide sur une commande
:help :checkhealth
:help :Lazy

Le système d'aide utilise des tags : quand un mot est surligné en couleur, placez le curseur dessus et appuyez sur Ctrl+] pour naviguer vers sa définition. Ctrl+O pour revenir en arrière.

Installer des plugins avec lazy.nvim

lazy.nvim est le gestionnaire de plugins le plus répandu pour Neovim. Il remplace vim-plug et packer.nvim avec une approche plus rapide et plus moderne : chargement paresseux (les plugins ne se chargent que quand vous en avez besoin), interface graphique, verrouillage des versions et mises à jour simplifiées. Neovim 0.12 embarque aussi un gestionnaire natif, vim.pack, que sa propre aide qualifie encore d'expérimental : ce guide reste sur lazy.nvim.

lazy.nvim ≠ LazyVim

Ne confondez pas lazy.nvim et LazyVim, ce sont deux projets distincts du même auteur (folke) :

• lazy.nvim est un gestionnaire de plugins, il installe, met à jour et charge vos plugins. C'est un outil neutre : vous choisissez vous-même chaque plugin et sa configuration. C'est ce que nous utilisons dans ce guide.
• LazyVim est une distribution Neovim préconfigurée, un ensemble complet de plugins déjà sélectionnés et configurés (LSP, Telescope, Tree-sitter, etc.) prêt à l'emploi. C'est un « starter kit » qui fonctionne immédiatement mais laisse moins de contrôle sur chaque détail.

L'approche de ce guide : configurer Neovim de zéro avec lazy.nvim comme gestionnaire. Vous comprenez chaque plugin, chaque ligne de configuration. Si vous préférez un environnement fonctionnel immédiatement sans tout configurer, regardez LazyVim, NvChad ou AstroNvim.

Installer lazy.nvim

Ajoutez ce bloc au début de votre init.lua, avant les require :

-- ~/.config/nvim/init.lua

-- Bootstrap lazy.nvim (installation automatique au premier lancement)
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not (vim.uv or vim.loop).fs_stat(lazypath) then
  vim.fn.system({
    "git", "clone", "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable",
    lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)

-- Charger les options et raccourcis
require("options")
require("keymaps")

-- Charger les plugins
require("lazy").setup("plugins")

La dernière ligne require("lazy").setup("plugins") indique à lazy.nvim de charger tous les fichiers Lua du dossier lua/plugins/. Chaque fichier dans ce dossier définit un ou plusieurs plugins. L'expression (vim.uv or vim.loop) reprend le bootstrap officiel de lazy.nvim : vim.uv est le nom actuel de la bibliothèque libuv, vim.loop son ancien alias.

Vérification : au premier lancement, lazy.nvim se clone automatiquement depuis GitHub. Vous devriez voir des messages de clonage dans le terminal :

# Lancez Neovim
nvim

Si le bootstrap fonctionne, la commande :Lazy doit ouvrir l'interface du gestionnaire. Si vous voyez une erreur module 'lazy' not found, vérifiez que git est installé (git --version) et que le chemin lazypath est correct.

L'interface de lazy.nvim

Ouvrez l'interface du gestionnaire avec la commande :

:Lazy

Depuis cette interface, vous pouvez :

Touche	Action
I	Installer les plugins manquants
U	Mettre à jour tous les plugins
S	Synchroniser (installer + mettre à jour + nettoyer)
X	Supprimer les plugins non déclarés
P	Voir les performances de chargement
q	Fermer l'interface

Glissez pour voir

Les plugins essentiels

Voici les plugins qui transforment Neovim en environnement de travail complet. Chacun est configuré dans un fichier séparé dans lua/plugins/.

Valider après chaque plugin

Après avoir créé ou modifié un fichier de plugin, relancez Neovim et vérifiez qu'il démarre sans erreur. Si un message d'erreur apparaît, il indique le fichier et la ligne responsables. Corrigez avant de passer au plugin suivant.

Pour forcer la réinstallation de tous les plugins :

" Ouvrir l'interface lazy.nvim et synchroniser
:Lazy sync

Gruvbox : un thème de couleurs lisible

Créez lua/plugins/colorscheme.lua :

-- ~/.config/nvim/lua/plugins/colorscheme.lua
return {
  "ellisonleao/gruvbox.nvim",
  priority = 1000,  -- Charger en premier (avant les autres plugins)
  config = function()
    require("gruvbox").setup({
      contrast = "hard",  -- "hard", "soft" ou "" (défaut)
    })
    vim.cmd.colorscheme("gruvbox")
  end,
}

Le thème Gruvbox en version Neovim exploite les couleurs 24 bits (true color) pour un rendu plus fidèle que la version Vim 256 couleurs.

Vérification : après redémarrage, le thème doit s'appliquer immédiatement. Si les couleurs semblent incorrectes (pas de fond sombre, couleurs plates) :

" Vérifier que le thème est bien actif (doit afficher "gruvbox")
:colorscheme

" Vérifier que true color est actif (doit afficher "termguicolors")
:set termguicolors?

" Lister tous les thèmes disponibles
:Telescope colorscheme

Lualine : une barre de statut moderne

Créez lua/plugins/lualine.lua :

-- ~/.config/nvim/lua/plugins/lualine.lua
return {
  "nvim-lualine/lualine.nvim",
  dependencies = { "nvim-tree/nvim-web-devicons" },
  config = function()
    require("lualine").setup({
      options = {
        theme = "gruvbox",
        section_separators = { left = "", right = "" },
        component_separators = { left = "", right = "" },
      },
      sections = {
        lualine_a = { "mode" },
        lualine_b = { "branch", "diff", "diagnostics" },
        lualine_c = { "filename" },
        lualine_x = { "encoding", "fileformat", "filetype" },
        lualine_y = { "progress" },
        lualine_z = { "location" },
      },
    })
  end,
}

Lualine remplace lightline (Vim) avec des fonctionnalités supplémentaires : affichage de la branche Git, compteur de diagnostics LSP et indicateur de diff, le tout sans configuration manuelle.

Telescope : recherche fuzzy universelle

Telescope est la fonctionnalité qui justifie à elle seule le passage à Neovim pour beaucoup d'utilisateurs. C'est un chercheur universel : fichiers, texte, buffers, historique Git, diagnostics LSP, tout est accessible en tapant quelques lettres.

Créez lua/plugins/telescope.lua :

-- ~/.config/nvim/lua/plugins/telescope.lua
return {
  "nvim-telescope/telescope.nvim",
  version = "*",
  dependencies = {
    "nvim-lua/plenary.nvim",
    { "nvim-telescope/telescope-fzf-native.nvim", build = "make" },
  },
  config = function()
    local telescope = require("telescope")
    telescope.setup({
      defaults = {
        path_display = { "truncate" },
        sorting_strategy = "ascending",
        layout_config = {
          horizontal = { prompt_position = "top" },
        },
      },
    })
    telescope.load_extension("fzf")

    -- Raccourcis Telescope
    local map = vim.keymap.set
    map("n", "<leader>ff", "<cmd>Telescope find_files<cr>", { desc = "Chercher un fichier" })
    map("n", "<leader>fg", "<cmd>Telescope live_grep<cr>", { desc = "Chercher du texte" })
    map("n", "<leader>fb", "<cmd>Telescope buffers<cr>", { desc = "Lister les buffers" })
    map("n", "<leader>fh", "<cmd>Telescope help_tags<cr>", { desc = "Chercher dans l'aide" })
    map("n", "<leader>fo", "<cmd>Telescope oldfiles<cr>", { desc = "Fichiers récents" })
    map("n", "<leader>fd", "<cmd>Telescope diagnostics<cr>", { desc = "Diagnostics LSP" })
  end,
}

Le tableau reprend les six raccourcis que la configuration vient de définir. Ils commencent tous par Espace f, pour find, ce qui les rend faciles à retenir et les regroupe dans le panneau which-key :

Raccourci	Ce qu'il fait
Espace ff	Chercher un fichier par nom (fuzzy)
Espace fg	Chercher du texte dans tout le projet (live grep)
Espace fb	Naviguer dans les buffers ouverts
Espace fh	Chercher dans l'aide Neovim
Espace fo	Fichiers récemment ouverts
Espace fd	Liste des erreurs et warnings LSP

Glissez pour voir

Dépendances de Telescope

Telescope nécessite ripgrep pour la recherche de texte (live_grep) et fd pour la recherche de fichiers rapide :

# Ubuntu / Debian (le binaire de fd s'y appelle fdfind)
sudo apt install ripgrep fd-find

# Fedora
sudo dnf install ripgrep fd-find

# Arch Linux
sudo pacman -S ripgrep fd

# macOS
brew install ripgrep fd

Sans ces outils, Telescope fonctionne mais utilise des alternatives plus lentes (grep, find). L'extension fzf-native demande en plus make et un compilateur C pour se construire.

Vérification : testez chaque commande Telescope pour confirmer que tout fonctionne :

" Doit ouvrir le chercheur de fichiers (nécessite fd)
:Telescope find_files

" Doit ouvrir la recherche de texte (nécessite ripgrep)
:Telescope live_grep

" Si une erreur apparaît, vérifier les dépendances dans un shell :
" - fd --version (fdfind --version sur Debian et Ubuntu)
" - rg --version
" Si fzf-native échoue, vérifier que make est installé :
" - make --version

Tree-sitter : coloration syntaxique intelligente

Tree-sitter est un analyseur syntaxique incrémental intégré à Neovim. Au lieu de colorier le code avec des expressions régulières (comme Vim), il construit un arbre syntaxique (AST) du fichier. Le résultat : une coloration plus précise, du pliage de code intelligent et une meilleure compréhension de la structure du fichier.

Le plugin nvim-treesitter télécharge puis compile un parser par langage. Sa branche main, devenue la branche par défaut, exige trois choses que son README liste en tête : Neovim 0.12 au minimum, un compilateur C, et la CLI tree-sitter en version 0.26.1 ou plus. Debian 13 ne fournit que la 0.22.6 : installez le binaire publié par le projet, empreinte vérifiée.

TS_VERSION=v0.27.0
curl -sSLO "https://github.com/tree-sitter/tree-sitter/releases/download/${TS_VERSION}/tree-sitter-linux-x64.gz"
echo "20a1f39ec1c45f2211492dcb8881c802b643b554bb196869a29ac3778277fa77  tree-sitter-linux-x64.gz" \
  | sha256sum --check
gunzip tree-sitter-linux-x64.gz
sudo install -m 0755 tree-sitter-linux-x64 /usr/local/bin/tree-sitter
tree-sitter --version

La dernière commande doit répondre tree-sitter 0.27.0. Sans cette CLI, chaque parser échoue au moment de la compilation avec l'erreur ENOENT: no such file or directory (cmd): 'tree-sitter', mesurée dans un conteneur Debian 13 sans elle.

Créez lua/plugins/treesitter.lua :

-- ~/.config/nvim/lua/plugins/treesitter.lua
-- API nvim-treesitter rewrite (branche main, Neovim ≥ 0.12, CLI tree-sitter requise)
return {
  "nvim-treesitter/nvim-treesitter",
  lazy = false,
  build = ":TSUpdate",
  config = function()
    require("nvim-treesitter").setup({})

    -- Installer les parsers (asynchrone, no-op si déjà installés)
    require("nvim-treesitter").install({
      "bash", "c", "css", "dockerfile", "go", "hcl",
      "html", "javascript", "json", "lua", "markdown",
      "python", "rust", "terraform", "toml", "typescript",
      "vim", "vimdoc", "yaml",
    })

    -- Activer la coloration Tree-sitter pour ces filetypes
    vim.api.nvim_create_autocmd("FileType", {
      pattern = {
        "bash", "sh", "c", "css", "dockerfile", "go", "hcl",
        "html", "javascript", "json", "lua", "markdown",
        "python", "rust", "terraform", "toml", "typescript",
        "vim", "yaml",
      },
      callback = function()
        pcall(vim.treesitter.start)
      end,
    })

    -- Activer le pliage de code basé sur Tree-sitter
    vim.api.nvim_create_autocmd("FileType", {
      pattern = {
        "bash", "sh", "c", "go", "javascript", "json", "lua",
        "python", "rust", "typescript", "yaml",
      },
      callback = function()
        vim.wo[0][0].foldmethod = "expr"
        vim.wo[0][0].foldexpr = "v:lua.vim.treesitter.foldexpr()"
        vim.wo[0][0].foldenable = false  -- Ne pas plier par défaut
      end,
    })
  end,
}

La nouvelle API nvim-treesitter (branche main) fonctionne différemment de l'ancienne. L'installation des parsers se fait via require("nvim-treesitter").install({...}), l'appel est asynchrone et ne refait rien si le parser est déjà compilé. La coloration syntaxique s'active avec vim.treesitter.start() dans un autocmd FileType, ce qui permet un contrôle fin par langage.

Le pliage de code (folding) utilise vim.treesitter.foldexpr() au lieu des expressions régulières. L'option foldenable = false évite que tous les blocs soient repliés à l'ouverture du fichier, vous pouvez plier manuellement avec za (basculer) ou zM (tout plier).

Vérification : ouvrez un fichier dans un des langages configurés et vérifiez que la coloration Tree-sitter est active :

" Ouvrir un fichier Python, Lua, YAML, etc.
:edit test.py

" Vérifier que Tree-sitter est actif pour ce buffer
" (doit afficher le nom du parser, "python" ici)
:lua print(vim.inspect(vim.treesitter.get_parser():lang()))

" Lister tous les parsers installés
:lua print(vim.inspect(require('nvim-treesitter').get_installed()))

" Si un parser manque, l'installer
:lua require('nvim-treesitter').install({ 'terraform' })

Compter les parsers installés

La branche main a retiré les commandes :TSInstallInfo et la fonction VimScript nvim_treesitter#installed_parsers() des anciens tutoriels. Le compte se lit en Lua ; après le premier lancement de la configuration ci-dessus, il valait 23 dans notre conteneur :

:lua print(#require('nvim-treesitter').get_installed() .. ' parsers installés')

LSP : autocomplétion et diagnostic en temps réel

Le LSP (Language Server Protocol) est la fonctionnalité qui transforme Neovim en véritable IDE. Un serveur de langage analyse votre code en arrière-plan et fournit l'autocomplétion, le diagnostic d'erreurs, la navigation vers les définitions, le renommage de symboles et bien plus.

La configuration LSP nécessite deux éléments :

1. mason.nvim, installe et gère les serveurs de langage
2. nvim-cmp, affiche l'autocomplétion dans l'éditeur

Le plugin nvim-lspconfig reste utile en complément : il fournit les configurations par défaut de chaque serveur (commande de lancement, détection de la racine du projet, types de fichiers). Ces fichiers sont chargés automatiquement dans le runtimepath, pas besoin d'appeler require('lspconfig').

Depuis Neovim 0.11, la configuration des serveurs LSP utilise l'API native vim.lsp.config et vim.lsp.enable au lieu de l'ancien require('lspconfig').server.setup(). La même version a ajouté des raccourcis LSP par défaut, actifs sans aucune ligne de configuration :

Raccourci par défaut	Action
K	Documentation au survol
grr	Références du symbole
gri	Aller à l'implémentation
grn	Renommer le symbole
gra	Actions de code
[d / ]d	Diagnostic précédent / suivant
gcc / gc	Commenter la ligne / la sélection (depuis la 0.10)

Glissez pour voir

La configuration ci-dessous ne redéfinit donc que ce qui manque. Redéfinir gr seul ferait attendre Neovim à chaque grr ou grn, le temps de savoir si une seconde lettre suit.

Créez lua/plugins/lsp.lua :

-- ~/.config/nvim/lua/plugins/lsp.lua
-- API vim.lsp.config / vim.lsp.enable (Neovim ≥ 0.11)
return {
  {
    "mason-org/mason.nvim",
    config = function()
      require("mason").setup()
    end,
  },
  {
    "neovim/nvim-lspconfig",
    dependencies = { "mason-org/mason.nvim" },
    config = function()
      -- Capabilities enrichies avec nvim-cmp (si installé)
      local capabilities = vim.lsp.protocol.make_client_capabilities()
      local ok, cmp_lsp = pcall(require, "cmp_nvim_lsp")
      if ok then
        capabilities = cmp_lsp.default_capabilities(capabilities)
      end

      -- Raccourcis LSP en plus des défauts (K, grr, gri, grn, gra, [d, ]d)
      vim.api.nvim_create_autocmd("LspAttach", {
        callback = function(ev)
          local map = function(keys, func, desc)
            vim.keymap.set("n", keys, func, { buffer = ev.buf, desc = desc })
          end

          map("gd", vim.lsp.buf.definition, "Aller à la définition")
          map("gD", vim.lsp.buf.declaration, "Aller à la déclaration")
          map("<leader>rn", vim.lsp.buf.rename, "Renommer le symbole")
          map("<leader>ca", vim.lsp.buf.code_action, "Actions de code")
          map("<leader>e", vim.diagnostic.open_float, "Détails du diagnostic")
        end,
      })

      -- Configuration par défaut (appliquée à tous les serveurs)
      vim.lsp.config("*", {
        capabilities = capabilities,
      })

      -- Configuration spécifique pour lua_ls (éviter les warnings Neovim)
      vim.lsp.config("lua_ls", {
        settings = {
          Lua = {
            diagnostics = { globals = { "vim" } },
            workspace = { library = vim.api.nvim_get_runtime_file("", true) },
          },
        },
      })

      -- Activer tous les serveurs installés via Mason
      vim.lsp.enable({
        "lua_ls", "pyright", "bashls", "yamlls",
        "dockerls", "terraformls", "jsonls",
      })
    end,
  },
}

Pour installer les serveurs de langage, ouvrez l'interface Mason avec :Mason puis installez-les manuellement, ou lancez directement la commande ci-dessous. Les serveurs écrits en JavaScript (pyright, bashls, yamlls, dockerls, jsonls) demandent Node.js et npm sur la machine ; lua_ls et terraform-ls sont des binaires autonomes.

:MasonInstall pyright lua-language-server bash-language-server yaml-language-server dockerfile-language-server terraform-ls json-lsp

Les changements clés par rapport à l'ancienne API :

• vim.lsp.config("*", {...}) remplace le passage de capabilities à chaque serveur, la configuration "*" s'applique à tous.
• vim.lsp.config("lua_ls", {...}) remplace lspconfig.lua_ls.setup({...}) pour les configurations spécifiques.
• vim.lsp.enable({...}) remplace la boucle for server in servers.
• LspAttach autocmd remplace le callback on_attach, c'est l'approche recommandée depuis Neovim 0.11.
• vim.diagnostic.goto_next() et goto_prev() sont dépréciés : :checkhealth vim.deprecated annonce leur retrait en 0.13 et conseille vim.diagnostic.jump(). Les défauts [d et ]d l'utilisent déjà.

nvim-cmp : le moteur d'autocomplétion

Créez lua/plugins/cmp.lua :

-- ~/.config/nvim/lua/plugins/cmp.lua
return {
  "hrsh7th/nvim-cmp",
  dependencies = {
    "hrsh7th/cmp-nvim-lsp",     -- Source LSP
    "hrsh7th/cmp-buffer",       -- Source buffer courant
    "hrsh7th/cmp-path",         -- Source chemins de fichiers
    "L3MON4D3/LuaSnip",         -- Moteur de snippets
    "saadparwaiz1/cmp_luasnip", -- Source snippets pour cmp
    "rafamadriz/friendly-snippets", -- Collection de snippets
  },
  config = function()
    local cmp = require("cmp")
    local luasnip = require("luasnip")

    -- Charger les snippets de friendly-snippets
    require("luasnip.loaders.from_vscode").lazy_load()

    cmp.setup({
      snippet = {
        expand = function(args)
          luasnip.lsp_expand(args.body)
        end,
      },
      mapping = cmp.mapping.preset.insert({
        ["<C-b>"] = cmp.mapping.scroll_docs(-4),
        ["<C-f>"] = cmp.mapping.scroll_docs(4),
        ["<C-Space>"] = cmp.mapping.complete(),
        ["<C-e>"] = cmp.mapping.abort(),
        ["<CR>"] = cmp.mapping.confirm({ select = true }),
        ["<Tab>"] = cmp.mapping(function(fallback)
          if cmp.visible() then
            cmp.select_next_item()
          elseif luasnip.expand_or_jumpable() then
            luasnip.expand_or_jump()
          else
            fallback()
          end
        end, { "i", "s" }),
        ["<S-Tab>"] = cmp.mapping(function(fallback)
          if cmp.visible() then
            cmp.select_prev_item()
          elseif luasnip.jumpable(-1) then
            luasnip.jump(-1)
          else
            fallback()
          end
        end, { "i", "s" }),
      }),
      sources = cmp.config.sources({
        { name = "nvim_lsp" },  -- Suggestions du LSP en priorité
        { name = "luasnip" },   -- Snippets
        { name = "buffer" },    -- Mots du buffer courant
        { name = "path" },      -- Chemins de fichiers
      }),
    })
  end,
}

Les raccourcis LSP les plus importants à retenir mêlent les défauts de Neovim et ceux de la configuration ci-dessus ; le tableau les regroupe par usage, de la navigation à l'autocomplétion :

Raccourci	Action
gd	Aller à la définition de la fonction/variable sous le curseur
grr	Voir les références (tous les endroits qui utilisent ce symbole)
K	Documentation au survol (signature, description)
Espace rn (ou grn)	Renommer le symbole partout dans le projet
Espace ca (ou gra)	Actions de code (correction rapide, import manquant)
Espace e	Détails du diagnostic (message d'erreur complet)
[d / ]d	Naviguer entre les diagnostics (erreurs, warnings)
Tab / Shift+Tab	Naviguer dans le menu d'autocomplétion
Entrée	Accepter la suggestion
Ctrl+Espace	Déclencher manuellement l'autocomplétion

Glissez pour voir

Installer un serveur de langage

Mason gère l'installation des serveurs de langage. Ouvrez l'interface avec :

:Mason

Naviguez dans la liste avec les flèches et appuyez sur i pour installer un serveur. Mason télécharge et configure le serveur automatiquement, pas besoin de pip install ou npm install manuellement, à condition que l'outil de base du serveur (Node.js pour pyright) soit présent.

Vérification LSP complète : ouvrez un fichier du langage concerné et vérifiez que le serveur s'attache. Sur Neovim 0.12, les anciennes commandes :LspInfo et :LspLog de nvim-lspconfig n'existent plus : le plugin ne les crée que si la commande native :lsp est absente.

" Ouvrir un fichier Lua (ou Python, YAML, etc.)
:edit test.lua

" Vérifier les serveurs LSP actifs (section « Active Clients »)
:checkhealth vim.lsp

" Vérifier que Mason a bien installé les serveurs
:Mason
" Les serveurs installés apparaissent avec une coche verte

" Lister les clients attachés au buffer courant
:lua print(vim.inspect(vim.tbl_map(function(c) return c.name end, vim.lsp.get_clients({ bufnr = 0 }))))

" Si le serveur ne démarre pas, ouvrir le journal LSP
:lua vim.cmd('tabnew ' .. vim.lsp.log.get_filename())

" Redémarrer les serveurs du buffer après une correction
:lsp restart

Mesuré avec lua_ls installé par Mason : :checkhealth vim.lsp liste lua_ls (id: 1) sous Active Clients. Si cette section est vide, le serveur de langage n'est probablement pas installé via Mason (vérifiez avec :Mason) ou le PATH de Neovim ne contient pas les binaires (vérifiez la section PATH dans options.lua).

Neo-tree : explorateur de fichiers

Créez lua/plugins/neo-tree.lua :

-- ~/.config/nvim/lua/plugins/neo-tree.lua
return {
  "nvim-neo-tree/neo-tree.nvim",
  branch = "v3.x",
  dependencies = {
    "nvim-lua/plenary.nvim",
    "nvim-tree/nvim-web-devicons",
    "MunifTanjim/nui.nvim",
  },
  config = function()
    require("neo-tree").setup({
      filesystem = {
        follow_current_file = { enabled = true },
        filtered_items = {
          hide_dotfiles = false,
          hide_gitignored = false,
        },
      },
      window = {
        width = 35,
      },
    })

    vim.keymap.set("n", "<leader>n", "<cmd>Neotree toggle<cr>",
      { desc = "Ouvrir/fermer l'explorateur" })
  end,
}

Neo-tree remplace NERDTree (Vim) avec un affichage plus riche : icônes par type de fichier, indicateurs Git intégrés et navigation fluide. Appuyez sur Espace n pour l'ouvrir ou le fermer.

Vérification : appuyez sur Espace n, l'explorateur doit s'ouvrir à gauche avec l'arborescence du répertoire courant. Si les icônes ne s'affichent pas, vérifiez que vous utilisez une Nerd Font (voir la section d'installation plus haut).

Gitsigns : marqueurs Git dans la gouttière

Créez lua/plugins/gitsigns.lua :

-- ~/.config/nvim/lua/plugins/gitsigns.lua
return {
  "lewis6991/gitsigns.nvim",
  config = function()
    require("gitsigns").setup({
      signs = {
        add          = { text = "│" },
        change       = { text = "│" },
        delete       = { text = "_" },
        topdelete    = { text = "‾" },
        changedelete = { text = "~" },
      },
      on_attach = function(bufnr)
        local gs = package.loaded.gitsigns
        local map = function(mode, l, r, desc)
          vim.keymap.set(mode, l, r, { buffer = bufnr, desc = desc })
        end

        map("n", "]c", function() gs.nav_hunk("next") end, "Hunk Git suivant")
        map("n", "[c", function() gs.nav_hunk("prev") end, "Hunk Git précédent")
        map("n", "<leader>gp", gs.preview_hunk, "Prévisualiser le changement")
        map("n", "<leader>gb", gs.blame_line, "Git blame de la ligne")
        map("n", "<leader>gr", gs.reset_hunk, "Annuler le changement")
      end,
    })
  end,
}

Les deux raccourcis de navigation passent par nav_hunk, que la documentation de gitsigns désigne comme remplaçant de next_hunk et prev_hunk, tous deux marqués DEPRECATED. Les marqueurs se lisent dans la gouttière, à gauche des numéros de ligne, dès que le fichier est suivi par Git. La couleur dépend du thème ; avec Gruvbox, le code couleur est le suivant :

Marqueur	Signification
│ vert	Ligne ajoutée
│ bleu	Ligne modifiée
_ rouge	Ligne supprimée

Glissez pour voir

Autres plugins recommandés

Créez lua/plugins/misc.lua pour les plugins utilitaires. Le commentaire de code n'y figure plus : depuis la 0.10, Neovim fournit gcc (commenter la ligne) et gc (commenter une sélection ou un mouvement) nativement, ce qui rend Comment.nvim et vim-commentary inutiles.

-- ~/.config/nvim/lua/plugins/misc.lua
return {
  -- Fermeture automatique des parenthèses et guillemets
  {
    "windwp/nvim-autopairs",
    event = "InsertEnter",
    config = function()
      require("nvim-autopairs").setup()
    end,
  },

  -- Entourer du texte (comme vim-surround, en Lua)
  {
    "kylechui/nvim-surround",
    event = "VeryLazy",
    config = function()
      require("nvim-surround").setup()
    end,
  },

  -- Guides d'indentation visuels
  {
    "lukas-reineke/indent-blankline.nvim",
    main = "ibl",
    config = function()
      require("ibl").setup()
    end,
  },

  -- Which-key : affiche les raccourcis disponibles
  {
    "folke/which-key.nvim",
    event = "VeryLazy",
    config = function()
      require("which-key").setup()
    end,
  },
}

Le plugin which-key mérite une attention particulière : quand vous appuyez sur Espace (la touche Leader) et que vous attendez une seconde, un panneau apparaît avec tous les raccourcis disponibles et leur description. C'est un aide-mémoire intégré qui rend la configuration explorable.

Vérification finale : après avoir créé tous les fichiers, lancez Neovim et exécutez ces commandes pour valider l'ensemble de la configuration :

" 1. Vérifiez que tous les plugins sont installés (aucun en rouge)
:Lazy

" 2. Vérifiez la santé complète de l'installation
:checkhealth

" 3. Vérifiez que les serveurs LSP sont installés
:Mason

" 4. Vérifiez que Telescope fonctionne
:Telescope find_files

" 5. Vérifiez que Tree-sitter a compilé les parsers
:lua print(#require('nvim-treesitter').get_installed() .. ' parsers installés')

" 6. Ouvrez un fichier Lua et vérifiez le LSP
:edit test.lua
:checkhealth vim.lsp

Si toutes ces commandes fonctionnent sans erreur, votre configuration est opérationnelle.

Configuration complète récapitulative

Voici l'arborescence finale et le fichier init.lua complet, suivis d'une installation rapide qui enchaîne toutes les étapes du guide sur une machine Debian ou Ubuntu :

Arborescence

~/.config/nvim/
├── init.lua
└── lua/
    ├── options.lua
    ├── keymaps.lua
    └── plugins/
        ├── colorscheme.lua
        ├── lualine.lua
        ├── telescope.lua
        ├── treesitter.lua
        ├── lsp.lua
        ├── cmp.lua
        ├── neo-tree.lua
        ├── gitsigns.lua
        └── misc.lua

init.lua complet

-- ~/.config/nvim/init.lua

-- Bootstrap lazy.nvim
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not (vim.uv or vim.loop).fs_stat(lazypath) then
  vim.fn.system({
    "git", "clone", "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable",
    lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)

-- Options et raccourcis
require("options")
require("keymaps")

-- Plugins
require("lazy").setup("plugins")

Installation rapide

Copiez-collez ces commandes pour tout installer d'un coup :

# 1. Dépendances : git, compilation, recherche (Debian / Ubuntu)
sudo apt install git curl make gcc unzip ripgrep fd-find

# 2. Neovim 0.12.5 depuis l'archive officielle, empreinte vérifiée
curl -sSLO https://github.com/neovim/neovim/releases/download/v0.12.5/nvim-linux-x86_64.tar.gz
echo "bce0f56eda1f1b1db6eee8f4133d7a38813ea07933837dd1777411ca384c6875  nvim-linux-x86_64.tar.gz" \
  | sha256sum --check
sudo tar -xzf nvim-linux-x86_64.tar.gz -C /opt
sudo ln -sf /opt/nvim-linux-x86_64/bin/nvim /usr/local/bin/nvim

# 3. CLI tree-sitter, exigée par nvim-treesitter
curl -sSLO https://github.com/tree-sitter/tree-sitter/releases/download/v0.27.0/tree-sitter-linux-x64.gz
echo "20a1f39ec1c45f2211492dcb8881c802b643b554bb196869a29ac3778277fa77  tree-sitter-linux-x64.gz" \
  | sha256sum --check
gunzip tree-sitter-linux-x64.gz
sudo install -m 0755 tree-sitter-linux-x64 /usr/local/bin/tree-sitter

# 4. Créer la structure de configuration
mkdir -p ~/.config/nvim/lua/plugins

# 5. Copier les fichiers de configuration
#    (init.lua, options.lua, keymaps.lua, plugins/*.lua)

# 6. Lancer Neovim : lazy.nvim s'installe automatiquement
#    puis les plugins se téléchargent et les parsers se compilent
nvim

# 7. Dans Neovim, vérifier la santé de l'installation
# :checkhealth

Commandes Neovim spécifiques

En plus des commandes Vim que vous connaissez déjà, Neovim et les plugins de ce guide ajoutent des commandes propres, toutes vérifiées sur la 0.12.5 avec la configuration ci-dessus :

Commande	Ce qu'elle fait
:checkhealth	Diagnostic complet de l'installation (providers, plugins, LSP)
:Lazy	Ouvrir le gestionnaire de plugins (installer, mettre à jour, supprimer)
:Mason	Ouvrir le gestionnaire de serveurs LSP
:TSUpdate	Mettre à jour les parsers Tree-sitter installés
:checkhealth vim.lsp	Afficher les serveurs LSP actifs et leur configuration
:lsp restart	Redémarrer les serveurs LSP du buffer courant
:Telescope	Ouvrir Telescope (recherche fuzzy)
:Neotree toggle	Ouvrir/fermer l'explorateur de fichiers
:lua vim.print(vim.lsp.get_clients())	Lister les clients LSP connectés

Glissez pour voir

Migrer depuis Vim

Si vous avez une configuration Vim existante, la migration vers Neovim peut se faire progressivement, sans jamais casser votre environnement de travail : chaque étape reste utilisable seule.

Étape 1 : utiliser votre .vimrc existant

Créez un init.vim minimal qui utilise votre configuration Vim :

" ~/.config/nvim/init.vim
source ~/.vimrc

À ce stade, Neovim fonctionne exactement comme votre Vim configuré. Les plugins vim-plug continuent de fonctionner, et vous gagnez déjà les valeurs par défaut modernes de Neovim.

Étape 2 : migrer vers Lua progressivement

Gardez votre init.vim et ajoutez des fichiers Lua au fur et à mesure. Dans init.vim, vous pouvez charger du Lua avec la commande lua, ce qui permet de convertir un sujet à la fois, les options d'abord :

" ~/.config/nvim/init.vim
source ~/.vimrc
lua require('options')  " Charge lua/options.lua

Étape 3 : passer à init.lua

Quand vous êtes à l'aise, remplacez init.vim par init.lua et migrez les plugins vers lazy.nvim. Gardez l'ancien fichier sous un autre nom le temps de vérifier que :checkhealth ne signale aucune régression.

Plugins incompatibles

La plupart des plugins Vim fonctionnent dans Neovim, mais quelques-uns posent problème :

• coc.nvim : fonctionne mais devient redondant avec le LSP natif
• YouCompleteMe : incompatible, remplacer par nvim-cmp
• vim-airline : fonctionne mais lualine est plus rapide et mieux intégré

En général, les plugins tpope (vim-surround, vim-fugitive, vim-commentary) fonctionnent parfaitement dans Neovim, mais des alternatives existent : nvim-surround, gitsigns, et le commentaire natif gc à la place de vim-commentary.

Dépannage

La plupart des pannes d'une configuration Neovim viennent d'une dépendance externe absente (git, ripgrep, CLI tree-sitter, Node.js pour un serveur LSP) ou d'un tutoriel écrit pour une version plus ancienne. Le tableau suit cet ordre : outil manquant, puis commande qui a changé.

Symptôme	Cause probable	Solution
Pas de couleurs true color	Terminal ne supporte pas termguicolors	Vérifier que $TERM contient 256color ou truecolor
Erreur au lancement de lazy.nvim	Git non installé	sudo apt install git
Telescope :Telescope live_grep échoue	ripgrep manquant	sudo apt install ripgrep
LSP ne démarre pas	Serveur non installé	Ouvrir :Mason et installer le serveur
checkhealth affiche "provider not found"	Provider Python/Node manquant	sudo apt install python3-pynvim et/ou npm install -g neovim
Le presse-papier ne fonctionne pas	Outil clipboard manquant	Installer xclip (X11) ou wl-clipboard (Wayland)
Les icônes sont des carrés	Police Nerd Font manquante ou non configurée dans le terminal	Installer une Nerd Font et la configurer dans votre terminal. Sur WSL, la police doit être installée côté Windows
ENOENT … (cmd): 'tree-sitter' à l'installation des parsers	CLI tree-sitter absente ou trop ancienne	Installer la CLI 0.26.1 ou plus (section Tree-sitter) et build-essential
E492: Not an editor command: LspInfo	Neovim 0.12 : nvim-lspconfig ne crée plus cette commande	:checkhealth vim.lsp
E492: Not an editor command: TSInstallInfo	Commande retirée de la branche main de nvim-treesitter	:lua print(vim.inspect(require('nvim-treesitter').get_installed()))
Plugin non chargé	Erreur dans la spec lazy.nvim	Ouvrir :Lazy et vérifier les erreurs en rouge
Lenteur au démarrage	Trop de plugins chargés au démarrage	Utiliser le chargement paresseux (event, cmd, ft dans lazy.nvim)

Glissez pour voir

À retenir

• Neovim reprend l'essentiel de Vim (modes, motions, text objects) : vos réflexes d'édition fonctionnent tels quels, seuls quelques plugins anciens comme YouCompleteMe posent problème.
• Les paquets des distributions sont en retard : installez la 0.12 depuis l'archive officielle, empreinte SHA-256 vérifiée.
• La configuration en Lua est plus lisible, plus rapide et mieux structurée que le VimScript (fichiers modulaires dans lua/).
• Le LSP natif fournit l'autocomplétion, le diagnostic, la navigation vers les définitions et le renommage, des fonctionnalités d'IDE sans quitter le terminal ; K, grr, grn et [d/]d sont actifs par défaut.
• Tree-sitter offre une coloration syntaxique basée sur l'analyse du code (pas des regex), plus précise et plus fiable ; nvim-treesitter exige la CLI tree-sitter pour compiler ses parsers.
• Telescope remplace fzf.vim avec une interface plus riche et plus de sources (fichiers, texte, buffers, diagnostics, aide).
• lazy.nvim gère les plugins avec chargement paresseux, verrouillage des versions et interface graphique.
• La commande :checkhealth est votre premier réflexe en cas de problème, elle diagnostique toute la configuration ; :checkhealth vim.lsp remplace l'ancien :LspInfo.
• La migration depuis Vim est progressive : commencez par source ~/.vimrc, puis migrez vers Lua au fur et à mesure.

Contrôle de connaissances

Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

6 questions

6 min.

70% requis

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

Démarrer le quiz

Lance le quiz et démarre le chronomètre

×

📖 Voir la documentation →