Top 5 des frameworks d'interface HMI embarqués pour 2025

Embedded human-machine interfaces, or HMIs, require UI frameworks capable of delivering smooth, visually rich, and highly responsive graphics across diverse hardware platforms, from low-power microcontrollers used in everyday appliances to advanced SoCs powering automotive digital cockpits. 

Below, we explore five of the leading embedded UI frameworks, both open-source and commercial, that are widely adopted in automotive, industrial, and consumer electronics. For each, you’ll find an overview of the vendor or developer, core features, known limitations, best-fit use cases, licensing details, and links to official resources.

Qt – Framework mature et polyvalent pour l'UI embarquée

Qt, developed by The Qt Company, is one of the most established frameworks for building graphical user interfaces and applications in C++. It offers a mature toolkit that scales from desktop environments to embedded devices, making it a popular choice for automotive, industrial, medical, and consumer HMIs.

Architecture et modèle de programmation

Qt offre une flexibilité dans la façon dont les interfaces utilisateur sont construites :

• Qt Widgets / C++: Pour la programmation d'interfaces utilisateur traditionnelles ou de bas niveau.
• Qt Quick / QML: Un langage déclaratif avec une syntaxe de type JSON et JavaScript pour la logique. Cette approche permet aux designers et aux développeurs de définir rapidement des interfaces, des animations et des comportements pilotés par l'état.

Behind the scenes, Qt Quick relies on a scene graph rendering model. UIs are represented as a tree of items in memory and rendered via OpenGL, OpenGL ES, or other graphics APIs. This retained-mode rendering allows batching and optimisation, which improves GPU performance and keeps animations fluid, even on embedded hardware.

Qt sépare la couche UI (QML, Qt Quick ou Widgets) de la logique backend (C++, Python, etc.). L'interaction est gérée via son mécanisme bien connu de signaux et slots, prenant en charge des applications événementielles hautement réactives.

Support de plateforme et outillage

Le plus grand atout de Qt est sa couverture multiplateforme :

• Bureau : Windows, Linux, macOS
• Mobile : Android, iOS
• Embarqué : Linux (avec Wayland ou framebuffer), QNX, RTOS, et Qt for MCUs (optimisé pour les appareils bare-metal ou pilotés par RTOS).

Cette évolutivité permet au même framework d'alimenter les systèmes d'infodivertissement embarqués haut de gamme, les tableaux de bord industriels et les écrans à microcontrôleur à faible empreinte.

L'écosystème comprend des outils de développement robustes :

• Qt Creator: IDE officiel avec édition de code, débogage et conception d'interface graphique.
• Qt Design Studio: Environnement visuel pour créer des interfaces utilisateur et des animations basées sur QML.
• Outils de profilage et de débogage: Tels que GammaRay et Qt Inspector pour l'inspection en direct sur les appareils cibles.

Ceux-ci raccourcissent les boucles d'itération entre la conception et le développement — crucial dans des secteurs en évolution rapide comme l'HMI automobile.

Points forts

• Réutilisabilité multiplateforme: Une seule base de code peut servir les systèmes de bureau, embarqués et mobiles, y compris des OS spécialisés comme QNX.
• Performances natives: Les applications se compilent en C++ et s'exécutent au plus près de la machine, ce qui rend Qt adapté aux interfaces utilisateur en temps réel telles que les combinés d'instruments ou les interfaces de dispositifs médicaux.
• Interface déclarative avec QML: idéal pour des HMI riches, animées et tactiles, avec prise en charge des shaders et du contenu 3D.
• Bibliothèques étendues: Réseautage, multimédia, API de capteurs, graphiques 2D/3D et composants d'interface utilisateur prêts à l'emploi.
• Synergie entre conception et développement : Des outils intégrés prennent en charge la collaboration entre ingénieurs et designers.
• Fiabilité éprouvée: Utilisé dans les produits à long cycle de vie dans l'automobile (par exemple, MBUX chez Mercedes-Benz), le médical et l'automatisation industrielle.

Licences et support commercial

Qt est proposé sous une double licence :

• Open source (GPLv3, LGPLv3) : Adapté à certains cas d'usage non commerciaux ou à liaison dynamique.
• Licence commerciale : Comprend les droits de liaison statique, les modules à usage commercial uniquement (par exemple, Qt for MCUs), le support à long terme et une assistance professionnelle garantie.

