# GrimOS : Construire son propre Système d'Exploitation en Python

# Chapitre 1 : Genèse et Philosophie de GrimOS

## Introduction

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.

## 1. Redonner vie aux ordinateurs oubliés

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.

## 2. La Philosophie du Projet : Transparence et Minimalisme

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.

## 3. GrimOS face aux systèmes modernes

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).

### L'inflation logicielle (Bloatware)

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.

### L'illusion du contrôle

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.

### Télémétrie et vie privée

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.

# Chapitre 2 : Panorama des fonctionnalités de GrimOS

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.

## 1. L'Environnement de Bureau (Le Desktop)

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).

- Le Bureau et ses Raccourcis : L'écran principal permet d'accueillir des raccourcis vers vos applications ou dossiers préférés. Ces raccourcis sont cliquables, déplaçables et persistants.
- La Barre des Tâches Multifonction : Située en bas de l'écran, elle centralise le contrôle du système. Outre le menu "Démarrer" et les fenêtres ouvertes, elle intègre un Moniteur Système Graphique avancé. Ce dernier affiche en temps réel des graphiques pour l'utilisation du processeur (CPU), de la mémoire vive (RAM), de la mémoire virtuelle (SWAP), la température, ainsi qu'une icône dynamique pour l'état de la batterie.
- Contrôles Rapides : D'un simple clic depuis la barre des tâches, l'utilisateur peut modifier le volume sonore, gérer ses réseaux Wi-Fi, ou basculer la disposition de son clavier.

> Aperçu du bureau principal avec son moniteur système interactif.

## 2. Les Applications Intégrées

GrimOS fournit un écosystème d'applications de base, chacune pensée pour consommer le moins de mémoire possible.

### L'Explorateur de Fichiers

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 :

- Le montage et démontage de clés USB en un clic.
- La connexion native aux partages réseau (SMB/Samba).
- Des icônes vectorielles nettes et professionnelles (générées dynamiquement à l'installation).

> L'explorateur de fichiers naviguant dans les dossiers systèmes.

### L'Éditeur de Texte et de Code

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.

### Le Navigateur Web

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.

### Les Outils Périphériques

- 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.

## 3. Personnalisation et Modularité

L'un des aspects les plus uniques de GrimOS est sa malléabilité.

- Le Moteur de Thèmes : Via l'application Paramètres, l'utilisateur peut changer instantanément l'apparence de tout le système. Envie d'un style "Windows 95", "Windows XP", d'une interface très sombre "Hacker" ou de l'élégance par défaut de "GrimOS" ? Un clic suffit à modifier l'intégralité des couleurs et des bordures, sans aucun redémarrage.
- La Persistance de Session : GrimOS mémorise intelligemment votre espace de travail. Si vous éteignez la machine avec l'éditeur ouvert sur un coin de l'écran, il s'ouvrira exactement au même endroit et à la même taille lors du prochain démarrage.

> 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.

# Chapitre 3 : Architecture du système

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.

## 1. Vue d'ensemble de l'architecture

La Fondation de GrimOS est structurée en trois couches principales, emboîtées comme des poupées russes :

1. La Couche d'Exécution (Le Noyau)
2. `main.py` : Point d'entrée de l'application. Initialise la fenêtre Tkinter plein écran.
3. `core/desktop.py` : Construit l'environnement visuel (fond d'écran, barre des tâches, horloge).
4. La Couche de Gestion (Le Chef d'Orchestre)
5. `core/app_manager.py` : Le moteur qui lance et ferme les applications.
6. `core/window.py` : Génère le "simulacre" de fenêtre (cadre, barre de titre, boutons).
7. La Couche Applicative (Les Logiciels)
8. `apps/` : Dossier contenant toutes les applications indépendantes (`editeur`, `terminal`, etc.).
9. `config/applications.json` : Le registre déclarant ces applications pour le menu Démarrer.

L'architecture est construite en 3 couches horizontales :

1. La Fondation (Core) : Gère la boucle graphique Tkinter, le fond d'écran, et la barre des tâches.
2. Le Gestionnaire (App Manager & Window) : Isole chaque application dans une fausse "fenêtre" (puisqu'il n'y a pas de gestionnaire de fenêtres X11 classique).
3. Les Applications (Apps) : Des modules Python indépendants qui se branchent sur le système.

## 2. Le Coeur du Système (Dossier `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.

- Rôle : Il dessine l'environnement (le fond d'écran), crée la barre des tâches en bas de l'écran, gère le bouton "Démarrer", et affiche l'heure ainsi que les widgets système (CPU, RAM).
- Fonctionnement : Il charge le fichier `applications.json` pour construire dynamiquement le menu Démarrer.

