FRAMEWORK DESKTOP • OPEN SOURCE • GITHUB / MICROSOFT

Electron — Apps desktop avec les technos web

Electron combine un moteur Chromium (rendu HTML/CSS/JS) et Node.js (accès système) dans un seul runtime. Une application web devient une application de bureau native — Windows, macOS et Linux simultanément.

Créé par GitHub (2013)
Moteur Chromium + V8 + Node.js
Langage HTML / CSS / JavaScript
Taille typique ~150–300 Mo
Windows macOS Linux
01

Définition & fonctionnement

Electron est un framework open source créé par GitHub qui permet de construire des applications de bureau multiplateformes avec des technologies web standard (HTML, CSS, JavaScript). Il combine deux moteurs distincts dans un seul processus :

Chromium gère le rendu de l'interface (le même navigateur que Google Chrome, donc compatibilité CSS3/ES2024 complète), et Node.js fournit l'accès au système d'exploitation (fichiers, réseau, processus). Les deux communiquent via un mécanisme appelé IPC (Inter-Process Communication).

ℹ
Applications connues : VS Code, Slack, Discord, Figma Desktop, Notion, Postman, GitHub Desktop, Twitch Desktop, 1Password 7, Atom — tous sont construits avec Electron.

Différence fondamentale avec HTA

CritèreHTAElectron
Moteur HTMLMSHTML / IEChromium (Chrome)
JavaScriptES5 seulementES2024 complet
CSSIE11 limitéCSS3 complet + CSS Grid
PlateformesWindows uniquementWin + macOS + Linux
Taille du bundle~0 Ko (1 fichier)~150–300 Mo
Installation requiseAucuneOui (installeur)
npm / node_modulesNon requisRequis
02

Historique & évolution

2013 — Atom Shell

GitHub crée un framework interne pour construire l'éditeur de code Atom. Il s'appelle alors "Atom Shell" et combine Node.js et le moteur WebKit (Chromium).

2015 — Nommage "Electron"

Atom Shell est rendu open source et renommé Electron. Microsoft adopte rapidement le framework pour construire VS Code, ce qui propulse sa popularité.

2016–2018 — Adoption massive

Slack, Discord, Figma, Postman, Twitch rejoignent l'écosystème Electron. Le framework devient le standard de facto pour les apps desktop cross-platform écrites par des équipes web.

2018 — Rachat GitHub par Microsoft

GitHub (et donc Electron) rejoint Microsoft. Le développement s'accélère, la sécurité est renforcée avec l'introduction de contextIsolation et les preload scripts.

2020 — Electron 10+ : sécurité renforcée

nodeIntegration désactivé par défaut, contextIsolation activé par défaut, introduction de l'API contextBridge pour exposer des APIs sécurisées au renderer.

2022+ — Electron vs Tauri

L'essor de Tauri (Rust, ~5 Mo) met en question le modèle lourd d'Electron. L'équipe répond avec des améliorations de performance et de partage de processus Chromium entre fenêtres.

03

Architecture biprocessus

Electron fonctionne avec deux types de processus séparés, chacun avec des responsabilités et des accès distincts. C'est le concept le plus important à comprendre.

MAIN PROCESS
main.js / main.ts
Node.js complet
BrowserWindow
app, ipcMain
dialog, shell
Menu, Tray
Accès fichiers, OS
⇄IPC
RENDERER PROCESS
index.html + JS/CSS
Chromium (Chrome)
ES2024 + CSS3
React / Vue / Svelte
ipcRenderer
DOM complet
Node.js : limité*

* Node.js est désactivé dans le Renderer par défaut depuis Electron 10 (bonne pratique sécurité). L'accès système passe par un preload script.

STRUCTURE PROJET
mon-app/
├── package.json
├── main.js          ← Main Process (Node.js)
├── preload.js       ← Pont sécurisé main ↔ renderer
└── renderer/
    ├── index.html
    ├── styles.css
    └── app.js       ← Renderer Process (Chromium)
04

Installation & démarrage

⚠
Prérequis : Node.js (v18+) et npm doivent être installés. Télécharger sur nodejs.org.
TERMINAL
# Créer un nouveau projet
mkdir mon-app && cd mon-app
npm init -y