In regulated industries (automotive, medical, aerospace), organisations typically choose the commercial route for compliance, confidentiality, and lifecycle stability. The Qt Company and its partners (e.g., KDAB, ICS) provide professional services, consulting, and certified developer training.

Slint – boîte à outils d'interface utilisateur embarquée légère en Rust/C++

Slint is a modern, lightweight UI toolkit developed by SixtyFPS GmbH (formerly “SixtyFPS,” reflecting its goal of consistently delivering 60 FPS graphics). It’s open source, actively maintained, and available under flexible licensing models, with commercial support for embedded projects.

Architecture et modèle de programmation

Slint adopte une approche déclarative inspirée de QML, mais conçue pour être plus légère et plus prévisible. Les interfaces sont définies dans des fichiers .slint à l'aide d'un langage spécifique au domaine, de type JSON, qui décrit les composants, les mises en page, les états et le comportement.

The Slint compiler translates these files into native Rust or C++ code. This design removes the need for a heavy runtime or embedded scripting engine, resulting in extremely small binaries and fast startup. The core runtime requires under 300 KB of RAM, making it well-suited for microcontrollers and constrained devices.

Its property-binding system ensures UI elements update reactively when data changes, similar to Qt or React. Rendering backends are modular: OpenGL ES for GPU-accelerated platforms, a lightweight software rasteriser for MCUs without a GPU, or integrations with Qt and Skia for more advanced use cases.

Bien que Slint soit implémenté en Rust pour la sécurité mémoire, les développeurs peuvent travailler en C++, Python ou JavaScript grâce aux bindings générés. Cela permet un développement d'interface utilisateur sûr et moderne sans imposer une pile Rust complète.

Support de plateforme et outillage

Slint a d'abord été conçu pour les systèmes embarqués, mais il fonctionne également sur ordinateur, web et mobile :

• Embarqué : Linux avec ou sans système de fenêtrage, microcontrôleurs bare-metal avec framebuffers ou écrans SPI.
• Bureau : Windows, macOS, Linux.
• Web : WebAssembly avec rendu WebGL.

Son expérience développeur est axée sur la rapidité et l'intégration :

• Aperçu en direct : Rechargement à chaud avec l'extension VS Code et le serveur de langage.
• Plugin Figma : Export direct des éléments d'interface utilisateur de la conception vers le code Slint.
• Inspecteur et débogage : Édition des propriétés de l'interface utilisateur, aperçus des appareils et tests prêts pour l'intégration continue.
• API multilingues : Support natif pour Rust, C++, Python et JavaScript.

Points forts

• Empreinte ultra-légère : <300 Ko d'exécution, pas de ramasse-miettes, démarrage rapide.
• Haute performance : Des animations fluides à 60 FPS, même sur du matériel embarqué modeste.
• Sécurité basée sur Rust : Noyau à mémoire sécurisée avec API C++ disponibles pour une adoption progressive.
• Interface utilisateur réactive déclarative : Simplifie les HMI dynamiques grâce aux mises à jour automatiques des propriétés.
• Runtime sans dépendances : Aucune exigence de système d'exploitation ou de framework lourd.
• Flux de travail designer-développeur : Les aperçus en direct et l'intégration Figma accélèrent les itérations.
• Intégration flexible : Peut coexister avec Qt ou d'autres frameworks pour prendre en charge les migrations hybrides.

Licences et support

Slint utilise un modèle de double licence :

• GPLv3 pour les projets open source.
• Apache 2.0 (libre de redevances) pour les applications propriétaires de bureau, mobiles et web.
• Licence commerciale pour les systèmes embarqués, y compris le support direct des fournisseurs et les options à long terme.

This flexible approach removes runtime royalties for many platforms and lowers entry barriers compared to traditional frameworks. Commercial licensing is priced to be accessible to startups and smaller OEMs, with support provided directly by the Slint team.

Flutter – boîte à outils UI à haute productivité avec rendu personnalisé

Flutter is an open-source UI framework created by Google, first released in 2017 and rapidly adopted from 2019 onward. Originally designed for mobile apps, Flutter has since expanded to desktop, web, and embedded devices. It is also the default UI layer for Google’s Fuchsia OS.

Architecture et modèle de programmation

