Personnaliser le prompt Bash Linux : PS1, couleurs et infos

Le prompt Bash est la courte ligne de texte affichée avant chaque commande dans un terminal Linux. Beaucoup d’utilisateurs gardent le prompt par défaut, alors qu’il peut devenir un véritable outil de confort et de productivité. En personnalisant PS1, il est possible d’afficher des informations utiles comme le nom d’utilisateur, la machine, le dossier courant, l’heure ou encore le code de retour de la dernière commande.

Ce tutoriel explique en détail comment fonctionne le prompt Bash, comment modifier la variable PS1, ajouter des couleurs, structurer un prompt lisible et enregistrer la configuration de façon durable. L’objectif n’est pas de produire un prompt “joli” uniquement, mais un prompt pratique, clair et adapté à un usage quotidien.

Le sujet reste centré sur Bash et sur des mécanismes stables et largement documentés. Vous pourrez tester chaque étape immédiatement dans un terminal, sans risque majeur, puis conserver uniquement ce qui vous convient.

Prérequis

• Savoir ouvrir un terminal sous Linux.
• Utiliser le shell Bash.
• Connaître les commandes de base comme echo, cd et cat.
• Avoir accès à son fichier personnel ~/.bashrc.

Matériel nécessaire

• Un système Linux avec Bash
• Un terminal graphique ou une console texte
• Un éditeur de texte comme nano, vim ou gedit
• Un compte utilisateur standard

Étapes

1. 1

   Comprendre ce qu’est PS1

   Dans Bash, le prompt principal est défini par la variable d’environnement PS1. C’est elle qui détermine le texte affiché avant la saisie de chaque commande. Vous pouvez voir sa valeur actuelle avec :

   bash

   echo "$PS1"

   Selon la distribution Linux, le contenu peut être simple ou plus complexe. Certaines distributions utilisent déjà des couleurs, affichent le nom d’utilisateur ou raccourcissent le chemin courant.

   Le prompt n’est pas qu’un élément décoratif. Il sert à fournir un contexte immédiat : sur quelle machine vous êtes, dans quel répertoire, avec quel utilisateur, et parfois dans quel environnement de travail. Cela devient particulièrement utile si vous ouvrez plusieurs terminaux ou si vous travaillez localement et à distance.

   La variable PS1 accepte des séquences spéciales interprétées par Bash. Par exemple, \u représente le nom de l’utilisateur, \h le nom de la machine et \w le répertoire courant complet avec ~ pour le dossier personnel.

   Un exemple minimal :

   bash

   PS1="\u@\h:\w\\$ "

   Ce prompt affiche un format classique du type utilisateur@machine:/chemin$. Le caractère final dépend du privilège : en pratique, \$ affiche généralement $ pour un utilisateur normal et # pour le superutilisateur.

   Vous pouvez tester cette affectation directement dans le terminal. Le changement est immédiat, mais temporaire : il disparaîtra à la fermeture de la session si vous ne l’enregistrez pas dans votre configuration Bash.

2. 2

   Tester un prompt temporaire sans risque

   

   

   

   Avant de modifier vos fichiers de configuration, il est conseillé de faire des essais temporaires. Dans un terminal Bash, saisissez par exemple :

   bash

   PS1="[\u@\h] \w \\$ "

   Le prompt change aussitôt. Vous pouvez alors naviguer avec cd, lancer quelques commandes et observer le résultat.

   Cette méthode est utile pour comprendre le rôle de chaque séquence. Voici quelques séquences parmi les plus courantes :

   • \u : nom de l’utilisateur
   • \h : nom d’hôte court
   • \H : nom d’hôte complet
   • \w : chemin courant complet avec ~
   • \W : nom du répertoire courant seulement
   • \t : heure au format 24 h avec secondes
   • \A : heure au format 24 h sans secondes
   • \d : date
   • \n : saut de ligne
   • \\ : antislash littéral
   • \$ : symbole adapté au niveau de privilège

   Exemple avec l’heure :

   bash

   PS1="[\A] \u@\h \W \\$ "

   Exemple sur deux lignes :

   bash

   PS1="\u@\h \w\n\\$ "

   Le prompt sur deux lignes améliore souvent la lisibilité, surtout quand le chemin devient long. La première ligne peut servir au contexte, la seconde à la saisie.

   Si un essai ne vous plaît pas, vous pouvez fermer le terminal ou rétablir une autre valeur de PS1. Comme vous travaillez uniquement en mémoire à ce stade, vous ne risquez pas de casser durablement votre environnement.

