Unreal Engine 6 et la fin des Blueprints : ce que les studios doivent reconstruire maintenant
En bref
Préparez vos projets à la migration vers Unreal Engine 6 : Blueprints et C++ Gameplay Framework supprimés, extrayez votre logique de jeu immédiatement
Toute la couche de gameplay de votre projet vit peut-être dans un système qu'Epic vient d'annoncer vouloir retirer. Lors de l'Unreal Fest Tokyo 2026, Epic a révélé qu'Unreal Engine 6 supprime les Blueprints et le C++ Gameplay Framework tels que nous les connaissons — les deux piliers sur lesquels repose presque chaque titre Unreal commercialisé. Si votre équipe a livré ne serait-ce qu'un prototype, vous êtes concerné.
Ce n'est pas un simple renommage d'API. C'est une remise à zéro architecturale. Les studios qui comptent 200 000 lignes de logique de graphes Blueprint et des milliers de classes C++ dérivées de AActor, AGameModeBase et UActorComponent doivent comprendre exactement ce qui change, ce qui survit, et comment construire un plan de migration qui ne dévore pas un cycle de production complet.
Ce qui change réellement avec Unreal Engine 6
La session de Tokyo 2026 s'appuyait sur des détails partagés en juin. Deux annonces ont déclenché la réaction virale :
- Les Blueprints sont supprimés. Le système de script visuel qui a démocratisé Unreal pendant une décennie est remplacé.
- Le C++ Gameplay Framework est supprimé. La chaîne d'héritage
GameMode/GameState/PlayerController/Pawnqui définit le fonctionnement des jeux Unreal est en cours de réarchitecture.
Pour les développeurs, la question pratique n'est pas pourquoi — c'est que faire de 40 systèmes livrés qui en dépendent.
La direction d'Epic pointe vers un modèle piloté par les données et axé sur la composition. Au lieu d'hériter de AGameModeBase et de surcharger des fonctions virtuelles, la logique de gameplay évolue vers des définitions déclaratives évaluées par le runtime du moteur. Au lieu de câbler des event graphs dans Blueprint, la logique vit dans des modules code-first ou une nouvelle couche de création qu'Epic n'a pas encore entièrement détaillée.
Considérez chaque communication officielle comme provisoire. Les feuilles de route du moteur évoluent. Construisez un plan de migration qui isole votre logique de gameplay de l'arbre d'héritage du moteur, et vous survivrez quelle que soit la forme finale.
Ce qui survit, ce qui meurt
| Système | Statut dans UE6 | Risque de migration |
|---|---|---|
| Modèle Actor/Component | En évolution, axé composition | Moyen |
| Script visuel Blueprint | Supprimé | Élevé |
| Héritage du C++ Gameplay Framework | Supprimé | Élevé |
| Rendu / Nanite / Lumen | Poursuivi | Faible |
| Noyau de réplication réseau | Retravaillé | Élevé |
Sauvegarde/Chargement (USaveGame) |
Probablement retravaillé | Moyen-Élevé |
Les lignes à haut risque partagent un trait : elles encodent l'état du jeu et les règles du jeu. Cela fait de cette migration un problème de backend autant qu'un problème de moteur.
Le vrai point douloureux : votre logique de jeu est enchevêtrée avec l'héritage du moteur
Voici pourquoi c'est difficile, dit clairement.
Dans un projet UE5 typique, votre code de persistance vit dans des appels AGameModeBase::SaveGame(). Votre inventaire vit dans un UActorComponent qui ne fonctionne que parce qu'il est attaché à un AActor répliqué. Votre flux de démarrage de match vit dans AGameMode::StartMatch().
Aucune de ces logiques ne concerne le framework d'Unreal. Elle concerne votre jeu. Mais parce qu'elle a été écrite sous forme de surcharges et d'événements Blueprint, elle ne peut pas être déplacée.
La solution est d'extraire les règles du jeu dans une logique simple et agnostique au moteur dès maintenant, pendant qu'il est encore temps. Définissez votre domaine dans des structures qui n'importent pas les en-têtes du moteur.
Étape 1 : Séparer la logique de domaine des types du moteur
Créez une couche C++ pure sans #include "Engine.h". Elle doit se compiler comme une bibliothèque statique autonome.
// GameDomain/PlayerProgression.h — no engine headers
#pragma once
#include <cstdint>
#include <string>
#include <unordered_map>
namespace GameDomain {
struct PlayerProfile {
std::string AccountId;
int32_t Level = 1;
int64_t TotalXp = 0;
std::unordered_map<std::string, int32_t> Inventory;
};
// Pure function: same input, same output, no engine state.
inline PlayerProfile ApplyXpGain(const PlayerProfile& input, int32_t xpDelta) {
PlayerProfile result = input;
result.TotalXp += xpDelta;
// Simple level curve: 1000 XP per level.
while (result.TotalXp >= result.Level * 1000) {
result.TotalXp -= result.Level * 1000;
result.Level += 1;
}
return result;
}
} // namespace GameDomain
Désormais, vos classes Unreal sont de fins adaptateurs. Quand le framework de gameplay UE6 arrivera, vous recâblerez l'adaptateur — pas la logique. Ce seul changement réduit le risque de toute la migration.
Étape 2 : Auditer chaque graphe Blueprint qui touche à la persistance
Ouvrez votre projet et lancez un audit des dépendances. Les graphes Blueprint qui écrivent dans des fichiers de sauvegarde, calculent des récompenses ou valident des transactions sont ceux qui ne se traduiront pas proprement dans un nouveau système de création.
Pour chaque graphe, demandez-vous :
- Ce graphe contient-il des règles (formules de dégâts, taux de drop, courbes d'XP) ? → Extrayez-les dans le code.
- Ce graphe contient-il de la présentation (déclencheurs VFX, indices sonores, mises à jour UI) ? → Laissez-le, il sera recréé à moindre coût.
- Ce graphe contient-il des mutations d'état (écritures d'inventaire, changements de monnaie) ? → Extrayez-les immédiatement dans le code.
Les studios constatent généralement que 60 à 70 % des nœuds Blueprint sont de la présentation et peuvent être écartés pendant la migration. Les 30 % restants sont de la vraie logique et doivent être déplacés.
Étape 3 : Découpler l'état multijoueur des macros de réplication
La réplication est la deuxième mine terrestre. Les macros UPROPERTY(Replicated) et les surcharges de GetLifetimeReplicatedProps sont profondément liés au framework en cours de suppression.
Un motif défensif consiste à conserver l'état faisant autorité sur un backend, pas sur l'acteur répliqué. Quand un joueur marque un kill ou ramasse un objet, le client envoie une intention ; le backend valide et renvoie le nouvel état faisant autorité. La couche moteur ne fait que rendre ce que le backend confirme.
C'est plus pertinent pour les jeux à progression persistante que pour les arena shooters purement basés sur des sessions. Mais si votre jeu a une économie, un classement ou un inventaire inter-sessions, sortir l'autorité de la réplication du moteur est une amélioration stratégique, pas seulement une tactique de migration.
Ce motif corrige aussi des problèmes que vous avez probablement déjà. La même séparation architecturale qui survit à une migration UE6 est celle qui élimine la classe de désync documentée dans notre analyse du problème de réplication RPC qui casse les états multijoueur.
Étape 4 : Mettre en place une couche de persistance non liée au moteur
Votre système de sauvegarde est le plus grand risque de migration. S'il s'agit de sous-classes USaveGame sérialisées sur disque ou vers un service que seul votre client Unreal comprend, vous devrez le reconstruire.
Concevez la persistance comme un contrat versionné exposé via HTTP, avec un schéma qui vous appartient :
// BackendClient.h — UE6-agnostic adapter
#pragma once
#include <string>
#include <optional>
class IBackendClient {
public:
virtual ~IBackendClient() = default;
// Revision-aware write: server rejects stale revisions.
virtual bool SaveProfile(const std::string& accountId,
int64_t expectedRevision,
const std::string& jsonPayload) = 0;
virtual std::optional<std::pair<int64_t, std::string>>
LoadProfile(const std::string& accountId) = 0;
};
// Production implementation swaps to any HTTP transport.
// The gameplay layer never knows which transport is used.
Deux détails comptent ici :
- Écritures avec gestion de révision. Si le client envoie
expectedRevision = 42et que le serveur est en révision 45, l'écriture échoue. Le client résout le conflit. Cela évite le classique effacement de progression « dernier écrit gagne ». - L'interface n'a pas de types moteur. Elle se compile dans votre couche de domaine pure et survit à tout changement de moteur.
Construire cela vous-même signifie mettre en place l'authentification, un stockage de sauvegarde avec gestion de révision, des classements, une configuration à distance et un tableau de bord — en pratique, 4 à 6 semaines de travail backend qui ne produisent aucun gameplay. horizOn couvre la Cloud Save liée au compte avec des lectures et écritures avec gestion de révision, l'authentification des utilisateurs par e-mail, anonyme, Google et Apple, ainsi que les classements et la configuration à distance. Votre client conserve le fin adaptateur IBackendClient ; la plateforme gère le reste.
Vérification : comment prouver que votre migration est sûre
Avant de toucher à une seule build UE6, prouvez que votre extraction a fonctionné :
- Compilez la couche de domaine de manière autonome.
g++ -c GameDomain/*.cppsans includes moteur. Si cela échoue, vous avez encore un couplage au moteur. - Écrivez des tests unitaires sans harnais de test moteur. Si vos règles de gameplay ont besoin de
GEnginepour s'exécuter, elles ne sont pas extraites. - Rejouez une session enregistrée. Enregistrez une session de jeu de 10 minutes dans UE5, puis rejouez le flux d'entrée à travers votre couche de domaine et vérifiez que l'état final correspond. Une divergence signifie que la logique vit encore dans Blueprint ou dans un acteur moteur.
- Simulez une écriture de révision obsolète. Envoyez
expectedRevisionen retard par rapport à la révision actuelle du serveur. Votre client doit détecter le conflit et le résoudre sans perte de données.
Exécutez ces quatre vérifications dans le CI. Toute régression est détectée avant le début de la migration du moteur.
Bonnes pratiques pour la fenêtre de migration UE6
- Gelez dès aujourd'hui toute nouvelle logique de jeu Blueprint. Déclarez une politique de projet selon laquelle les nouvelles règles de gameplay doivent atterrir dans la couche de domaine agnostique au moteur. Vous ne pouvez pas migrer ce que vous continuez d'ajouter.
- Versionnez explicitement votre schéma de sauvegarde. Ajoutez un champ
schemaVersionà chaque payload persisté. Quand UE6 change la sérialisation, vous mettez à jour à la lecture au lieu de perdre les données des joueurs. - Déplacez l'autorité vers le serveur pour l'état persistant. Inventaire, monnaie, rang, déblocages. Le moteur est un client. Traitez-le ainsi et la suppression du framework devient un non-événement pour votre économie.
- Prévoyez 4 à 8 semaines par projet mature. Auditez, extrayez, testez, réadaptez. Les équipes qui commencent l'audit maintenant termineront avant l'arrivée de la première build de production d'UE6.
- Ne bloquez jamais la sortie du jeu pour la migration. Si vous êtes en pleine production sur UE5, continuez à construire. Utilisez l'extraction de la couche de domaine comme une assurance, pas comme une réécriture.
L'essentiel à retenir
La suppression des Blueprints et du C++ Gameplay Framework dans Unreal Engine 6 est le plus grand changement architectural de l'histoire du moteur. Les studios qui en sortent proprement sont ceux qui traitent leur logique de jeu comme un produit, pas comme une fonctionnalité du moteur.
Commencez cette semaine : choisissez un système — persistance, inventaire ou progression — et extrayez ses règles dans un module de domaine pur sans en-têtes moteur. Ajoutez une interface de sauvegarde avec gestion de révision derrière. Puis continuez à construire, car cette extraction est le même travail qui corrige vos désyncs, effacements et surfaces de triche actuels.
Prêt à décharger la couche de persistance pendant que vous vous concentrez sur la migration ? Essayez horizOn gratuitement pour la Cloud Save liée au compte, l'authentification et les classements, ou lisez la documentation API pour câbler l'adaptateur client.
Source : L'avenir d'Unreal Engine 6