La principale distinction de Flutter réside dans le fait qu'il restitue chaque pixel lui-même via son propre moteur graphique, au lieu de s'appuyer sur les widgets natifs du système d'exploitation. Cette approche garantit une apparence et une expérience utilisateur cohérentes sur toutes les plateformes, tout en permettant des interfaces hautement personnalisées.

Applications are written in Dart, Google’s modern object-oriented language designed for UI development. Dart supports features such as async/await, a declarative reactive framework, and both JIT (for fast development cycles with Hot Reload) and AOT compilation (for native ARM/x86 binaries in production).

The programming model is widget-based and declarative: developers define a widget tree in Dart code that describes UI structure and behaviour. When state changes, Flutter rebuilds the necessary widgets, conceptually similar to React but without a JavaScript bridge.

Sous le capot :

• Moteur de rendu : Utilise Skia (également utilisé dans Chrome) pour un rendu graphique accéléré par GPU ; transition vers Impeller, un runtime de nouvelle génération qui réduit les saccades liées à la compilation des shaders et offre des performances plus prévisibles.
• Architecture en couches : Un noyau C/C++ gère le texte, les graphiques et la machine virtuelle Dart, tandis que la majorité du framework (widgets, gestes, animations) est développée en Dart pour plus de flexibilité.
  Canaux de plateforme : Intégration native via des ponts vers Android (Java/Kotlin), iOS (Swift/Obj-C) ou d'autres API système, permettant l'accès aux appareils (caméra, capteurs, etc.).

Le résultat est un rendu fluide à 60–120 fps d'interfaces complexes, d'animations et de graphiques, si l'accélération matérielle est disponible.

Support de plateforme et outillage

Flutter a débuté en tant que solution Android/iOS uniquement, mais prend désormais en charge :

• Mobile : Android, iOS (stable).
• Bureau : Windows, macOS, Linux.
• Web : Via CanvasKit/WebAssembly.
• Embarqué : Grâce à des embedders personnalisés.

Google fournit des exemples d'embedders pour le framebuffer Linux, et des entreprises comme Toyota ont déployé avec succès Flutter dans des systèmes d'infodivertissement automobile (AGL/Wayland), citant des performances fluides et une productivité des développeurs accrue grâce au Hot Reload.

L'outillage est un atout majeur :

• SDK et CLI (Flutter): Gère les builds, les exécutions et les déploiements.
• Rechargement à chaud : Injection quasi instantanée des modifications du code Dart dans une application en cours d'exécution.
• Outils de développement : Suite basée sur le web pour le profilage, l'inspection de la mémoire, les arbres de widgets et les chronologies de performance.
• Plugins IDE : Prise en charge avancée de VS Code, Android Studio/IntelliJ.
• Outils de conception UI : Bien que Flutter ne dispose pas d'un éditeur WYSIWYG officiel, des outils tiers (par ex. FlutterFlow, Plugin Adobe XD) permettent un prototypage par glisser-déposer qui génère du code Dart.
• Tests : Framework intégré pour les tests unitaires, de widgets et d'intégration, y compris la simulation de gestes.
• Accessibilité et i18n : Arborescence sémantique, prise en charge de l'écriture de droite à gauche et gestion globale des polices via ICU.

Considérations matérielles et de performance

Flutter suppose un environnement compatible GPU (OpenGL ES 2.0+/Vulkan). L'empreinte mémoire et de stockage est modeste selon les standards mobiles (les versions de production font généralement 10 à 20 Mo), mais trop lourde pour les MCU. Les cibles appropriées incluent Raspberry Pi 4, NXP i.MX8M, et des plateformes Linux embarquées comparables. Les processeurs à faible consommation sans accélération GPU (par exemple, i.MX6 ULL) rencontrent des difficultés.

Points forts

• Contrôle d'interface personnalisé : Une pile de rendu complète permet des interfaces de marque, hautement animées, sans contraintes liées au système d'exploitation.
• Performances fluides : Rendu à 60–120 fps avec une synchronisation prévisible (notamment avec Impeller).
• Réutilisation de code multiplateforme : Une base de code Dart unique couvre le mobile, le bureau, le web et l'embarqué.
• Productivité des développeurs : Hot Reload + widgets déclaratifs = itération de conception très rapide.
• Écosystème et communauté : Écosystème de packages étendu (par ex. MQTT, Modbus, Bluetooth), ainsi qu'un solide soutien de Google.
• Design responsive et thématisation : Des API pour s'adapter à plusieurs tailles d'écran, résolutions et orientations.