# Installer Electron
npm install --save-dev electron

# Ou utiliser le template officiel (recommandé)
npm create electron-vite@latest
cd mon-app && npm install

# Lancer en mode développement
npm run dev
MAIN.JS — MINIMAL
const { app, BrowserWindow } = require('electron')
const path = require('path')

function createWindow() {
  const win = new BrowserWindow({
    width: 1200, height: 800,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      contextIsolation: true,   // sécurité : obligatoire
      nodeIntegration: false    // sécurité : désactiver
    }
  })
  win.loadFile('renderer/index.html')
}

app.whenReady().then(createWindow)
05

APIs Node.js disponibles

Dans le Main Process, l'intégralité des modules Node.js est disponible :

fs / fs.promises

Lire, écrire, copier, déplacer, supprimer des fichiers. API synchrone ou async/await.

path

Manipulation des chemins de fichiers de façon cross-platform (séparateurs Windows/Unix).

child_process

Lancer des processus externes (ffmpeg, git, python…), capturer stdout/stderr en temps réel.

net / http / https

Serveur HTTP, requêtes, WebSockets, gestion réseau bas niveau.

os

Informations système : plateforme, mémoire disponible, cœurs CPU, dossier home.

crypto

Chiffrement, hachage (SHA256, MD5…), génération d'UUID, HMAC.

sqlite3 / better-sqlite3

Base de données locale SQLite — persistance structurée sans serveur. (via npm)

Tous les packages npm

L'intégralité de l'écosystème npm (400 000+ packages) est accessible dans le Main Process.

06

APIs Electron natives

BrowserWindow

Créer et gérer des fenêtres. Contrôle de la taille, position, décoration, opacité, frameless…

dialog

Boîtes de dialogue natives : ouverture de fichier, dossier, sauvegarde, messages d'erreur/confirmation.

shell

Ouvrir des fichiers dans l'application par défaut, ouvrir des URLs dans le navigateur, afficher dans l'explorateur.

Menu / MenuItem

Menus natifs de la barre d'application (macOS) et menus contextuels clic-droit.

Tray

Icône dans la zone de notification système (systray Windows, barre de menu macOS).

Notification

Notifications système natives (centre de notifications Windows/macOS).

clipboard

Lire et écrire dans le presse-papiers (texte, HTML, images, formats personnalisés).

globalShortcut

Raccourcis clavier globaux qui fonctionnent même quand la fenêtre n'a pas le focus.

powerMonitor

Détecter la mise en veille, le réveil, l'état de la batterie, le changement de source d'alimentation.

screen

Informations sur les écrans connectés, résolutions, densité de pixels, multi-moniteur.

autoUpdater

Mise à jour automatique de l'application via Squirrel (Windows/macOS).

nativeImage

Manipulation d'images natives pour icônes, miniatures, captures d'écran.

07

Communication IPC

Le renderer ne peut pas accéder directement au système. Il passe par un preload script qui expose des fonctions sécurisées via contextBridge.

PRELOAD.JS — PONT SÉCURISÉ
const { contextBridge, ipcRenderer } = require('electron')

contextBridge.exposeInMainWorld('api', {
  // Renderer → Main
  ouvrirFichier: () => ipcRenderer.invoke('dialog:open'),
  lireFichier:   (p) => ipcRenderer.invoke('fs:read', p),

  // Main → Renderer (événements)
  onProgress: (cb) => ipcRenderer.on('progress', (_, v) => cb(v))
})
MAIN.JS — GESTIONNAIRE IPC
const { ipcMain, dialog } = require('electron')
const fs = require('fs')

ipcMain.handle('dialog:open', async () => {
  const { filePaths } = await dialog.showOpenDialog({ properties: ['openFile'] })
  return filePaths[0]
})

ipcMain.handle('fs:read', async (_, path) => {
  return fs.promises.readFile(path, 'utf8')
})
RENDERER — UTILISATION
// window.api est exposé par le preload — pas d'accès Node.js direct
const btn = document.getElementById('open')
btn.addEventListener('click', async () => {
  const filePath = await window.api.ouvrirFichier()
  const content  = await window.api.lireFichier(filePath)
  document.getElementById('content').textContent = content
})
08