3. 3

   Connaître les séquences utiles de Bash pour le prompt

   Pour bien personnaliser son prompt, il faut distinguer les informations réellement utiles de celles qui surchargent l’affichage. Un bon prompt donne un contexte rapide sans détourner l’attention.

   Voici les éléments les plus pertinents dans beaucoup de cas :

   • Utilisateur avec \u : utile si vous alternez entre plusieurs comptes.
   • Machine avec \h : très utile en SSH ou en administration.
   • Répertoire courant avec \w ou \W : probablement l’information la plus consultée.
   • Heure avec \A ou \t : pratique pour garder une trace visuelle rapide.
   • Saut de ligne avec \n : utile pour aérer.
   • Symbole final avec \$ : indispensable pour distinguer facilement utilisateur normal et root.

   Exemple équilibré :

   bash

   PS1="[\A] \u@\h: \W\n\\$ "

   Ce prompt indique l’heure, l’utilisateur, la machine et le dossier courant sur la première ligne, puis laisse une seconde ligne claire pour la saisie.

   Un autre choix fréquent consiste à afficher le chemin complet avec \w. C’est plus informatif, mais parfois plus verbeux. Si vous travaillez souvent dans des arborescences profondes, un prompt sur deux lignes compense bien cet encombrement visuel.

   À l’inverse, un prompt trop chargé peut devenir contre-productif. Par exemple, empiler date, heure détaillée, utilisateur, machine, chemin complet, variables diverses et informations annexes n’aide pas toujours à travailler plus vite. La personnalisation doit servir l’usage réel.