Licences et support

Flutter is licensed under BSD, making it royalty-free and permissive for commercial projects. Google and the open-source community maintain it, but unlike Qt or commercial HMIs, there is no official enterprise support program. Instead, companies often rely on consultancies or the global developer community.

Google lui-même utilise Flutter en production (par exemple, Google Pay, Fuchsia), ce qui renforce son statut stratégique. Bien que certaines inquiétudes existent quant à la longévité du projet de Google, Flutter a connu une croissance constante, avec un investissement continu dans les cas d'usage embarqués.

Is it for you? Flutter is attractive for industries needing polished, smartphone-like interfaces on embedded Linux hardware (e.g., automotive, medical devices, consumer electronics). It combines modern developer ergonomics, smooth performance, and cross-platform reach — provided the target system has sufficient GPU resources.

React Native – faire le lien entre le web et le mobile pour des interfaces multiplateformes

React Native (RN) is an open-source framework developed by Meta (Facebook) and released in 2015. It extends the popular React paradigm from the web to mobile, allowing developers to build native iOS and Android apps with JavaScript and TypeScript. While its focus is mobile, the ecosystem now includes extensions for desktop, web, and even embedded use cases.

Architecture et modèle de programmation

React Native adopts a declarative, component-based model similar to React for the web. Developers write UI in JSX (XML-like syntax) and style with JavaScript objects that resemble CSS. Logic runs in JavaScript/TypeScript via engines like Hermes (lightweight, RN-optimised) or V8. Each RN component maps directly to a native widget — for example, <Text> becomes a UILabel on iOS or a TextView on Android. This approach distinguishes RN from Flutter, as RN leverages the native rendering stack rather than re-implementing its own.

Traditionnellement, RN utilisait un pont JavaScript :

• Le runtime JS gérait l'état et la logique de l'application.
• Un pont asynchrone communiquait les diffs (issus du DOM virtuel de React) à la couche native.
• La couche native a mis à jour ou créé les widgets d'interface utilisateur en conséquence.

Cela fonctionnait, mais une communication fréquente entre ponts pouvait introduire de la latence et une surcharge de performance.

Pour y remédier, RN déploie la nouvelle architecture :

• Moteur de rendu Fabric : Une couche de rendu basée sur C++ qui unifie la logique entre Android et iOS, permettant des mises à jour synchrones et par lots ainsi qu'une interface utilisateur plus fluide.
• TurboModules : Système de modules natifs plus rapide et plus léger avec des appels directs de JS vers le natif.
• Moteur Hermes : Optimisé pour un démarrage rapide et une utilisation réduite de la mémoire.

Ce changement améliore considérablement les performances, la cohérence et l'évolutivité dans les applications complexes (depuis RN 0.70+).

Pour les développeurs, RN semble familier : composants fonctionnels/de classe, hooks pour l'état, et accès au vaste écosystème npm.

Support de plateforme et outillage

Cibles principales :

• iOS et Android (prise en charge complète).

Cibles étendues :

• Windows/macOS : Les forks RN de Microsoft pour les applications UWP, Win32 et Cocoa.
• Web : React Native Web fait correspondre les composants RN aux éléments du DOM pour un partage partiel du code.
• Embarqué/Linux : Portages expérimentaux (react-native-linux, builds Yocto) et utilisation courante via Systèmes embarqués sous Android (par ex., téléviseurs intelligents, IVI). Amazon utiliserait RN pour l'application TV de Prime Video.
• Autres : tvOS, Raspberry Pi (porté par la communauté).

Chaîne d'outils :

• CLI + bundler metro : Pour les workflows de build/exécution.
• Rafraîchissement rapide : Préserve l'état tout en injectant les modifications JS en temps réel.
• Débogage : Chrome DevTools, VS Code, React DevTools, ainsi que Flipper pour inspecter la mise en page, le réseau et les journaux.
• IDEs: Généralement,  VS Code pour JS plus Xcode/Android Studio pour les modules natifs.
• Outils de conception : Pas de WYSIWYG officiel ; les développeurs s'appuient sur Storybook pour le développement isolé de composants ou sur une UI codée manuellement à partir des spécifications de conception.