### `core/window.py` (Le Simulacre de Fenêtre)

C'est le secret technique de GrimOS.

- Rôle : Étant donné que GrimOS s'exécute sur un serveur X11 "nu" (sans environnement de bureau comme GNOME ou XFCE), les fenêtres n'existent pas naturellement.
- Fonctionnement : Ce fichier crée un composant (`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)

- Rôle : C'est lui qui fait le lien entre le Bureau et les Applications.
- Fonctionnement : Quand l'utilisateur clique sur une icône, l'`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.py`

Ces 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.

## 3. Les Applications (Dossier `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`.

### Structure d'une application

Si vous explorez `apps/editeur/` ou `apps/explorateur/`, vous y trouverez toujours la même architecture minimale :

- `app.py` : Le fichier principal.
- (optionnel) Des sous-fichiers Python ou des ressources locales.

### La fonction magique : `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.

## 4. La Configuration (Dossier `config/`)

Pour rester facilement modifiable, GrimOS extrait sa configuration du code source.

### `applications.json`

C'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.

## 5. Le Terminal TTY Natif : Un choix architectural

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.

# Chapitre 4 : Tutoriel : Créer sa première application (Calculatrice)

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.

## 1. Créer le dossier de l'application

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.

## 2. Le code minimal (Le contrat GrimOS)

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 :

1. Nous importons `tkinter` pour dessiner nos boutons et nos champs de texte.
2. Nous utilisons `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.
3. La fonction `eval()` est utilisée ici pour la simplicité de l'exemple afin de calculer mathématiquement le texte tapé par l'utilisateur.

## 3. Déclarer l'application au système

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/`.

## 4. Tester l'application

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é).

1. Ouvrez le menu Démarrer.
2. Allez dans la catégorie Bureautique.
3. Cliquez sur Calculatrice.

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`.

## Conclusion

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 !

# Chapitre 5 : L'installation magique et le déploiement

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.

## La Philosophie : Le Workflow "Deux Clés USB".

Comment transforme-t-on un PC vide en une machine GrimOS fully-fonctionnelle ?

## 1. Le Mythe de l'ISO vs La Méthode des Deux Clés

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.

1. La clé Socle : Elle contient l'installateur officiel de Debian "Minimal" (Netinst).
2. La clé Magique : Elle contient le dossier source de GrimOS et le script `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.

## 2. Étape 1 : Le Socle Debian Minimal

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.

## 3. Étape 2 : Le Script d'Installation (`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 ?

### A. Téléchargement des dépendances

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.

### B. Configuration de l'Autologin

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.

### C. Le lancement automatique de X11 (`.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.

# 🚀 Guide d'Installation Officiel - GrimOS

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 :

1. Étape A : L'installation du "moteur" de base (Debian minimal).
2. Étape B : La préparation de votre clé USB contenant GrimOS.
3. Étape C : Le déploiement automatique de GrimOS sur votre machine.

## 🛠️ Étape A : Installation du système de base (Debian)

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.

### 1. Télécharger Debian

- Rendez-vous sur le site officiel de Debian et téléchargez l'image d'installation par le réseau (netinst) : Télécharger Debian (netinst).

### 2. Créer une clé USB d'installation (Clé n°1)

