diff --git a/.portfolio/diagrams/diagram.svg b/.portfolio/diagrams/diagram.svg
new file mode 100644
index 0000000..4473fa4
--- /dev/null
+++ b/.portfolio/diagrams/diagram.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/.portfolio/portfolio.md b/.portfolio/portfolio.md
new file mode 100644
index 0000000..b8034ec
--- /dev/null
+++ b/.portfolio/portfolio.md
@@ -0,0 +1,419 @@
+---
+title: "ReadRSS"
+description: "Application de bureau (Rust) pour lire les flux RSS. Interface graphique rapide et minimale."
+date: "2025-10-29"
+tags: ["rust","gui","rss","desktop","egui"]
+lang: "fr"
+
+# Configuration techStack
+techStack:
+ - name: "Rust"
+ category: "language"
+ icon: "🦀"
+ - name: "egui / eframe"
+ category: "framework"
+ icon: "🖼️"
+ - name: "tokio"
+ category: "tool"
+ icon: "⚡"
+ - name: "feed-rs"
+ category: "tool"
+ icon: "📡"
+ - name: "ureq"
+ category: "tool"
+ icon: "🌐"
+ - name: "serde"
+ category: "tool"
+ icon: "💾"
+ - name: "Shell"
+ category: "language"
+ icon: "($(curl -s https://emojicdn.elk.sh/:-shell-?style=twitter | jq -r .em | head -n 1))"
+
+# Architecture du projet
+architecture:
+ overview: "L'application suit une architecture 'headless' claire, séparant la logique métier de l'interface. Le crate `rss-core` gère toute la logique : le fetching HTTP asynchrone (via tokio et ureq), le parsing des flux (feed-rs), et la gestion de la base de données (fichiers JSON via serde). Le crate `rss-gui` est un consommateur de cette logique, se concentrant uniquement sur le rendu de l'interface graphique avec `egui` et la gestion des états de la vue."
+ components:
+ - "rss-core (Bibliothèque Rust) : Crate 'backend' indépendant (lib.rs). Il gère la structure des données (Feed, Article), la persistence (lecture/écriture JSON via serde), et expose les fonctions publiques (ex: add_feed, fetch_articles)."
+ - "rss-gui (Exécutable Rust) : Crate 'frontend' qui utilise eframe pour créer la fenêtre de bureau. Il implémente le trait eframe::App pour gérer le cycle de vie de l'application et le rendu."
+ - "tokio (Runtime Asynchrone) : Composant essentiel dans `rss-core`. Permet au `fetcher` de télécharger les flux RSS de manière non-bloquante, évitant de geler l'application."
+ - "feed-rs (Parseur de flux) : La bibliothèque qui transforme le texte XML brut (récupéré par ureq) en structures Rust (feed_rs::model::Feed) faciles à manipuler."
+ - "Gestionnaire d'état (GuiState) : La structure principale dans `rss-gui` qui contient l'état de l'interface (flux sélectionné, article sélectionné, onglet actif) et les données (rss_core::Rss)."
+
+# Diagrammes d'architecture (optionnel)
+diagrams:
+ - path: "https://raw.githubusercontent.com/xAMA0x/ReadRSS/main/.portfolio/diagrams/readrss-architecture.svg"
+ title: "Architecture Core / GUI"
+ description: "Vue d'ensemble de la séparation des crates (logique et interface)"
+
+# URLs et liens
+demo_url: ""
+demo_label: ""
+github_url: "https://github.com/xAMA0x/ReadRSS"
+---
+
+## 🎯 Vue d'ensemble
+
+
+
+ ReadRSS est un lecteur de flux RSS natif et minimaliste pour le bureau. Développé en Rust avec egui, il se concentre sur la rapidité et la simplicité, sans fioritures inutiles. Il gère l'ajout, le rafraîchissement et la lecture de vos flux en local, avec une interface réactive qui démarre instantanément.
+
+
+
+
+
~ 3.5 Mo
+
Poids du paquet .deb
+
+
+
100%
+
Rust Natif (Core & GUI)
+
+
+
< 1s
+
Démarrage instantané
+
+
+
4
+
Collaborateurs
+
+
+
+
+### Objectifs du projet
+
+
+
+
+ 🎓
+
+
+ Valider le Projet de 4e Année
+
+
+ Répondre au sujet imposé de la matière "Rust" à l'ESGI. L'objectif premier était de livrer un projet fonctionnel pour l'examen.
+
+
+
+
+ 🦀
+
+
+ Maîtriser les Concepts de Rust
+
+
+ Mettre en pratique l'ownership, le borrowing, la gestion des crates (core/gui), et la gestion d'erreurs (`Result`).
+
+
+
+
+ 🖼️
+
+
+ Implémenter une GUI en Rust
+
+
+ Découvrir et utiliser un framework de GUI Rust (comme `egui`) pour créer une application de bureau multiplateforme réactive.
+
+
+
+
+ ⚡
+
+
+ Gérer l'Asynchrone
+
+
+ Implémenter des opérations réseau (fetching RSS) non-bloquantes en utilisant un runtime asynchrone (`tokio`) pour ne pas geler l'interface.
+
+
+
+
+ 🤝
+
+
+ Collaborer sur un Projet (4 étudiants)
+
+
+ Travailler en équipe sur un dépôt Git partagé, gérer la séparation des modules (`rss-core`, `rss-gui`) et les dépendances `Cargo.toml`.
+
+
+
+
+## 🏛️ Architecture `Core` / `GUI`
+
+
+
+ Le projet est construit sur une architecture "headless" propre à Rust, séparant la logique métier (Core) de la présentation (GUI). Le crate rss-core est une bibliothèque (lib.rs) qui ne sait rien de l'interface, tandis que rss-gui est un binaire (main.rs) qui importe rss-core comme une simple dépendance.
+
+
+
rss-core (Bibliothèque / Backend) : Crate indépendant gérant la logique pure. Il contient les structures de données (Feed, Article), la persistence (store.rs) et le fetcher asynchrone (fetcher.rs).
+
rss-gui (Binaire / Frontend) : Crate qui importe rss-core. Il utilise eframe et egui pour dessiner l'interface. Il gère l'état de la vue (GuiState) et appelle les fonctions de rss-core.
+
Espace de travail Cargo (Cargo.workspace) : Le projet est défini comme un "workspace" Cargo, permettant aux deux crates de partager un dossier target (compilation) et un Cargo.lock (dépendances).
+
Communication : La GUI (rss-gui) détient une instance mutable de la structure principale de rss-core et l'appelle directement, mettant à jour son propre état local en réponse.
+
+
+
+## ⚡ Moteur Asynchrone (Tokio & Fetching)
+
+
+
+ Pour éviter de figer l'interface utilisateur (GUI) lors des requêtes réseau, rss-core utilise tokio, le principal runtime asynchrone de Rust. Le fetcher (récupérateur de flux) est conçu pour s'exécuter dans un thread séparé et communiquer avec la GUI de manière non-bloquante.
+
+
+
Runtime tokio : Le cratetokio est utilisé pour créer un runtime multi-threadé (tokio::runtime::Runtime) qui gère l'exécution des tâches asynchrones (les async fn).
+
Client HTTP ureq : Le client HTTP ureq est utilisé pour effectuer les requêtes GET. Il est exécuté dans un thread bloquant (tokio::task::spawn_blocking) pour s'intégrer à l'écosystème async.
+
spawn_blocking : C'est la fonction clé qui permet au code synchrone (comme ureq::get()) de s'exécuter sans bloquer le runtimetokio principal, assurant que l'UI reste réactive.
+
Gestion des erreurs réseau : Le fetcher gère les erreurs potentielles (Timeouts, DNS, 404/500) en encapsulant les retours dans un Result, permettant à la GUI d'afficher un message d'erreur propre.
+
+
+
+## 🖼️ Interface Graphique (egui)
+
+
+
+ L'interface est entièrement construite avec egui, un framework de GUI en Rust qui utilise une approche en mode immédiat (immediate mode). Cela signifie que l'interface est redessinée à chaque frame, ce qui simplifie la gestion de l'état et permet un développement très rapide sans callbacks complexes.
+
+
+
Framework eframe : C'est le crate qui lance la fenêtre de bureau et exécute la boucle d'application egui.
+
Trait eframe::App : La structure principale de rss-gui implémente ce trait, qui ne requiert qu'une seule méthode : update(). Cette méthode est appelée à chaque frame pour dessiner l'intégralité de l'interface.
+
Panneaux egui : L'interface est structurée à l'aide de panneaux (egui::SidePanel, egui::CentralPanel) pour diviser l'écran (flux à gauche, articles au centre).
+
Gestion d'état simplifiée : L'état est détenu dans la structure GuiState. Les interactions (clics, etc.) modifient directement cet état, et l'interface se redessine automatiquement à la frame suivante.
+ Pour la persistance des données, le projet évite une base de données complexe et opte pour des fichiers JSON. C'est le crateserde (SERialisation/DEserialisation) qui gère la conversion des structures Rust (comme Feed) en texte JSON et vice-versa.
+
+
+
Macros serde : Utilisation des macros #[derive(Serialize, Deserialize)] sur toutes les structures de données (Feed, Article, Config).
+
Stockage en fichiers plats : L'état de l'application (liste des flux, articles lus, configuration) est sauvegardé dans des fichiers JSON simples (ex: feeds.json, config.json).
+
Module store.rs : Toute la logique de lecture (store::load()) et d'écriture (store::save()) est centralisée dans ce module de rss-core, qui utilise les fonctions de serde_json.
+
Robustesse (Gestion d'erreurs) : Le chargement et la sauvegarde des fichiers sont encapsulés dans un Result, permettant de gérer proprement les erreurs I/O (fichier non trouvé, etc.).
+
+
+
+## 🎓 Compétences démontrées
+
+
+
+
+
+ 🦀
+
Programmation Système (Rust)
+
+
+
+ ✓
+
+
Gestion de la mémoire (Ownership)
+
Utilisation de l'ownership et du borrowing (pas de GC).
+
+
+
+ ✓
+
+
Gestion robuste des erreurs
+
Utilisation de `Result` et `Option` (pas d'exceptions).
+
+
+
+ ✓
+
+
Modélisation de données & Serde
+
Définition de `struct` et `#[derive(Serialize, Deserialize)]`.
+
+
+
+ ✓
+
+
Utilisation des Traits (Polymorphisme)
+
Implémentation de `eframe::App` et `Default`.
+
+
+
+
+
+
+
+ 🖼️
+
Développement GUI Natif
+
+
+
+ ✓
+
+
Framework `egui` (Mode immédiat)
+
UI redessinée à chaque frame, simplifiant l'état.
+
+
+
+ ✓
+
+
Gestion de l'état (GUI)
+
État centralisé dans `GuiState` et modifié par les widgets.
+
+
+
+ ✓
+
+
Composition de l'interface (Layout)
+
Utilisation de `SidePanel`, `CentralPanel`, `ScrollArea`.
+
+
+
+ ✓
+
+
Rendu multiplateforme
+
Utilisation de `eframe` pour compiler sur Linux et Windows.
+
+
+
+
+
+
+
+ ⚡
+
Concurrence & Réseau
+
+
+
+ ✓
+
+
Programmation asynchrone
+
Utilisation de `async/await` et du runtime `tokio`.
+
+
+
+ ✓
+
+
Gestion de threads (`spawn_blocking`)
+
Pont entre code synchrone (`ureq`) et asynchrone (`tokio`).
+
+
+
+ ✓
+
+
Client HTTP
+
Requêtes réseau GET avec `ureq` pour récupérer les flux.
+
+
+
+ ✓
+
+
Parsing de flux (RSS/Atom)
+
Utilisation de la bibliothèque `feed-rs` pour parser le XML.
+
+
+
+
+
+
+
+ 📦
+
Gestion de Projet (Cargo)
+
+
+
+ ✓
+
+
Cargo Workspaces
+
Séparation `rss-core` (logique) et `rss-gui` (interface).
+
+
+
+ ✓
+
+
Gestion des dépendances
+
Gestion des `Cargo.toml` pour les deux crates.
+
+
+
+ ✓
+
+
Scripts de "build" (Shell)
+
Automatisation de la compilation (`build_release.sh`).
+
+
+
+ ✓
+
+
Distribution (GitHub Releases)
+
Création de binaires `.deb` (Debian) et `.zip` (Windows).
+
+
+
+
+
+
+
+## 📚 Ressources & Documentation
+
+
+
+
+
+ 📖
+
Documentation complète
+
+
+
+ ▸
+ Analyse du code source Rust (Core)
+
+
+ ▸
+ Implémentation de la GUI (egui)
+
+
+ ▸
+ Gestion de l'état asynchrone (Tokio)
+
+
+ ▸
+ Instructions de compilation
+
+
+
+ → Voir les détails techniques
+
+
+
+
+
+ 🗺️
+
Diagramme interactif
+
+
Visualisation complète de l'architecture avec tooltips détaillés pour chaque composant.