Considérations matérielles et de performance

• Exigences : Un processeur performant et plusieurs centaines de Mo de RAM (les téléphones modernes sont idéaux).
• Rendu : RN utilise le pipeline de rendu natif du système d'exploitation, et non son propre moteur GPU. Les performances sont généralement « natives » pour des widgets comme les listes et les vues défilantes.
• Contraintes : La surcharge du pont peut solliciter les processeurs plus faibles ou les mises à jour fréquentes d'état. Fabric atténue ce problème en rapprochant la logique de rendu du natif.
• Adéquation embarquée : RN fonctionne mieux sur les appareils basés sur Android (téléviseurs, IVI, décodeurs) mais est trop gourmand en ressources pour le matériel de classe MCU.

Points forts

• Transfert de compétences du web vers le mobile : Les développeurs React peuvent se tourner vers le développement d'applications natives avec une reconversion minimale.
• Apparence et convivialité natives : RN utilise de véritables widgets natifs, offrant aux applications une UX adaptée à la plateforme dès le départ.
• Écosystème étendu : Des milliers de bibliothèques/plugins pour les API des appareils, les graphiques, les animations, le Bluetooth, etc.
• Itération rapide : Fast Refresh rationalise le prototypage d'interface utilisateur et la correction des bugs.
• Partage de code multiplateforme : Réutilisation majeure de code entre iOS/Android, avec des frameworks comme Expo permettant des workflows unifiés sur le web et le mobile.
• Communauté et adoption : Largement utilisé par Meta, Microsoft (Teams), Tesla, Shopify, et d'autres. Forte dynamique open source et contributions d'entreprises.
• Passerelle native : Les développeurs peuvent implémenter des composants spécifiques en code natif iOS/Android lorsque les performances l'exigent.
• Outils de débogage matures : Flipper, Chrome DevTools et React DevTools offrent une visibilité complète sur les applications RN.

Licences et support

• Licence : MIT, permissive et libre de redevances. Aucune obligation de copyleft.
• Support : Maintenu par Meta avec des contributions majeures de Microsoft et de la communauté open source. Pas de support entreprise officiel, mais de nombreux cabinets de conseil sont spécialisés dans RN.
• Dépendances : RN repose sur Xcode (pour iOS), le SDK Android et des chaînes de compilation natives — le dépannage couvre souvent RN et les problèmes au niveau de la plateforme.

React Native is appealing where Android-based embedded systems are in play (e.g., infotainment, smart displays, TVs). It allows leveraging existing JavaScript talent, accelerates cross-platform development, and benefits from a huge ecosystem, though resource constraints and reliance on native bridges must be carefully evaluated.

L'interface Slate d'Unreal Engine – framework d'interface 3D en temps réel

Slate UI is the low-level user interface framework inside Epic Games’ Unreal Engine. Originally created to power game HUDs and the Unreal Editor itself, it now underpins all in-game and editor UIs in UE4/UE5. While not distributed as a standalone toolkit, it comes bundled with Unreal Engine and is increasingly used for non-gaming applications, most notably automotive HMI.

Above Slate sits UMG (Unreal Motion Graphics), a higher-level, Blueprint-driven UI system. UMG wraps Slate widgets in a designer-friendly interface, enabling drag-and-drop layout, animation, and logic binding without requiring raw C++ coding. Together, Slate and UMG form Unreal’s full UI stack.

Architecture et modèle de programmation

Slate (couche C++) :

• Un framework de widgets en C++ à mode conservé (classe de base SWidget).
• Similaire dans l'esprit à Qt Widgets : boutons, panneaux, texte, tous construits à partir de widgets dans une hiérarchie de graphe de scène.
• Le rendu est entièrement piloté par le moteur — Slate n'utilise pas les contrôles natifs du système d'exploitation, mais dessine tout via le pipeline GPU d'Unreal. Cela rend l'interface entièrement personnalisable avec des shaders, de la 3D et un rendu personnalisé.

UMG (couche Blueprint) :