- Munissez-vous d'une première clé USB (8 Go minimum).
- Utilisez un logiciel comme Rufus (sur Windows) ou BalenaEtcher (sur Mac/Linux) pour "flasher" le fichier ISO Debian téléchargé sur votre clé USB.

### 3. Installer Debian sur le PC cible

- Branchez la clé USB sur le PC que vous souhaitez transformer en machine GrimOS et allumez-le.
- Démarrez sur la clé USB (souvent en tapotant `F12`, `F8`, ou `Suppr` au démarrage pour choisir le périphérique de démarrage).
- Choisissez l'installation normale ou graphique ("Graphical install") et suivez l'assistant :
- Langue, Pays, Clavier : Choisissez le français (ou votre langue).
- Réseau : Connectez-vous à internet (par câble ou Wi-Fi) quand cela vous est demandé.
- Nom d'hôte : Laissez par défaut (ex: `debian`).
- Mot de passe administrateur (root) : Laissez vide et faites "Continuer" (cela activera `sudo` pour notre utilisateur principal, ce qui est plus simple).
- ⚠️ CRUCIAL - Création de l'utilisateur : Lorsqu'on vous demande le nom complet du nouvel utilisateur et l'identifiant, tapez exactement `grimos` (tout en minuscules). Choisissez un mot de passe dont vous vous souviendrez.
- Partitionnement des disques : Choisissez "Assisté - utiliser un disque entier" et sélectionnez votre disque dur.
- ⚠️ CRUCIAL - Sélection des logiciels : À la fin de l'installation, un écran "Sélection des logiciels" apparaît. C'est l'étape la plus importante.
  - Décochez absolument tout (surtout "environnement de bureau Debian", "GNOME", etc.).
  - La seule case qui doit rester cochée est : "Utilitaires standards du système".
- Une fois l'installation terminée, l'ordinateur va redémarrer. Retirez la clé USB.
- L'ordinateur démarrera sur un écran noir avec un texte vous demandant de vous connecter (`login`). C'est normal ! Éteignez le PC pour le moment ou laissez-le tel quel.

## 💾 Étape B : Préparation de la clé USB "GrimOS" (Clé n°2)

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.