Sécurité & bonnes pratiques

OptionValeur recommandéeRaison
contextIsolationtrue (défaut)Sépare le contexte JS du renderer et du preload.
nodeIntegrationfalse (défaut)Empêche le renderer d'accéder à Node.js directement.
webSecuritytrue (défaut)Maintient la politique Same-Origin dans le renderer.
allowRunningInsecureContentfalseBloque les ressources HTTP dans une app HTTPS.
preloadChemin absoluSeul moyen sécurisé d'exposer des APIs Node.js au renderer.
⛔
Jamais : nodeIntegration: true + contextIsolation: false dans une app qui charge du contenu distant. Une XSS dans le renderer deviendrait une exécution de code arbitraire avec accès Node.js complet sur l'OS.
09

Compatibilité par plateforme

Windows 10/11
✔ NATIF
NSIS / Squirrel installer
Windows 7/8
✔ SUPPORTÉ
Electron v22 = dernière version
macOS 10.13+
✔ NATIF
.app bundle, notarisation Apple
Ubuntu / Debian
✔ NATIF
.deb, .AppImage, Snap
Fedora / Arch
✔ NATIF
.rpm, .AppImage, Flatpak
iOS / Android
✘ IMPOSSIBLE
Pas de runtime mobile
Navigateur web
✘ NON
Desktop uniquement
10

Poids & performance

Le principal reproche fait à Electron est sa taille et sa consommation mémoire. Chaque application embarque une copie complète de Chromium et Node.js.

MétriqueElectronTauriHTA
Taille installateur~80–250 Mo~3–10 Mo~0 Ko
RAM au démarrage~150–400 Mo~30–80 Mo~20–50 Mo
Temps de démarrage2–5 sec< 1 sec< 1 sec
Performances UIExcellentes (V8)ExcellentesLimitées (IE)
Partage ChromiumNon (par défaut)WebView natif OSMSHTML partagé
ℹ
Optimisation : Electron Forge et electron-builder permettent de réduire la taille avec asar (archive compressée), le tree-shaking webpack/vite, et l'exclusion des dépendances dev. VS Code pèse ~100 Mo installé malgré sa richesse fonctionnelle.
11

Packaging & distribution

ELECTRON-BUILDER
# Installer electron-builder
npm install --save-dev electron-builder

# Package.json — configuration build
{
  "build": {
    "appId": "com.monapp.desktop",
    "win": { "target": ["nsis", "portable"] },
    "mac": { "target": "dmg", "category": "public.app-category.utilities" },
    "linux": { "target": ["AppImage", "deb"] }
  }
}

# Générer les installateurs pour toutes les plateformes
npx electron-builder --win --mac --linux
OutilRôleFormat de sortie
electron-builderLe plus complet, NSIS, dmg, AppImage, auto-update.exe .dmg .AppImage .deb .rpm
Electron ForgeOfficiel, intégré au CLI, plus simple.exe .zip .deb .rpm
electron-packagerBasique, sans installeurDossier avec l'exe
12

Cas d'usage appropriés

Cas d'usagePertinenceRaison
Éditeur de code / IDEEXCELLENTVS Code en est la preuve. Accès fichiers + extensions npm.
Client de messagerie / collaborationEXCELLENTSlack, Discord — notifications, systray, mise à jour auto.
Outil desktop cross-platform distribuéTRÈS BONUn seul codebase pour Win + Mac + Linux.
App web existante → desktopTRÈS BONEnveloppe une SPA React/Vue existante en quelques jours.
Utilitaire personnel légerOVERKILL150 Mo pour un utilitaire simple : préférer HTA (Windows) ou Tauri.
Application mobileIMPOSSIBLEDesktop uniquement — utiliser React Native ou Flutter.
Application haute performance / jeuDÉCONSEILLÉOverhead Chromium. Préférer Qt, Flutter, ou natif.
✔
Conclusion : Electron est le choix idéal quand tu veux distribuer une application desktop à une audience large sur Windows + macOS + Linux simultanément, avec les technologies web modernes (React, Vue, TypeScript) et l'écosystème npm. Le coût en taille et en mémoire est le compromis à accepter.