• Une couche destinée aux designers construite sur Slate.
• Fournit un visuel éditeur pour composer les interfaces utilisateur (Widget Blueprints).
• L'interactivité est ajoutée via Blueprint scripting ou fonctions C++ liées.
• Recommandé pour la plupart des projets HMI, car il raccourcit les itérations et permet la collaboration entre designers et développeurs.

Prise en charge de MVVM :

• UE5 introduit un modèle MVVM cadre pour UMG. Les développeurs définissent des ViewModels en C++ ou en Blueprints, qui alimentent les widgets d'interface utilisateur en données.
• Cela rapproche Unreal des frameworks d'interface utilisateur d'entreprise comme Qt/QML, améliorant la maintenabilité des grands projets à l'état complexe.

Modèle de rendu :

• Les widgets Slate/UMG sont dessinés à l'aide du moteur de rendu différé d'Unreal ou d'un moteur de rendu d'interface utilisateur optimisé.
• Peut intégrer de la 3D modèles, post-traitement, effets de particules, ou même des environnements temps réel complets directement dans l'interface utilisateur.
• Les exemples automobiles incluent des rendus 3D de véhicules dans les tableaux de bord (par exemple, Lotus, GMC Hummer EV).

Options de programmation :

• C++ (Slate) : Créez des SWidgets personnalisés, redéfinissez tick/paint, composez dans des layouts — utilisés pour des contrôles sur mesure.
• Blueprint (UMG) : Glisser/déposer des widgets, animer les transitions, scripter les interactions visuellement.
• Hybride : Utilisez les Blueprints pour la mise en page et l'interaction, tout en exposant les données et les modèles issus des systèmes C++.

Support de plateforme et outillage

Plateformes prises en charge :

• Bureau : Windows, Linux, macOS (développement).
• Déploiement : Windows (y compris Embedded/IoT), Linux (personnalisable), Android, iOS, principales consoles.
• Automobile : Prise en charge explicite des plateformes Qualcomm Snapdragon Automotive (Android ou QNX), intégration avec les hyperviseurs QNX pour les systèmes IVI.
• Expérimental : Des builds WebAssembly pour des démos plus légères, pas pour des HMI de production.
• Non adapté aux MCU ou aux systèmes bas de gamme — nécessite un OS + un GPU moderne (Vulkan/DirectX/Metal).

Avantages des outils :

• Éditeur Unreal : Conception WYSIWYG des mises en page UMG, des ancrages et du design adaptatif. Animer les widgets directement dans l'éditeur.
• Plans directeurs : Scripting basé sur des nœuds pour un prototypage et une itération rapides. Les designers peuvent implémenter la logique eux-mêmes.
• Déploiement en un clic : Packager et déployer vers des tablettes Android, des bancs de test IVI ou des systèmes embarqués Windows/Linux en quelques secondes.
• Profilage : Unreal Insights, profileurs GPU/CPU, budgétisation des frames pour le démarrage et les objectifs de fréquence d'images.
• Collaboration : Intégration Perforce/Git native ; prend en charge les équipes pluridisciplinaires (artistes, designers, programmeurs).

Fonctionnalités spécifiques à l'automobile/HMI :

• Chemins de démarrage rapides pour des affichages de démarrage instantanés.
• Prise en charge multi-écrans (afficher une scène sur plusieurs écrans de voiture ou fournir des sorties séparées).
• Service Android à instance unique pour partager un seul runtime entre plusieurs surfaces HMI.
• Intégration de Niagara VFX pour des indicateurs de charge animés, des effets de particules ou des arrière-plans dynamiques.

Configuration matérielle requise

• Les interfaces Unreal packagées sont lourds: des binaires de l'ordre de la centaine de Mo, des empreintes mémoire de l'ordre de 200 à 400 Mo.
• Le temps de démarrage peut être de quelques secondes, bien qu'Epic optimise pour IHM à démarrage rapide en réduisant les shaders et les assets.
• Matériel cible : SoC de milieu à haut de gamme (par exemple, Snapdragon 820a ou plus récent) avec une capacité GPU comparable à celle des smartphones modernes.
• Non viable pour les systèmes à ultra-basse consommation ; idéal pour voitures haut de gamme, simulateurs ou IHM industrielles avec des environnements riches en GPU.

Points forts