1. Sur votre ordinateur personnel, prenez une deuxième clé USB (formatée en FAT32 ou exFAT).
2. Ouvrez le dossier `grimos_build` (le dossier où se trouve ce guide).
3. Copiez l'intégralité du contenu de ce dossier à la racine de votre clé USB.
4. Assurez-vous que le fichier `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.

## 🪄 Étape C : Déploiement de GrimOS

C'est la dernière ligne droite ! Le script va tout faire à votre place.

### 1. Se connecter

- Allumez votre PC (celui avec l'écran noir installé à l'Étape A).
- Au message `debian login:`, tapez `grimos` et appuyez sur Entrée.
- Tapez votre mot de passe (les caractères ne s'affichent pas à l'écran, c'est normal) et appuyez sur Entrée.

### 2. Brancher et trouver la clé USB

- Branchez votre clé USB "GrimOS" (Clé n°2).
- Tapez la commande suivante pour lister les disques :

> 💻 Terminal :

      lsblk

- Vous verrez une liste. Cherchez votre clé USB (souvent nommée `sdb1`, `sdc1`, et reconnaissable par sa taille). Notez ce nom. Nous utiliserons `sdb1` pour l'exemple.

### 3. Monter (connecter) la clé USB

- Tapez la commande suivante pour créer un point d'attache :

> 💻 Terminal :

      sudo mkdir -p /mnt/usb

- Tapez votre mot de passe (celui de l'utilisateur `grimos`) s'il vous est demandé.
- "Branchez" logiciellement la clé USB :

> 💻 Terminal :

      sudo mount /dev/sdb1 /mnt/usb

(Remplacez `sdb1` par le nom trouvé à l'étape précédente si différent).

### 4. Lancer l'installation magique

- Allez dans le dossier de la clé USB :

> 💻 Terminal :

      cd /mnt/usb

- Lancez le script d'installation :

> 💻 Terminal :

      sudo bash install_grimos.sh

### 5. Laissez la magie opérer !

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.

### 6. Redémarrage final

Une fois que le script affiche que tout est terminé avec succès :

- Tapez :

> 💻 Terminal :

      cd /
      sudo umount /mnt/usb

- Débranchez votre clé USB.
- Redémarrez la machine :

> 💻 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 !

# Chapitre 6 : L'Automagie sous le capot (Réseau et USB)

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.

## 1. La gestion du Réseau (Wi-Fi) "à la main"

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 :

1. Python lance une simple ligne de commande invisible : `sudo wpa_cli scan`
2. Python lit la réponse brute en texte du système d'exploitation.
3. Python "parse" (découpe) ce texte pour extraire le nom des réseaux (SSID) et la puissance du signal.
4. L'interface affiche la liste déroulante.

Le gain : Aucun processus lourd ne surveille le réseau en permanence. Le scan n'a lieu que lorsque l'utilisateur le demande explicitement.

## 2. L'Auto-montage USB "Maison"

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.

### Comment ça marche ?

1. À intervalle régulier, Python exécute la commande native Linux : `lsblk -J` (List Block Devices).
2. Cette commande très rapide renvoie la liste complète de tout ce qui est branché à la machine au format JSON.
3. Python analyse le JSON. S'il détecte un disque de type `RM` (Removable / Amovible) qui n'a pas de `mountpoint` (point de montage), cela signifie qu'une clé vient d'être insérée !
4. Automatiquement, le script lance la commande `sudo mount /dev/sdX /media/usb...` pour monter la clé de manière transparente.
5. Une icône "⏏️ USB" apparaît alors dans la barre des tâches.

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é.

## 3. La Frugalité comme philosophie

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.

# Chapitre 7 : L'Art du Trompe-l'œil : Le Moteur de Thèmes

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.

## 1. Séparer le fond de la forme

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.

## 2. L'Injection globale (`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.

## 3. Le dictionnaire magique

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 !

## 4. Créez votre propre thème

Le système est tellement ouvert que vous pouvez créer votre propre thème en 30 secondes.

1. Ouvrez `core/theme.py` avec l'Éditeur de Code.
2. Ajoutez un nouveau bloc dans le dictionnaire `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"
        }

1. Sauvegardez et redémarrez GrimOS.
2. Allez dans l'application Paramètres, et sélectionnez "Cyberpunk" dans le menu déroulant.
3. Cliquez sur "Appliquer".

# Chapitre 8 : Repenser la sécurité : L'approche Mono-Utilisateur

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.

## 1. Un ordinateur, Un humain

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.

## 2. Le secret : L'automatisation du Sudo

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.

## 3. Les avantages ergonomiques

Cette approche débloque une ergonomie extraordinaire pour un système basé sur Linux :

- Montage immédiat : Une clé USB insérée apparaît instantanément dans l'explorateur, montée et prête à l'emploi.
- Connexion transparente : Le changement de réseau Wi-Fi s'effectue en un clic dans la barre des tâches.
- Contrôle matériel : Le réglage du volume sonore, l'extinction immédiate de la machine, ou l'accès aux sondes de température se font en temps réel, sans la lourdeur des outils de gestion de droits complexes comme `PolicyKit`.

## 4. Les compromis assumés (Les risques)

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.

# Chapitre 9 : L'Avenir de GrimOS (Kiosques, Raspberry Pi et Conclusion)

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.

## 1. Au-delà du Bureau : Les Kiosques et Bornes d'arcade

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 :

- Supprimer la barre des tâches de `core/desktop.py`.
- Forcer le lancement de l'application "Visionneuse" ou "Navigateur Web" en plein écran, sans bouton pour la fermer.

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.

## 2. Le mariage parfait avec le Raspberry Pi

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.

## Conclusion générale

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.