4. 4

   Ajouter des couleurs au prompt Bash

   Les couleurs permettent d’améliorer la lisibilité du prompt. On peut par exemple distinguer visuellement l’utilisateur, la machine et le chemin. Sous Bash, cela se fait généralement avec des séquences d’échappement ANSI intégrées dans PS1.

   Lorsqu’on insère des séquences non imprimables dans le prompt, il faut les entourer avec \[ et \]. C’est important pour que Bash calcule correctement la longueur visible de la ligne. Sans cela, l’édition de commande peut devenir incorrecte, notamment lors des retours à la ligne ou des déplacements du curseur.

   Exemple simple avec couleurs :

   bash

   PS1="\[\e[32m\]\u@\h\[\e[0m\]:\[\e[34m\]\w\[\e[0m\] \\$ "

   Dans cet exemple :

   • \e[32m active le vert
   • \e[34m active le bleu
   • \e[0m réinitialise les attributs

   Le nom d’utilisateur et la machine sont en vert, tandis que le chemin est en bleu.

   Quelques codes de couleurs classiques :

   • 30 : noir
   • 31 : rouge
   • 32 : vert
   • 33 : jaune
   • 34 : bleu
   • 35 : magenta
   • 36 : cyan
   • 37 : blanc ou gris clair selon le terminal

   On peut aussi utiliser des attributs comme 1 pour un affichage plus intense selon le terminal. Exemple :

   bash

   PS1="\[\e[1;32m\]\u@\h\[\e[0m\] \[\e[1;34m\]\W\[\e[0m\] \\$ "

   Il faut rester modéré. Trop de couleurs rendent le prompt fatigant. En pratique, deux ou trois couleurs bien choisies suffisent largement.

5. 5

   Créer un prompt pratique et lisible

   Le meilleur prompt n’est pas forcément le plus sophistiqué. Il doit rester rapide à lire. Voici plusieurs modèles utiles à adapter.

   Modèle sobre et classique :

   bash

   PS1="\u@\h:\w \\$ "

   Avantages : très standard, facile à reconnaître, peu de distraction.

   Modèle coloré simple :

   bash

   PS1="\[\e[32m\]\u@\h\[\e[0m\]:\[\e[34m\]\w\[\e[0m\] \\$ "

   Avantages : lecture plus rapide grâce à la séparation visuelle.

   Modèle sur deux lignes :

   bash

   PS1="\[\e[36m\][\A]\[\e[0m\] \u@\h \[\e[33m\]\w\[\e[0m\]\n\\$ "

   Avantages : bon confort dans les chemins longs.

   Modèle minimaliste :

   bash

   PS1="\W \\$ "

   Avantages : parfait si vous préférez un terminal très épuré.

   Pour choisir, posez-vous quelques questions :

   • Ai-je souvent plusieurs terminaux ouverts en parallèle ?
   • Ai-je besoin de savoir immédiatement sur quelle machine je travaille ?
   • Le chemin complet m’est-il utile en permanence ?
   • Un prompt sur deux lignes améliore-t-il ma lecture ?
   • Les couleurs me facilitent-elles vraiment le repérage ?

   Le bon design de prompt dépend souvent de votre contexte : poste personnel, machine de développement, serveur distant ou terminal intégré dans un éditeur.

6. 6

   Afficher le code de retour de la dernière commande

   Une amélioration très utile consiste à afficher le code de retour de la commande précédente. Sous Unix et Linux, une commande réussie renvoie généralement 0. Une erreur renvoie une valeur différente.

   Dans Bash, la variable spéciale $? contient ce code de retour. On peut l’intégrer dans le prompt, mais il faut le faire proprement pour éviter d’afficher un résultat trompeur ou de casser l’évaluation au mauvais moment.

   Une méthode simple consiste à utiliser une fonction Bash qui prépare PS1 avant l’affichage du prompt. Par exemple, vous pouvez tester dans votre terminal :

   bash

   set_prompt() {
     local exit_code=$?
     PS1="[retour:${exit_code}] \u@\h \W \\$ "
   }
   PROMPT_COMMAND=set_prompt

   Le mécanisme est le suivant :

   • PROMPT_COMMAND exécute une commande ou une fonction juste avant l’affichage du prompt.
   • La fonction récupère d’abord le code de retour de la commande précédente dans une variable locale.
   • Puis elle construit PS1 en y insérant cette valeur.

   Vous pouvez ensuite lancer une commande réussie comme :

   bash

   true

   Puis une commande qui échoue, par exemple :

   bash

   false

   Le nombre affiché dans le prompt change.

   Pour rendre l’information plus discrète, on peut n’afficher le code de retour qu’en cas d’erreur. Exemple :

   bash

   set_prompt() {
     local exit_code=$?
     local status=""
     if [ "$exit_code" -ne 0 ]; then
       status="[retour:${exit_code}] "
     fi
     PS1="${status}\u@\h:\w \\$ "
   }
   PROMPT_COMMAND=set_prompt

   Ce modèle est souvent plus agréable au quotidien, car le prompt reste simple quand tout va bien et met en évidence uniquement les échecs.

7. 7

   Enregistrer la configuration dans ~/.bashrc

   Une fois votre prompt choisi, vous pouvez le rendre permanent en l’ajoutant au fichier ~/.bashrc. Ce fichier est lu par Bash pour les sessions interactives selon la configuration habituelle de l’environnement.

   Avant toute modification, faites une sauvegarde :

   bash

   cp ~/.bashrc ~/.bashrc.sauvegarde

   Ouvrez ensuite le fichier avec un éditeur de texte. Avec nano par exemple :

   bash

   nano ~/.bashrc

   Ajoutez à la fin du fichier une affectation simple, par exemple :

   bash

   PS1="\[\e[32m\]\u@\h\[\e[0m\]:\[\e[34m\]\w\[\e[0m\] \\$ "

   Si vous préférez une version basée sur une fonction et PROMPT_COMMAND, ajoutez plutôt un bloc comme celui-ci :

   bash

   set_prompt() {
     local exit_code=$?
     local status=""
     if [ "$exit_code" -ne 0 ]; then
       status="[retour:${exit_code}] "
     fi
     PS1="${status}\[\e[32m\]\u@\h\[\e[0m\]:\[\e[34m\]\w\[\e[0m\] \\$ "
   }
   PROMPT_COMMAND=set_prompt

   Enregistrez le fichier, puis rechargez la configuration sans fermer le terminal :

   bash

   source ~/.bashrc

   Si le résultat ne vous convient pas, restaurez l’ancienne version :

   bash

   cp ~/.bashrc.sauvegarde ~/.bashrc
   source ~/.bashrc

   Cette méthode permet d’expérimenter sans crainte. Une simple sauvegarde suffit généralement à revenir en arrière.

8. 8

   Différencier visuellement un shell root ou distant

   Une personnalisation intelligente du prompt peut aussi limiter les erreurs. Il est fréquent de vouloir différencier clairement un shell normal, un shell root ou une session distante en SSH.

   La distinction la plus simple repose déjà sur \$, qui affiche un symbole différent selon le privilège. Mais on peut aller plus loin, par exemple en utilisant une couleur plus visible pour les sessions sensibles.

   Exemple d’idée simple : un prompt rouge pour le superutilisateur. Si vous êtes dans un shell root Bash, vous pouvez définir :

   bash

   PS1="\[\e[31m\]\u@\h:\w\[\e[0m\] \\$ "

   Pour un utilisateur normal, vous pourriez conserver du vert ou du bleu. L’objectif n’est pas esthétique : il s’agit surtout d’éviter une commande destructrice lancée au mauvais endroit.

   Sur une machine distante, l’affichage du nom d’hôte devient encore plus important. Un prompt du type suivant aide à repérer immédiatement le contexte :

   bash

   PS1="[\u@\h] \w \\$ "

   Si vous ouvrez plusieurs sessions SSH en parallèle, vous pouvez même choisir des variantes selon les machines en modifiant manuellement le prompt sur chacune, ou en prévoyant une logique conditionnelle dans ~/.bashrc. L’idée générale reste stable : rendre visibles les contextes où une erreur coûterait plus cher.

9. 9

   Structurer un prompt avancé sans le rendre fragile

   Avec le temps, il est tentant d’ajouter de nombreux éléments au prompt. Pourtant, plus il devient complexe, plus il faut veiller à sa robustesse. Quelques principes simples évitent bien des problèmes.

   • Encadrez toujours les séquences non imprimables avec \[ et \].
   • Réinitialisez les couleurs avec \e[0m pour éviter qu’elles débordent sur la saisie.
   • Testez le prompt sur plusieurs largeurs de terminal.
   • Évitez d’ajouter des traitements lourds à chaque affichage du prompt.
   • Préférez des informations réellement consultées.

   Exemple de prompt avancé mais encore lisible :

   bash

   set_prompt() {
     local exit_code=$?
     local status=""
     if [ "$exit_code" -ne 0 ]; then
       status="\[\e[31m\][retour:${exit_code}]\[\e[0m\] "
     fi
     PS1="${status}\[\e[36m\][\A]\[\e[0m\] \[\e[32m\]\u@\h\[\e[0m\] \[\e[34m\]\w\[\e[0m\]\n\\$ "
   }
   PROMPT_COMMAND=set_prompt

   Ce prompt montre :

   • le code de retour en rouge si nécessaire ;
   • l’heure ;
   • l’utilisateur et la machine ;
   • le chemin courant ;
   • une seconde ligne pour la saisie.

   Dans un usage quotidien, ce type de compromis fonctionne souvent mieux qu’un prompt très chargé avec de nombreuses informations secondaires.

10. 10

    Revenir en arrière et dépanner un prompt cassé

    Il arrive qu’un prompt mal formé provoque un affichage étrange : curseur décalé, retour à la ligne incorrect, couleurs persistantes ou texte illisible. Ces problèmes viennent souvent d’une séquence d’échappement mal fermée ou de l’absence de \[ et \] autour des séquences non imprimables.

    Pour dépanner rapidement dans la session en cours, vous pouvez remettre un prompt très simple :

    bash

    PS1="\u@\h:\w \\$ "

    Si le problème vient de ~/.bashrc, ouvrez le fichier, corrigez la ligne fautive puis rechargez :

    bash

    nano ~/.bashrc
    source ~/.bashrc

    En cas de doute, restaurez la sauvegarde :

    bash

    cp ~/.bashrc.sauvegarde ~/.bashrc
    source ~/.bashrc

    Autres points de vérification :

    • Les guillemets sont-ils correctement ouverts et fermés ?
    • Les séquences de couleur sont-elles bien réinitialisées ?
    • Le prompt contient-il des caractères spéciaux mal échappés ?
    • Une fonction appelée par PROMPT_COMMAND contient-elle une erreur de syntaxe ?

    Procédez par petites étapes. Modifiez un élément, testez, puis ajoutez le suivant. Cette méthode est la plus fiable pour construire un prompt personnalisé propre.

Erreurs fréquentes & dépannage

• Oublier \[ et \] autour des couleurs : cela perturbe le calcul de la longueur du prompt.
• Ne pas réinitialiser la couleur avec \e[0m : la commande saisie peut hériter de la couleur du prompt.
• Modifier ~/.bashrc sans sauvegarde : toujours créer une copie avant expérimentation.
• Surcharger le prompt : trop d’informations diminuent la lisibilité.
• Confondre test temporaire et configuration permanente : une affectation dans le terminal n’est pas conservée après fermeture de session.
• Introduire une logique trop complexe dans PROMPT_COMMAND : un prompt doit rester léger et fiable.

Astuces & pour aller plus loin

• Commencez par un prompt simple, puis ajoutez les éléments un par un.
• Utilisez un prompt sur deux lignes si vous travaillez souvent dans des chemins longs.
• Affichez systématiquement le nom d’hôte si vous utilisez SSH.
• Réservez une couleur d’alerte, par exemple le rouge, aux contextes sensibles comme root.
• Affichez le code de retour seulement en cas d’erreur pour conserver un prompt sobre.
• Gardez un modèle de secours facile à recopier : PS1="\u@\h:\w \\$ ".

Questions fréquentes

Quelle est la différence entre un changement temporaire et permanent de PS1 ?

Un changement temporaire est saisi directement dans le terminal et ne dure que pour la session en cours. Un changement permanent est ajouté dans ~/.bashrc puis rechargé avec source ~/.bashrc.

Pourquoi faut-il utiliser \[ et \] avec les couleurs ?

Parce que les séquences ANSI de couleur ne sont pas des caractères visibles. Bash doit savoir qu’elles ne comptent pas dans la longueur affichée du prompt, sinon l’édition de ligne peut être incorrecte.

Puis-je afficher uniquement le nom du dossier courant ?

Oui. Utilisez \W au lieu de \w. \W affiche seulement le nom du répertoire courant.

Comment revenir rapidement à un prompt normal ?

Vous pouvez définir un prompt simple comme PS1="\u@\h:\w \\$ ". Si le problème vient de ~/.bashrc, restaurez votre sauvegarde puis rechargez le fichier.

Est-ce que cette personnalisation fonctionne avec tous les shells ?

Non, ce tutoriel vise Bash. D’autres shells existent et ont leur propre système de configuration du prompt.

PROMPT_COMMAND est-il obligatoire ?

Non. Pour un prompt statique, une simple affectation de PS1 suffit. PROMPT_COMMAND devient utile quand vous voulez recalculer dynamiquement certaines informations avant chaque affichage du prompt.

Conclusion

Personnaliser le prompt Bash est une amélioration simple, mais très rentable au quotidien. En maîtrisant PS1, vous pouvez afficher exactement les informations qui vous aident à travailler plus vite : utilisateur, machine, chemin, heure, statut de la dernière commande et repères visuels grâce aux couleurs.

La meilleure approche consiste à commencer avec une base minimale, à tester vos idées directement dans le terminal, puis à enregistrer une version stable dans ~/.bashrc. Un bon prompt reste lisible, léger et adapté à votre usage réel. Si vous administrez plusieurs machines ou alternez entre comptes, une personnalisation réfléchie devient vite indispensable.

En pratique, quelques séquences Bash bien choisies suffisent pour transformer un prompt ordinaire en outil d’orientation fiable et agréable.