• Fidélité visuelle inégalée : 3D photoréaliste, éclairage en temps réel, reflets, ombres, post-traitement. Unique parmi les frameworks HMI.
• Interactivité en temps réel : Animations complexes, widgets pilotés par la physique, transitions 3D/2D fluides. Prend en charge le tactile, les manettes, les gestes, la voix.
• Flux de travail axé sur le design : Les designers peuvent implémenter et tester directement l'interface utilisateur dans le moteur à l'aide de Blueprints, ce qui réduit les cycles de transfert.
• Intégration avec la simulation et la 3D : Idéal pour la visualisation ADAS, les simulateurs de formation, les jumeaux numériques. Réutilisation des ressources de jeu/marketing existantes.
• Performances multiplateformes : Optimisé pour un rendu à 60 FPS sur toutes les plateformes ; s'appuie sur des abstractions de moteur matures pour les entrées, les API de rendu, le HDR, etc.
• Évolutif et pérenne : Les mises à jour du moteur offrent un accès automatique aux fonctionnalités GPU de nouvelle génération. Possibilité d'augmenter la qualité avec le matériel.
• Accès à la source : Code source complet du moteur disponible pour modification ; permet une personnalisation approfondie pour les projets HMI d'entreprise.
• Dynamique du secteur : Équipe dédiée Epic HMI, vitrines automobiles, partenariats Qualcomm/Epic ; écosystème croissant d'intégrateurs (Elektrobit, Siili, etc.).

Licences et modèle commercial

• Licence : Gratuit, avec accès au code source via GitHub d'Epic.
• Modèle de redevances : 5 % de redevances sur le chiffre d'affaires brut au-delà de 1 M$ pour les produits commerciaux vendus. Les applications internes ou gratuites en sont généralement exemptées.
• Automobile et entreprise : Conditions de licence personnalisées négociables — souvent des frais forfaitaires au lieu de redevances par unité (par exemple, pour le HMI du GM Hummer EV).
• Support : Les partenaires Enterprise ont accès au Custom License Program d'Epic, incluant le support, l'assistance au niveau du code source et le co-développement.
• Aspect open source : Non open source selon les termes FOSS, mais le code source complet est fourni aux titulaires de licence ; toute redistribution est interdite.
• Expérimentation : Prototypage gratuit sans frais ; les obligations commerciales n'apparaissent qu'au stade de la productisation.

Unreal Engine’s Slate/UMG stack is best-in-class for high-end, visually rich HMIs. It enables photoreal 3D dashboards, rapid design iteration, and integration with advanced simulation or sensor data. The trade-offs: a large runtime footprint, demanding hardware, and licensing complexity. For premium automotive, aerospace, and industrial projects where immersive visuals and design-driven workflows are priorities, Unreal stands out as a uniquely powerful option.

Choisir le bon framework

Aucun framework n'est le « meilleur universel ». Le bon choix dépend de votre appareil, de votre secteur et des objectifs de votre équipe. Voici comment les principales options se comparent :

Qt: The safe, versatile choice. Mature, feature-rich, and proven in automotive, medical, and industrial domains. It scales from MCUs to full Linux systems, with strong tooling and long-term support. Ideal when you need stability across varied hardware. Just account for licensing costs.

Slint: Le nouveau venu léger. Encombrement compact, compatible avec Rust et flexible en matière de licence. Idéal pour les appareils plus petits ou lorsque vous souhaitez des capacités d'interface utilisateur modernes sans la surcharge des frameworks plus volumineux. Considérez-le comme une alternative plus légère et ouverte à QML.

Flutter: Designed for polished UIs and rapid iteration. Great if you want app-like fluidity on embedded Linux or plan to reuse code across mobile, desktop, and embedded. Perfect for consumer devices and infotainment systems, provided hardware resources are sufficient.

React Native: Adapté aux appareils mobiles ou basés sur Android, en particulier si vous disposez déjà d'une expertise React. Ce n'est pas la solution privilégiée pour les HMI embarquées traditionnelles, mais elle fonctionne bien lorsque votre HMI fait également office d'application Android ou d'application compagnon.

Interface utilisateur Unreal Slate: Pour les projets haut de gamme et gourmands en graphismes. Si vous avez besoin de visuels cinématographiques, de réalisme 3D ou d'un « effet wow » (voitures de luxe, simulateurs, interfaces premium), Unreal se démarque. Excessif pour des HMI plus simples, mais inégalé dans le bon contexte.