Le code de la barre des tâches ouvert directement dans l'éditeur intégré de GrimOS.
Dans un monde technologique où la course à la puissance semble sans fin, l'industrie informatique nous pousse inexorablement vers le renouvellement constant de nos équipements. Chaque nouvelle version d'un système d'exploitation grand public exige davantage de mémoire vive, des processeurs plus véloces et des espaces de stockage gigantesques. Face à cette surenchère, une question fondamentale se pose : nos besoins réels ont-ils évolué de manière aussi exponentielle que le matériel que l'on nous impose ?
C'est de cette interrogation qu'est né le projet GrimOS.
Le nom GrimOS n'a pas été choisi au hasard. C'est l'acronyme de Graphical Resource-Independent Minimal Operating System (Système d'Exploitation Graphique Minimal et Indépendant des Ressources). Ce nom porte en lui la promesse centrale du projet : offrir une interface graphique complète et fonctionnelle, tout en s'affranchissant de la course aux ressources matérielles.
L'objectif initial et le moteur principal de GrimOS sont profondément ancrés dans une démarche de lutte contre l'obsolescence programmée et le gaspillage électronique. Aux quatre coins du monde, des millions d'ordinateurs parfaitement fonctionnels dorment dans des placards ou finissent à la décharge. Leur seul tort ? Ne plus être capables de faire tourner les lourdes interfaces graphiques et les services en arrière-plan imposés par les systèmes modernes.
GrimOS a été conçu avec une ambition claire : ressusciter ces machines. En ciblant un environnement minimaliste, capable de s'exécuter sur du matériel très modeste (comme un Raspberry Pi ancien ou un ordinateur portable datant de plus d'une décennie), GrimOS prouve qu'une machine "obsolète" peut encore offrir une expérience fluide, réactive et utile. Que ce soit pour naviguer sur le web de manière basique, éditer des textes, organiser des fichiers ou s'initier à la programmation, la puissance nécessaire est en réalité bien en deçà des standards actuels de l'industrie.
La philosophie de GrimOS s'articule autour de trois piliers fondamentaux : le minimalisme, la lisibilité et l'auto-détermination.
Le minimalisme : Là où les systèmes traditionnels empilent les couches d'abstraction (gestionnaires de fenêtres complexes, daemons de télémétrie, services de mise à jour automatiques imposés), GrimOS revient à l'essentiel. L'interface est dessinée pixel par pixel via Python et Tkinter, éliminant le besoin de lourds serveurs d'affichage. Chaque widget, de la barre des tâches au moniteur système graphique, a été codé pour n'utiliser que les ressources strictement nécessaires.
La lisibilité (Le "DIY" informatique) : L'une des plus grandes forces de GrimOS est d'être écrit en Python, un langage interprété et reconnu pour sa clarté. Contrairement aux OS classiques, compilés et transformés en boîtes noires hermétiques, le code source de GrimOS est son propre manuel. N'importe quel utilisateur curieux peut ouvrir core/desktop.py avec l'éditeur de texte intégré, comprendre comment la barre des tâches est dessinée, la modifier à sa guise et relancer l'interface instantanément. GrimOS n'est pas seulement un système d'exploitation, c'est un bac à sable pédagogique.
Le code de la barre des tâches ouvert directement dans l'éditeur intégré de GrimOS.
L'auto-détermination : GrimOS redonne le pouvoir à l'utilisateur. Rien ne s'exécute sans raison, aucune donnée n'est envoyée à l'insu de l'utilisateur. Le système fait exactement ce qu'on lui demande, ni plus ni moins.
Pour bien comprendre la place de GrimOS, il est essentiel de le comparer aux géants modernes (Windows, macOS, et même certaines distributions Linux grand public comme Ubuntu).
Les systèmes modernes souffrent de ce que l'on appelle l'inflation logicielle. Lors d'un démarrage typique, un OS moderne consomme souvent entre 2 et 4 Go de mémoire vive simplement pour afficher le bureau, accaparé par des indexeurs de fichiers, des antivirus, des stores d'applications et des services de synchronisation cloud. L'approche GrimOS : Au démarrage (Boot-to-GUI via X11 sans gestionnaire de session lourd), GrimOS consomme à peine quelques dizaines de mégaoctets de RAM. L'interface graphique est directement liée à l'interpréteur Python.
Sur les OS modernes, l'utilisateur est devenu un simple "consommateur" de l'interface. Modifier le comportement fondamental de la barre des tâches, ou ajouter une fonction spécifique au cœur du système relève du parcours du combattant ou de la rétro-ingénierie.
L'approche GrimOS : Le système est un ensemble modulaire de scripts Python et de configurations JSON (applications.json). L'utilisateur est invité à devenir l'architecte de son propre système. Le bureau n'est qu'une surcouche applicative transparente reposant sur un socle Debian extrêmement solide.
Le fichier de configuration JSON qui gère le menu "Démarrer" de GrimOS.
Aujourd'hui, l'ordinateur personnel n'a jamais été aussi connecté... aux serveurs de ses créateurs. Les systèmes d'exploitation modernes récoltent en continu des données d'utilisation sous couvert d'amélioration du service. L'approche GrimOS : GrimOS est inerte d'un point de vue réseau tant que l'utilisateur ne le sollicite pas explicitement (via le navigateur ou des requêtes réseau volontaires). Le système respecte l'intimité de manière absolue.
En conclusion, GrimOS n'a pas la prétention de remplacer les systèmes modernes pour le traitement vidéo 8K ou les jeux vidéo de dernière génération. Sa mission est tout autre : prouver qu'une informatique frugale, élégante, transparente et réparable par tous est non seulement possible, mais extrêmement gratifiante. Les chapitres suivants détailleront l'architecture technique qui a permis de donner vie à cette vision.
Bien que GrimOS soit extrêmement léger et repose sur un socle technique minimaliste, il est livré "clés en main" avec tout le nécessaire pour une utilisation quotidienne classique. Ce chapitre dresse un inventaire des fonctionnalités natives de la version actuelle.
Au démarrage, GrimOS accueille l'utilisateur avec une interface graphique familière, conçue en pur Python (via Tkinter) pour ne dépendre d'aucun gestionnaire de fenêtres lourd (comme GNOME ou KDE).
Aperçu du bureau principal avec son moniteur système interactif.
GrimOS fournit un écosystème d'applications de base, chacune pensée pour consommer le moins de mémoire possible.
Véritable centre névralgique, l'explorateur permet de naviguer dans l'arborescence du système. Il intègre des fonctions avancées telles que :
L'explorateur de fichiers naviguant dans les dossiers systèmes.
Plus qu'un simple bloc-notes, l'éditeur de GrimOS est un outil idéal pour la productivité et la programmation. Il permet bien sûr de prendre des notes, mais il offre aussi la possibilité de modifier directement le code source du système (fichiers Python, JSON) et d'exécuter des scripts à la volée.
L'éditeur de code intégré avec coloration syntaxique.
Pour l'accès à Internet, GrimOS intègre une solution d'une frugalité redoutable. Reposant sur un moteur allégé (comme surf), le navigateur permet de consulter des pages web complexes sans saturer la mémoire vive de la machine, tout en s'intégrant parfaitement dans le fenêtrage de l'OS.
Navigation web ultra-légère directement intégrée.
Terminal (Xterm) : Pour les utilisateurs avancés, un émulateur de terminal est directement accessible, parfaitement dimensionné dans l'interface, permettant d'interagir avec le noyau Debian sous-jacent.
Imprimante : Un gestionnaire basé sur CUPS permet de détecter automatiquement les imprimantes locales ou réseau et de lancer des pages de test sans ligne de commande.
Caméra : Une application légère pour capturer des photos via une webcam connectée.
L'un des aspects les plus uniques de GrimOS est sa malléabilité.
L'application Paramètres permet de changer de thème à la volée.
Avec ces outils, un vieil ordinateur équipé de GrimOS redevient immédiatement une station de travail capable de rédiger, de naviguer, de coder et de communiquer, le tout avec une consommation de ressources défiant toute concurrence.
GrimOS est conçu pour être aussi lisible qu'un livre ouvert. Son architecture repose sur une séparation stricte entre le noyau (la boucle principale et le bureau), le gestionnaire de fenêtres, et les applications tierces.
L'ensemble du système d'exploitation est structuré dans un dossier unique (grimos_build), sans fichiers éparpillés dans le système de fichiers linux.
La Fondation de GrimOS est structurée en trois couches principales, emboîtées comme des poupées russes :
main.py : Point d'entrée de l'application. Initialise la fenêtre Tkinter plein écran.core/desktop.py : Construit l'environnement visuel (fond d'écran, barre des tâches, horloge).core/app_manager.py : Le moteur qui lance et ferme les applications.core/window.py : Génère le "simulacre" de fenêtre (cadre, barre de titre, boutons).apps/ : Dossier contenant toutes les applications indépendantes (editeur, terminal, etc.).config/applications.json : Le registre déclarant ces applications pour le menu Démarrer.L'architecture est construite en 3 couches horizontales :
core/)Le dossier core/ contient le "noyau" de GrimOS. Ce sont les fichiers critiques qui maintiennent l'illusion du système d'exploitation. L'approche de GrimOS prend ce concept à rebours : c'est l'interface graphique qui est le cœur du système.
graph TD
A[Noyau Linux / Shell] -->|Bypass| B[Python / Tkinter main.py]
B --> C(Gestionnaire de Fenêtres Virtuel)
B --> D(Services Intégrés)
D --> E[wpa_cli Wi-Fi]
D --> F[lsblk USB Mount]
C --> G[Applications Python apps/]
Dès le démarrage, le système Unix lance immédiatement un gigantesque script Python (main.py). (À la racine)
C'est l'étincelle qui allume le moteur. Ce fichier initialise Tkinter (root = tk.Tk()), force l'affichage en plein écran sans bordures, et appelle le Desktop. Il ne contient aucune logique métier.
core/desktop.py (Le Bureau)C'est le chef d'orchestre visuel.
applications.json pour construire dynamiquement le menu Démarrer.core/window.py (Le Simulacre de Fenêtre)C'est le secret technique de GrimOS.
Frame) qui ressemble à une fenêtre (avec une barre de titre bleue, un bouton croix rouge pour fermer, et des bordures). Il gère mathématiquement la logique de "cliquer-glisser" pour permettre à l'utilisateur de déplacer ces fausses fenêtres sur l'écran.core/app_manager.py (Le Chargeur d'Applications)AppManager va importer dynamiquement le module Python demandé (par exemple apps.editeur.app), instancier un conteneur Window, et injecter cette fenêtre dans le module de l'application via la fonction start(window).core/theme.py, wifi.py, audio.pyCes modules sont des assistants (helpers) :
theme.py : Fournit les codes couleurs et les polices (style "Classic 98" ou "Modern Dark").wifi.py & audio.py : Sont des ponts (wrappers) qui envoient des commandes silencieuses au système Debian sous-jacent (comme nmcli pour le réseau ou amixer pour le son) et renvoient le résultat à l'interface Python.apps/)Dans GrimOS, une application n'est pas un fichier exécutable binaire (.exe ou fichier ELF). C'est un simple dossier contenant un fichier app.py.
Si vous explorez apps/editeur/ ou apps/explorateur/, vous y trouverez toujours la même architecture minimale :
app.py : Le fichier principal.start(window)Toutes les applications GrimOS obéissent à un "contrat" (une interface). Le fichier app.py doit contenir une fonction nommée start qui prend au moins un argument :
def start(window, app_manager=None, **kwargs):
# La magie opère ici
L'argument window n'est pas la fenêtre principale de l'ordinateur, mais le "panneau intérieur" de la fausse fenêtre générée par window.py. L'application n'a plus qu'à dessiner ses boutons et ses textes à l'intérieur de ce panneau, sans jamais se soucier de savoir comment elle peut être déplacée ou fermée.
config/)Pour rester facilement modifiable, GrimOS extrait sa configuration du code source.
applications.jsonC'est le registre du système. Il contient une liste de toutes les applications installées sous forme de tableau JSON.
Pour installer une nouvelle application, il suffit de copier son dossier dans apps/, puis d'ajouter quelques lignes dans applications.json :
{
"name": "Éditeur de Code",
"module": "apps.editeur.app",
"icon": "icons/editeur.png",
"category": "Développement"
}
Au prochain démarrage, l'application apparaîtra automatiquement dans le menu Démarrer sous la bonne catégorie, avec sa propre icône. C'est cette simplicité absolue qui différencie l'architecture de GrimOS de celle des monstres logiciels de notre époque.
L'une des particularités de GrimOS est son traitement du "Terminal" (la ligne de commande administrateur). Plutôt que de s'enfermer dans un terminal virtuel instable à l'intérieur de l'interface graphique, GrimOS joue la carte de l'architecture Unix pure.
Dans le menu Démarrer, le bouton "Fermer la session" ne fait pas qu'éteindre l'ordinateur. Il met fin au processus Python (main.py) et tue le serveur graphique X11.
L'écran noir redescend alors brutalement, révélant le véritable terminal maître de Debian (le TTY). Dans ce terminal natif, l'utilisateur possède un accès absolu et inébranlable (sudo) pour mettre à jour son système ou installer des paquets complexes (sans aucun bug d'affichage).
Une fois son administration système terminée, il lui suffit de taper startx pour relancer instantanément la machine dans le monde coloré et fenêtré de GrimOS, ou de taper exit pour déclencher une reconnexion automatique.
Dans le chapitre précédent, nous avons vu que GrimOS ne possède pas de "bureau" au sens Unix du terme. Chaque fenêtre n'est en fait qu'un petit composant (un Frame Tkinter) dessiné à l'intérieur de l'application principale.
Maintenant que vous avez compris l'architecture de GrimOS (Chapitre 4) et que votre environnement de développement à distance est prêt (Chapitre 3), il est temps de mettre les mains dans le code !
Dans ce chapitre, nous allons créer ensemble une application de A à Z : une petite Calculatrice.
Toutes les applications de GrimOS vivent de manière indépendante dans le dossier apps/.
Pour commencer, créez un nouveau dossier nommé calculatrice dans ce répertoire.
💻 Terminal :
cd grimos_build/apps/
mkdir calculatrice
À l'intérieur de ce dossier, créez un fichier Python nommé obligatoirement app.py. C'est le point d'entrée que le moteur de GrimOS cherchera à lancer.
Ouvrez le fichier app.py. Pour qu'une application soit reconnue par le système, elle doit posséder une fonction nommée start(window, app_manager=None, **kwargs).
L'argument window correspond au "panneau intérieur" de la fenêtre. C'est un simple cadre (Frame) Tkinter dans lequel nous avons le droit de dessiner.
Copiez le code suivant :
import tkinter as tk
from tkinter import messagebox
def start(window, app_manager=None, **kwargs):
# Changement de la couleur de fond du panneau
window.configure(bg="#f0f0f0")
# Titre de l'application
titre = tk.Label(window, text="Calculatrice GrimOS", font=("Arial", 16, "bold"), bg="#f0f0f0")
titre.pack(pady=10)
# Un champ de texte pour taper le calcul
entree = tk.Entry(window, font=("Arial", 14), width=20)
entree.pack(pady=10)
# Fonction qui sera appelée quand on clique sur le bouton
def calculer():
expression = entree.get()
try:
# Évaluation mathématique simple
resultat = eval(expression)
messagebox.showinfo("Résultat", f"Le résultat est : {resultat}")
except Exception as e:
messagebox.showerror("Erreur", "Calcul invalide !")
# Le bouton d'action
btn = tk.Button(window, text="Calculer", font=("Arial", 12), command=calculer)
btn.pack(pady=10)
Explications :
tkinter pour dessiner nos boutons et nos champs de texte.window comme "parent" pour tous nos composants (Label, Entry, Button). C'est ce qui permet à l'application d'être proprement contenue dans la fenêtre générée par GrimOS.eval() est utilisée ici pour la simplicité de l'exemple afin de calculer mathématiquement le texte tapé par l'utilisateur.Si vous lancez GrimOS maintenant, votre application existe bien sur le disque dur, mais le système ne la connaît pas encore. Il faut l'inscrire dans le grand registre : le fichier config/applications.json.
Ouvrez ce fichier et ajoutez un nouveau bloc à la fin de la liste (n'oubliez pas la virgule après le bloc précédent !) :
{
"name": "Calculatrice",
"module": "apps.calculatrice.app",
"icon": "icons/terminal.png",
"category": "Bureautique"
}
Note : Pour l'icône, nous utilisons ici temporairement l'icône du terminal (icons/terminal.png). Vous pourrez par la suite ajouter votre propre fichier calculatrice.png dans le dossier icons/.
C'est l'heure de vérité. Relancez GrimOS (ou cliquez sur "Redémarrer GrimOS" dans le menu Démarrer si vous êtes déjà connecté).
Une magnifique fenêtre s'ouvre ! Vous pouvez la déplacer en cliquant sur sa barre de titre bleue, la redimensionner (si autorisé) et la fermer avec la croix rouge. Tout ce "simulacre de fenêtre" a été généré automatiquement par core/window.py sans que vous n'ayez eu à écrire une seule ligne de code pour le gérer.
Tapez 5 + 5 * 2 dans le champ et cliquez sur Calculer. Une petite fenêtre d'alerte s'ouvrira pour vous afficher le résultat : 15.
Félicitations, vous venez de créer votre première application native pour GrimOS !
L'architecture est volontairement d'une simplicité enfantine. Que vous vouliez développer un simple lecteur de musique, un jeu de démineur ou un outil de surveillance réseau, le principe sera exactement le même : un dossier dans apps/, une fonction start(), et une déclaration JSON.
La seule limite est votre imagination et vos connaissances en Python !
Ce chapitre vous guide étape par étape pour transformer n'importe quel vieil ordinateur ou machine virtuelle en une station GrimOS complète, de la façon la plus simple et la plus fiable possible.
Comment transforme-t-on un PC vide en une machine GrimOS fully-fonctionnelle ?
Historiquement, les systèmes d'exploitation (comme Windows ou Ubuntu) sont distribués sous forme de fichiers "ISO" amorçables. C'est un énorme fichier de plusieurs gigaoctets contenant l'intégralité du système pré-compilé.
Cependant, générer une image ISO personnalisée est un processus complexe, très lourd et difficile à maintenir (les outils de live-build évoluent sans cesse).
Dans la philosophie de simplicité de GrimOS, nous avons opté pour une approche beaucoup plus élégante et universelle : La méthode des deux clés USB.
install_grimos.sh.Cette séparation des pouvoirs garantit que GrimOS reposera toujours sur un socle Debian officiel, propre, certifié et à jour, sans avoir à gérer nous-mêmes la lourdeur de la compilation d'un noyau Linux.
La première étape de l'installation de GrimOS consiste à installer un "moteur" nu.
Lors de l'installation de Debian via la première clé, la règle d'or est de tout désactiver (GNOME, KDE, serveur web, environnement de bureau standard). La seule case qui doit rester cochée est "Utilitaires standards du système".
Pourquoi ? Parce que les environnements de bureaux classiques installent des centaines de "daemons" (services tournant en arrière-plan) pour gérer le réseau, le bluetooth, les imprimantes, ou la télémétrie. GrimOS est conçu pour faire tout cela lui-même, à sa manière, sans aucun bruit de fond.
Une fois installé, l'ordinateur démarre sur un écran noir effrayant avec un texte blanc : le fameux TTY. Le socle est prêt.
install_grimos.sh)C'est ici qu'intervient la deuxième clé USB. L'utilisateur insère la clé contenant GrimOS et exécute simplement le script install_grimos.sh. Que se passe-t-il sous le capot ?
Le script se connecte à internet et télécharge le minimum vital pour afficher des fenêtres :
xserver-xorg et xinit : Les fondations de l'affichage graphique sur Linux.python3-tk : Le module Python permettant de dessiner l'interface.iw et wpa_supplicant : Les outils stricts pour le Wi-Fi.Un système moderne se doit de démarrer directement sur le bureau. Le script modifie la configuration du gestionnaire de terminaux (getty) de Debian pour que l'utilisateur principal soit connecté automatiquement (Auto-login) sur le premier terminal (tty1) dès l'allumage de la machine, sans demander de mot de passe.
.profile)Une fois l'utilisateur connecté automatiquement en arrière-plan, le système lit son fichier de profil caché (.profile). Le script y injecte cette condition :
💻 Terminal :
if [ -z "$DISPLAY" ] && [ "$(tty)" = "/dev/tty1" ]; then
startx
fi
Traduction : "Si aucune interface graphique n'est affichée ($DISPLAY est vide), et que je suis sur l'écran principal (tty1), alors lance immédiatement l'interface graphique (startx)."
En combinant un socle extrêmement stable et un script de configuration totalement transparent, le déploiement de GrimOS prouve que l'installation d'un système d'exploitation n'a pas besoin d'être une "boîte noire" obscure, mais peut être une opération logique, compréhensible et parfaitement maîtrisée.
Bienvenue dans le guide d'installation de GrimOS. Ce document est conçu pour vous accompagner pas-à-pas dans l'installation de votre système d'exploitation, même si vous n'êtes pas un expert en informatique.
L'installation se déroule en trois grandes étapes :
GrimOS repose sur un socle très solide appelé Debian. Nous allons d'abord installer une version "vide" de Debian, que notre script transformera ensuite en GrimOS.
F12, F8, ou Suppr au démarrage pour choisir le périphérique de démarrage).debian).sudo pour notre utilisateur principal, ce qui est plus simple).grimos (tout en minuscules). Choisissez un mot de passe dont vous vous souviendrez.login). C'est normal ! Éteignez le PC pour le moment ou laissez-le tel quel.Maintenant que le socle est prêt, nous allons préparer la clé USB qui contient tout l'univers visuel et les applications de GrimOS.
grimos_build (le dossier où se trouve ce guide).install_grimos.sh et le fichier main.py se trouvent bien à la racine de cette clé USB, et non cachés dans un sous-dossier.C'est la dernière ligne droite ! Le script va tout faire à votre place.
debian login:, tapez grimos et appuyez sur Entrée.💻 Terminal :
lsblk
sdb1, sdc1, et reconnaissable par sa taille). Notez ce nom. Nous utiliserons sdb1 pour l'exemple.💻 Terminal :
sudo mkdir -p /mnt/usb
grimos) s'il vous est demandé.💻 Terminal :
sudo mount /dev/sdb1 /mnt/usb
(Remplacez sdb1 par le nom trouvé à l'étape précédente si différent).
💻 Terminal :
cd /mnt/usb
💻 Terminal :
sudo bash install_grimos.sh
Le script va télécharger toutes les interfaces graphiques, configurer le démarrage automatique et installer vos applications. Cela peut prendre quelques minutes selon votre connexion internet.
Une fois que le script affiche que tout est terminé avec succès :
💻 Terminal :
cd /
sudo umount /mnt/usb
💻 Terminal :
sudo reboot
🎉 Félicitations ! Au redémarrage, la machine s'allumera toute seule, sans demander de mot de passe, et affichera directement le bureau magnifique de GrimOS !
L'un des plus grands défis de GrimOS a été de remplacer les "démons" Linux complexes (comme NetworkManager pour le réseau ou Udisks2 pour les clés USB) par du pur code Python, lisible et modifiable par l'utilisateur.
Un système d'exploitation moderne (Linux, Windows ou macOS) est peuplé de "démons" (Daemons en anglais, ou Services). Ce sont de petits programmes invisibles qui tournent en boucle en arrière-plan dès l'allumage de la machine pour gérer diverses tâches : détecter une clé USB, maintenir la connexion réseau, vérifier les mises à jour, etc.
Le problème ? L'accumulation de ces dizaines de démons consomme énormément de mémoire vive (RAM) et de temps de calcul, même lorsque vous ne faites rien.
Dans ce chapitre, nous allons voir comment GrimOS parvient à s'en passer totalement pour la gestion du Réseau (Wi-Fi) et des clés USB, en utilisant une approche "à la main", 100% Python.
Sur un Linux grand public (comme Ubuntu), le réseau est géré par NetworkManager, un très gros démon qui fournit une interface complexe.
GrimOS a supprimé NetworkManager. À la place, il utilise l'outil fondamental et historique de Linux : wpa_supplicant. C'est le programme le plus léger possible capable de parler aux antennes Wi-Fi.
Le fichier core/wifi.py joue le rôle de traducteur entre l'interface de GrimOS et cet outil.
Quand vous cliquez sur l'icône Wi-Fi dans la barre des tâches :
sudo wpa_cli scanLe gain : Aucun processus lourd ne surveille le réseau en permanence. Le scan n'a lieu que lorsque l'utilisateur le demande explicitement.
Insérer une clé USB sur un ordinateur moderne provoque une série d'actions complexes gérées par des démons comme Udisks2 ou gvfs, qui montent la clé, envoient des notifications au bureau, indexent les fichiers pour la recherche, etc.
Dans GrimOS, la philosophie est brutale mais d'une efficacité redoutable. Le bureau (core/desktop.py) possède une petite boucle très légère qui s'exécute silencieusement toutes les quelques secondes pour vérifier l'état de la batterie et... les disques durs.
lsblk -J (List Block Devices).RM (Removable / Amovible) qui n'a pas de mountpoint (point de montage), cela signifie qu'une clé vient d'être insérée !sudo mount /dev/sdX /media/usb... pour monter la clé de manière transparente.Lorsque l'utilisateur a terminé, il clique sur cette icône. Python exécute simplement sudo umount et la clé peut être retirée en toute sécurité.
En déléguant ces opérations critiques non pas à d'énormes services en arrière-plan, mais à de minuscules commandes textuelles Unix (comme mount, lsblk, wpa_cli) orchestrées par quelques dizaines de lignes de code Python, GrimOS accomplit un miracle de légèreté.
C'est ainsi que la version finale de GrimOS, avec son interface graphique, son explorateur, sa détection USB et son réseau Wi-Fi actifs, réussit à consommer moins de 100 Mégaoctets de RAM au repos, là où d'autres systèmes saturent des ordinateurs équipés de 4 Gigaoctets.
GrimOS ne cache rien à son utilisateur : l'OS est un chef d'orchestre, et le terminal Unix est son instrument.
L'un des défis majeurs lorsqu'on développe une interface graphique en Python brut (avec la bibliothèque standard Tkinter), c'est l'esthétique. Par défaut, Tkinter propose un rendu qui rappelle fortement les interfaces des années 90, et de nombreux développeurs l'abandonnent rapidement, le jugeant trop "moche" ou archaïque.
Pourtant, GrimOS réussit un tour de force : il est capable de simuler l'élégance de macOS Classic, les couleurs vibrantes d'un Ubuntu ou l'austérité rassurante d'un Windows 98.
Ce miracle repose sur le moteur de thèmes, une architecture technique ingénieuse qui sépare la logique des applications de leur apparence.
Dans une application GrimOS, vous ne verrez presque jamais un développeur écrire tk.Button(bg="red", fg="white"). S'il faisait cela, l'application ne s'adapterait pas lorsque l'utilisateur changerait de thème depuis les paramètres.
Au lieu de cela, l'application se contente de déclarer ses composants (Boutons, Textes) de manière neutre. C'est le moteur de thèmes qui, tel un peintre en bâtiment, passe derrière pour colorer chaque élément.
core/theme.py)Si vous ouvrez le fichier core/theme.py, vous découvrirez le secret de GrimOS : la commande magique option_add.
def apply_theme(root, theme_name):
theme = THEMES.get(theme_name, THEMES["GrimOS"])
# Configuration globale pour tous les futurs widgets
root.option_add("*background", theme["bg"])
root.option_add("*foreground", theme["fg"])
root.option_add("*font", theme["font"])
# Styles spécifiques
root.option_add("*Button.background", theme["btn_bg"])
root.option_add("*Button.relief", theme["relief"])
Cette fonction intercepte le cœur même de Tkinter (l'objet root). Grâce à l'étoile *, elle applique une règle absolue : "Désormais, tout objet créé dans le système aura ces couleurs et cette police par défaut".
Ainsi, l'explorateur de fichiers, la calculatrice ou l'éditeur de texte se retrouvent instantanément rhabillés sans même s'en rendre compte.
Qu'est-ce qu'un thème dans GrimOS ? Ce n'est pas un fichier CSS complexe. C'est simplement un petit bloc de dictionnaire (une liste de variables).
Si l'on prend l'exemple du célèbre thème Win 98, voici sa définition exacte dans le code :
"Win 98": {
"bg": "#C0C0C0", # Le fameux gris de Windows 98
"fg": "black", # Texte noir
"font": ("MS Sans Serif", 9), # La police d'époque
"btn_bg": "#C0C0C0",
"relief": "raised", # L'effet 3D "bouton surélevé"
"desktop_bg": "#008080", # Le fond d'écran bleu/vert caractéristique
"desktop_fg": "white",
"accent": "#000080",
"title_bg": "#000080", # La barre de titre bleu foncé
"title_fg": "white",
...
}
Ce simple changement de 10 variables suffit à métamorphoser intégralement le système !
Le système est tellement ouvert que vous pouvez créer votre propre thème en 30 secondes.
core/theme.py avec l'Éditeur de Code.THEMES, par exemple : "Cyberpunk": {
"bg": "black",
"fg": "#00FF00",
"font": ("Courier New", 11, "bold"),
"btn_bg": "#222222",
"relief": "flat",
"desktop_bg": "black",
"desktop_fg": "#00FF00",
"accent": "#FF00FF",
"title_bg": "#FF00FF",
"title_fg": "black",
"taskbar_bg": "black",
"taskbar_fg": "#00FF00",
"start_btn_bg": "#FF00FF",
"start_btn_fg": "black",
"panel_btn_bg": "#222222",
"window_border": "#FF00FF",
"icon_theme": "grimos"
}
La quasi-totalité des systèmes d'exploitation modernes, et plus particulièrement ceux basés sur Unix ou Linux, ont été conçus dès leur origine pour répondre aux besoins des entreprises et des universités. L'architecture de base suppose qu'un même ordinateur sera partagé par des dizaines d'utilisateurs simultanés, souvent connectés à distance, qu'il faut cloisonner pour éviter qu'ils n'espionnent ou ne détruisent le travail de leurs voisins.
C'est cette architecture qui explique pourquoi, sur un système Linux classique, on vous demande sans cesse votre mot de passe administrateur pour monter une simple clé USB, changer l'heure du système ou vous connecter à un réseau Wi-Fi.
Mais à la maison, sur un vieil ordinateur portable personnel, cette approche est-elle vraiment justifiée ? GrimOS a fait le choix radical de répondre par la négative.
GrimOS assume pleinement son statut de système "Mono-Utilisateur". Il part du principe que l'humain assis physiquement devant le clavier est le seul et unique maître légitime de la machine.
Puisque l'utilisateur est le seul maître, il n'y a aucune raison de le soupçonner ou de l'enfermer dans une prison logicielle. GrimOS lève toutes les barrières ergonomiques liées à la sécurité multi-utilisateurs pour offrir une expérience fluide et sans friction.
Sur Linux, la commande sudo ("Super User DO") permet à un utilisateur normal d'exécuter temporairement une tâche avec des privilèges d'administrateur, moyennant la saisie de son mot de passe.
Dans GrimOS, l'interface graphique a besoin d'utiliser sudo en permanence en arrière-plan : pour détecter le niveau de la batterie dans les fichiers matériels (/sys/class), pour monter un disque dur (mount), ou pour analyser les ondes radio environnantes (wpa_cli scan).
Pour éviter d'inonder l'utilisateur de fenêtres de mot de passe, GrimOS utilise une méthode que les administrateurs système "puristes" qualifieraient d'hérésie : le mot de passe est enregistré en clair dans le fichier de configuration de l'utilisateur (config/settings.json).
{
"theme": "GrimOS",
"sudo_pwd": "mon_mot_de_passe_secret"
}
Grâce à cela, lorsqu'une application Python a besoin d'agir sur le système, elle injecte simplement ce mot de passe de manière silencieuse (via subprocess avec un input). L'action est instantanée et totalement transparente pour l'utilisateur.
Cette approche débloque une ergonomie extraordinaire pour un système basé sur Linux :
PolicyKit.Une telle architecture vient évidemment avec un avertissement de sécurité fondamental.
Si un pirate parvient à exécuter un code malveillant sur votre machine, ou si quelqu'un vole votre ordinateur, il lui suffit de lire le fichier settings.json pour obtenir votre mot de passe et prendre le contrôle total du système.
GrimOS n'est donc pas conçu pour être utilisé comme un serveur exposé sur internet, ni dans un bureau ouvert où n'importe qui peut s'asseoir à votre clavier. C'est un système profondément intime et personnel, un laboratoire privé.
Cependant, rien n'empêche un utilisateur averti d'améliorer cette sécurité. Dans l'esprit du "Faites-le vous-même" de GrimOS, un développeur pourrait tout à fait modifier le système pour remplacer ce stockage en clair par l'utilisation d'un Keyring (trousseau de clés chiffré), prouvant une fois de plus que dans GrimOS, le seul maître à bord, c'est vous.
Au fil de ces chapitres, nous avons exploré les entrailles de GrimOS pour comprendre comment il remplace les lourds mécanismes de l'informatique moderne par des concepts simples, lisibles et hautement optimisés.
Mais voir GrimOS uniquement comme un "ordinateur de bureau" pour surfer sur le web et écrire du texte serait une erreur. Sa légèreté inouïe en fait une arme redoutable pour d'autres domaines de l'informatique.
Avez-vous déjà vu un panneau publicitaire numérique planter et afficher un menu Démarrer de Windows, ou un distributeur de billets bloqué sur une mise à jour système ? Ces erreurs surviennent parce que l'on utilise des systèmes d'exploitation généralistes et très lourds pour des tâches qui nécessitent d'afficher une seule application en plein écran.
L'architecture de GrimOS est parfaite pour le "Mode Kiosque" (Single-purpose machine).
Puisque l'affichage graphique n'est qu'un simple script Python (main.py), un développeur peut, en quelques minutes :
core/desktop.py.Le résultat ? Vous obtenez un système d'exploitation impénétrable, ultra-stable, qui démarre en quelques secondes sur une machine d'une puissance dérisoire, idéal pour créer une borne d'arcade de rétro-gaming, un tableau de bord domotique mural, ou un écran d'affichage dynamique.
Le Raspberry Pi est le nano-ordinateur le plus célèbre au monde, prisé par les inventeurs pour ses "broches GPIO", ces petites tiges métalliques qui permettent à l'ordinateur de communiquer avec le monde réel (allumer des LED, lire des capteurs de température, contrôler des moteurs).
Généralement, pour contrôler ces broches, les utilisateurs écrivent des scripts... en Python ! Puisque GrimOS est intégralement écrit en Python, la frontière entre le matériel et l'interface graphique disparaît totalement.
Vous pourriez créer une application GrimOS avec un magnifique bouton vert dessiné par Tkinter, qui, lorsqu'il est cliqué, allume instantanément la lumière de votre salon, sans avoir besoin d'aucun serveur intermédiaire ni d'aucune API complexe. GrimOS est le système d'exploitation rêvé pour les hackers du quotidien et les passionnés d'électronique.
Ce livre touche à sa fin. En parcourant ces chapitres, vous n'avez pas seulement appris comment installer, utiliser ou développer sur GrimOS.
Vous avez découvert une philosophie technique à contre-courant de l'industrie : une approche où la complexité artificielle est remplacée par la lisibilité, où la puissance brute s'efface devant l'optimisation intelligente, et où l'utilisateur n'est plus un simple consommateur pris en otage, mais redevient le maître absolu et l'artisan de sa machine.
Que vous utilisiez GrimOS pour ressusciter un vieil ordinateur portable oublié, pour construire un tableau de bord domotique ou simplement comme un formidable laboratoire pour apprendre à programmer, une chose est sûre : l'informatique est de nouveau entre vos mains.
Bienvenue dans GrimOS.