Retour au Blog

Godot 4.8 Beta 3 arrive ? Lancez ces tests de migration avant que vos scènes ne cassent

Publié le 13 novembre 2026
Godot 4.8 Beta 3 arrive ? Lancez ces tests de migration avant que vos scènes ne cassent Généré avec l'aide de l'IA

En bref

Exécutez les tests de migration Godot 4.8 bêta 3 pour détecter les régressions avant qu'elles ne cassent vos scènes et votre physique de jeu.

La snapshot Godot 4.8 beta 3 vient de sortir, et l'équipe annonce qu'elle se rapproche de la phase de release candidate. Cela signifie que la fenêtre pour détecter et signaler les régressions se réduit rapidement. Si vous maintenez un projet Godot — qu'il sorte le mois prochain ou dans un an — c'est le moment d'ouvrir votre codebase dans cette build et de voir ce qui casse.

La plupart des développeurs ne testent pas les bêtas systématiquement. Ils clonent la build, ouvrent leur projet, jettent un œil à quelques scènes, et considèrent que c'est bon. Puis la version stable sort, la physique semble différente, les fichiers de sauvegarde se désérialisent incorrectement, et un joueur tombe sur une erreur obscure d'analyse GDScript qui ne s'est jamais déclenchée pendant le développement. La solution n'est pas un débogage héroïque après le lancement. C'est un protocole de test reproductible qui détecte ces problèmes maintenant.

Ce guide vous propose un workflow concret : un script de test de migration que vous pouvez exécuter dès aujourd'hui, trois pièges spécifiques à rechercher, et une structure de signalement de régression qui attire réellement l'attention de l'équipe Godot.


Pourquoi la bêta 3 est votre échéance de test

La bêta 3 est la dernière bêta avant que l'équipe Godot ne passe aux release candidates. Les release candidates servent à peaufiner, pas à découvrir que move_and_slide() se comporte différemment sur des pentes supérieures à 45°. Quand la RC1 sortira, les nouvelles régressions ne seront traitées comme bloqueurs que si elles sont assez graves pour retarder la sortie.

Votre rôle pendant la fenêtre de bêta est simple :

  • Trouver les régressions avant qu'elles ne deviennent invisibles dans la version stable
  • Documenter les changements cassants spécifiques à la codebase de votre projet
  • Signaler les bugs avec des étapes de reproduction minimales pour que les mainteneurs puissent les corriger

L'équipe Godot était à la GodotFest la semaine dernière et a quand même poussé des correctifs pour les bloqueurs de sortie restants. C'est le rythme. Si vous voulez votre mot à dire sur ce à quoi ressemblera la 4.8 au lancement, testez maintenant.


Mettre en place une branche de test de migration

Avant d'ouvrir quoi que ce soit dans la bêta 3, créez un environnement de test propre :

# Create a dedicated testing branch from your stable codebase
git checkout -b beta/4.8-testing
git push -u origin beta/4.8-testing

Pourquoi une branche séparée est importante : Les fichiers de scène de Godot (.tscn) sont basés sur du texte et incluent des métadonnées spécifiques au moteur. Lorsque vous ouvrez une scène dans la 4.8 bêta 3 et que vous l'enregistrez, le hash du fichier change. Si vous fusionnez avec des membres de l'équipe sur différentes versions de Godot, cela crée des conflits de fusion pénibles à résoudre. Gardez les tests bêta isolés.


Créer un script de test de migration

La plus grande lacune de test chez les développeurs est l'absence de référence. Vous ouvrez le projet, ça « semble correct », et vous passez à autre chose. Le problème : semble correct ne détecte pas les dérives de la physique, les différences de compilation des shaders, ni les changements de comportement GDScript qui ne se manifestent que dans des conditions spécifiques.

Voici un script de test de migration que vous pouvez intégrer dans n'importe quel projet Godot 4.x. Il valide les comportements fondamentaux du moteur par rapport aux valeurs attendues :

@tool
extends SceneTree

## Godot 4.8 Beta 3 Migration Test Suite
## Run with: godot --headless -s migration_test.gd
##
## This script validates that core engine behaviors match
## expectations from Godot 4.7.x stable. Run it in both
## the stable build and beta 3, then compare output.

var results: Array[Dictionary] = []

func _init() -> void:
	print("\n╔══════════════════════════════════════════════╗")
	print("║   Godot 4.8 Beta 3 — Migration Test Suite   ║")
	print("╚══════════════════════════════════════════════╝\n")
	
	test_vector_math()
	test_json_parsing()
	test_scene_serialization()
	test_input_map_registration()
	test_color_conversion()
	test_file_access_permissions()
	
	print_summary()
	quit(get_exit_code())

func record(test_name: String, passed: bool, detail: String) -> void:
	results.append({
		"name": test_name,
		"passed": passed,
		"detail": detail
	})

func test_vector_math() -> void:
	# Vector2 operations — regression-prone area in minor releases
	var a := Vector2(3.0, 4.0)
	var b := Vector2(1.0, 0.0)
	
	# Length should be exactly 5.0
	record(
		"Vector2.length()",
		abs(a.length() - 5.0) < 0.001,
		"Expected 5.0, got %.6f" % a.length()
	)
	
	# Normalized vector should have length 1.0
	var normalized := a.normalized()
	record(
		"Vector2.normalized()",
		abs(normalized.length() - 1.0) < 0.001,
		"Expected length 1.0, got %.6f" % normalized.length()
	)
	
	# Dot product: (3,4)·(1,0) = 3.0
	record(
		"Vector2.dot()",
		abs(a.dot(b) - 3.0) < 0.001,
		"Expected 3.0, got %.6f" % a.dot(b)
	)

func test_json_parsing() -> void:
	var test_cases := [
		'{"score": 1500, "level": 12, "name": "TestPlayer"}',
		'{"nested": {"value": true}, "array": [1, 2, 3]}',
		'{"special": "chars: \\\"quotes\\\" and \\\\backslash"}',
	]
	
	for i in test_cases.size():
		var json := JSON.new()
		var error := json.parse(test_cases[i])
		record(
			"JSON.parse() case %d" % i,
			error == OK and json.data is Dictionary,
			"Parse error: %s" % error_string(error) if error != OK else "Parsed successfully with %d keys" % json.data.size()
		)

func test_scene_serialization() -> void:
	# Create a minimal scene and verify round-trip serialization
	var root := Node.new()
	root.name = "TestRoot"
	
	var child := Node2D.new()
	child.name = "TestChild"
	child.position = Vector2(100.5, 200.75)
	child.rotation = 1.5708  # ~90 degrees
	child.scale = Vector2(2.0, 2.0)
	root.add_child(child)
	
	# Test that properties are preserved
	record(
		"Node2D.position precision",
		abs(child.position.x - 100.5) < 0.01 and abs(child.position.y - 200.75) < 0.01,
		"Expected (100.5, 200.75), got (%.2f, %.2f)" % [child.position.x, child.position.y]
	)
	
	record(
		"Node2D.rotation",
		abs(child.rotation - 1.5708) < 0.001,
		"Expected ~1.5708, got %.6f" % child.rotation
	)
	
	root.free()

func test_input_map_registration() -> void:
	var action_name := "__migration_test_action_7f3a"
	var event := InputEventKey.new()
	event.keycode = KEY_SPACE
	
	InputMap.add_action(action_name)
	InputMap.action_add_event(action_name, event)
	
	record(
		"InputMap.add_action()",
		InputMap.has_action(action_name),
		"Action registered: %s" % InputMap.has_action(action_name)
	)
	
	var events := InputMap.action_get_events(action_name)
	record(
		"InputMap.action_get_events()",
		events.size() == 1 and events[0] is InputEventKey,
		"Expected 1 InputEventKey, got %d event(s)" % events.size()
	)
	
	InputMap.erase_action(action_name)
	record(
		"InputMap.erase_action()",
		not InputMap.has_action(action_name),
		"Action erased: %s" % (not InputMap.has_action(action_name))
	)

func test_color_conversion() -> void:
	# Colors can serialize differently across versions
	var red := Color(1.0, 0.0, 0.0, 1.0)
	var hex := red.to_html()
	
	record(
		"Color.to_html()",
		hex == "ff0000ff",
		"Expected 'ff0000ff', got '%s'" % hex
	)
	
	var from_html := Color.html("00ff00ff")
	record(
		"Color.html()",
		abs(from_html.g - 1.0) < 0.001 and abs(from_html.a - 1.0) < 0.001,
		"Expected green (0,1,0,1), got (%.2f, %.2f, %.2f, %.2f)" % [from_html.r, from_html.g, from_html.b, from_html.a]
	)

func test_file_access_permissions() -> void:
	# Verify user:// directory is writable
	var test_path := "user://_migration_test.tmp"
	var file := FileAccess.open(test_path, FileAccess.WRITE)
	record(
		"FileAccess user:// write",
		file != null if true else FileAccess.get_open_error() == OK,
		"File opened for writing: %s" % ("OK" if file != null else error_string(FileAccess.get_open_error()))
	)
	
	if file:
		file.store_string("migration_test_4.8_beta3")
		file.close()
		
		# Read it back
		var reader := FileAccess.open(test_path, FileAccess.READ)
		if reader:
			var content := reader.get_as_text()
			reader.close()
			record(
				"FileAccess user:// read",
				content == "migration_test_4.8_beta3",
				"Read back: '%s'" % content
			)
		
		DirAccess.remove_absolute(test_path)

func print_summary() -> void:
	var passed_count := 0
	for result in results:
		var icon := "✅" if result["passed"] else "❌"
		print("%s  %s: %s" % [icon, result["name"], result["detail"]])
		if result["passed"]:
			passed_count += 1
	
	print("\n────────────────────────────────────────────")
	print("Results: %d / %d tests passed" % [passed_count, results.size()])
	
	if passed_count < results.size():
		var failed := results.size() - passed_count
		print("⚠️  %d test(s) failed." % failed)
		print("   Compare output against Godot 4.7.1 stable.")
		print("   File regressions: https://github.com/godotengine/godot/issues")
	else:
		print("✅  All core behaviors match expected values.")
		print("   This does NOT guarantee full compatibility,")
		print("   but it confirms fundamental APIs are stable.")

func get_exit_code() -> int:
	for result in results:
		if not result["passed"]:
			return 1
	return 0

Exécutez-le dans les deux builds et comparez la sortie :

# In Godot 4.7.1 stable:
godot --headless -s migration_test.gd > results_stable.txt

# In Godot 4.8 beta 3:
godot --headless -s migration_test.gd > results_beta3.txt

# Compare:
diff results_stable.txt results_beta3.txt

Si le diff montre des résultats réussite/échec identiques, vos comportements fondamentaux ont survécu à la mise à niveau. Les divergences pointent directement vers le changement d'API.


Trois pièges de migration à rechercher

Piège 1 : Analyse GDScript et inférence de type

Le parseur GDScript est mis à jour à chaque version mineure. Dans la 4.8, surveillez ces domaines spécifiques :

  • Coercition de tableaux typés — Le comportement de conversion entre Array[int] et PackedByteArray a été resserré dans les versions récentes. Si votre code repose sur la conversion implicite entre tableaux typés et tableaux packés, testez explicitement ces chemins de code.
  • Ordre d'évaluation des scripts @tool — Les EditorScripts qui dépendent d'un ordre d'initialisation spécifique peuvent se comporter différemment si le timing de l'évaluateur a changé.
  • Syntaxe de connexion des signaux — Le modèle signal.connect(callable) est stable, mais les connexions basées sur des chaînes ("signal_name") sont dépréciées et peuvent émettre des avertissements ou des erreurs.
# Check your project for these patterns:

# AVOID — string-based signal connections (deprecated):
# node.connect("body_entered", self, "_on_body_entered")

# USE — callable-based connections:
node.body_entered.connect(_on_body_entered)

# AVOID — implicit typed array coercion:
var bytes: PackedByteArray = [72, 101, 108]  # May warn in 4.8

# USE — explicit construction:
var bytes: PackedByteArray = PackedByteArray([72, 101, 108])

Approche de détection : Recherchez ces modèles dans votre projet avec grep :

# Find deprecated signal connections
grep -rn '\.connect("' --include="*.gd" .

# Find string-based export hints
grep -rn 'export(' --include="*.gd" .

# Find untyped variables that may trigger new warnings
grep -rn 'var [a-z_]* =' --include="*.gd" . | grep -v ':'

Piège 2 : Métadonnées des fichiers de scène

Lorsque vous ouvrez un fichier .tscn dans l'éditeur de la 4.8 bêta 3, la scène est réenregistrée avec des métadonnées mises à jour. Le nombre de load_steps, les valeurs uid et l'ordre des sections [resource] peuvent changer. C'est généralement sans danger, mais cela casse le git blame et aggrave les conflits de fusion.

Avant d'ouvrir des scènes dans la bêta 3 :

  1. Exportez les hash actuels de vos scènes : git ls-files '*.tscn' | xargs md5sum > scene_hashes_stable.txt
  2. Ouvrez le projet dans la bêta 3, parcourez quelques scènes, enregistrez
  3. Réexportez : git ls-files '*.tscn' | xargs md5sum > scene_hashes_beta.txt
  4. Comparez : diff scene_hashes_stable.txt scene_hashes_beta.txt

Si seules les métadonnées ont changé (le contenu de vos scènes semble identique mais les fichiers sont différents), vous savez à quoi vous attendre lors de la migration vers la version stable.

Piège 3 : Dérive de la référence de simulation physique

Les changements physiques sont la catégorie de régression la plus sournoise. Rien ne plante. Aucune erreur n'apparaît. Votre personnage semble simplement 2 % plus lent, ou votre projectile retombe 5 pixels plus bas qu'avant. Les joueurs ne le remarqueront peut-être pas. Votre équipe QA ne le détectera lors des tests de sensation que si elle est attentive.

La solution — une scène de test de régression physique :

extends Node2D

## Physics Regression Test — Godot 4.8 Beta 3
## Attach this to a Node2D in an empty scene.
## Run the scene and compare the printed positions
## against values from your stable build.

func _ready() -> void:
	await get_tree().create_timer(0.1).timeout
	run_gravity_test()
	run_velocity_test()

func run_gravity_test() -> void:
	var body := CharacterBody2D.new()
	var collision := CollisionShape2D.new()
	var shape := RectangleShape2D.new()
	shape.size = Vector2(16, 32)
	collision.shape = shape
	body.add_child(collision)
	add_child(body)
	
	body.position = Vector2(200, 100)
	body.velocity = Vector2.ZERO
	
	# Simulate 1 second of free fall (60 physics frames)
	for i in range(60):
		body.velocity.y += body.get_gravity().y * (1.0 / 60.0)
		body.move_and_slide()
		await get_tree().physics_frame
	
	var fall_distance := body.position.y - 100.0
	print("[Gravity Test] Fell %.2f pixels in 60 frames" % fall_distance)
	print("  Compare against stable build — deviation > 1.0 px = investigate")
	print("  Expected range: 489.0 - 491.0 (default gravity 980 px/s²)")
	
	body.queue_free()

func run_velocity_test() -> void:
	var body := CharacterBody2D.new()
	var collision := CollisionShape2D.new()
	var shape := RectangleShape2D.new()
	shape.size = Vector2(16, 32)
	collision.shape = shape
	body.add_child(collision)
	add_child(body)
	
	body.position = Vector2(50, 300)
	body.velocity = Vector2(300, 0)
	
	# Move horizontally for 2 seconds
	for i in range(120):
		body.velocity = Vector2(300, 0)
		body.move_and_slide()
		await get_tree().physics_frame
	
	var horizontal_distance := body.position.x - 50.0
	print("[Velocity Test] Moved %.2f pixels horizontally in 120 frames" % horizontal_distance)
	print("  Expected: ~600.0 px (300 px/s × 2 seconds)")
	print("  Deviation > 2.0 px = physics engine behavior changed")
	
	body.queue_free()

Enregistrez la sortie de la 4.7.x stable. Enregistrez celle de la 4.8 bêta 3. Si les chiffres diffèrent de plus de 1 à 2 pixels, vous avez une régression physique qui mérite d'être signalée.


Tester les builds exportées — Les parties que la plupart des devs ignorent

Les tests dans l'éditeur détectent les problèmes de script et de scène. Les builds exportées ont leur propre catégorie de problèmes :

Plateforme Domaine d'attention Piège courant en 4.x
Windows Compilation des shaders, chargement DLL Cache de shaders invalidé entre les versions de Godot
Linux Compatibilité pilotes Vulkan Différences de pilotes Mesa avec les fonctionnalités Vulkan 1.3
Android Latence de saisie tactile, cycle de vie de l'application La pause/reprise de l'activité perd l'état dans les versions récentes d'Android
Web Limites de mémoire, performances GDScript Les builds compilées avec Emscripten ont un plafond mémoire plus strict
WebXR Transitions en mode immersif Le nettoyage de sortie de session peut différer du XR de bureau

Le test de compatibilité d'export :

# Export your project for each target platform
# Save the export output with the Godot version in the filename

# Windows
godot --headless --export-release "Windows Desktop" build/godot471_win.exe
# Then repeat with beta 3:
godot --headless --export-release "Windows Desktop" build/godot48b3_win.exe

# Android APK
godot --headless --export-release "Android" build/godot471_android.apk
godot --headless --export-release "Android" build/godot48b3_android.apk

Exécutez chaque build et effectuez une boucle de gameplay standard de 10 minutes. Faites attention aux temps de chargement, au framerate, et à l'apparition éventuelle d'artefacts visuels absents de la version stable.


Signaler des régressions qui seront corrigées

Le suivi de problèmes de Godot reçoit des centaines de rapports par version. Ceux qui obtiennent rapidement un développeur assigné partagent une structure :

## Summary
CharacterBody2D.move_and_slide() produces 3.2% less vertical displacement 
on slopes steeper than 45° compared to Godot 4.7.1 stable.

## Environment
- OS: Windows 11, NVIDIA RTX 3070, driver 551.86
- Godot build: 4.8-beta3 (build hash from Help → Copy Build Info)
- Rendering method: Forward+

## Minimal Reproduction
1. Open attached project
2. Run scene `test_slope_regression.tscn`
3. Observe printed displacement: 456.2 px (expected: 471.3 px)

## Regression Marker
Verified behavior in Godot 4.7.1 stable: displacement is 471.3 px.
Likely introduced between commit [first known good] and [first known bad].

Éléments clés qui rendent les rapports exploitables :

  • Des chiffres précis, pas « semble plus lent »
  • Le hash de la build depuis le menu Aide, pas seulement « bêta 3 »
  • Un seul fichier de scène qui reproduit le problème sans tout votre projet
  • Une comparaison avec la version stable montrant les valeurs exactes attendues vs réelles
  • Les informations GPU et pilote car les problèmes de rendu dépendent du matériel

Si vous voulez bisecter le commit exact, clonez la source de Godot et utilisez git bisect. C'est le moyen le plus efficace d'identifier quand une régression a été introduite et accélère considérablement les correctifs.


Bonnes pratiques pour votre migration vers Godot 4.8

  1. Conservez un MIGRATION-4.8.md dans votre dépôt — Chaque changement d'API rencontré, chaque différence de comportement, documentez-les avec la ligne GDScript et le contournement. Quand la version stable sortira, vous aurez un guide de migration complet et spécifique à votre projet au lieu de redécouvrir les problèmes.

  2. Testez les allers-retours sauvegarde/chargement — Si votre jeu sérialise les données des joueurs avec JSON.stringify() ou ResourceSaver.save(), vérifiez que les données écrites avec la 4.7.x se chargent correctement dans la 4.8 bêta 3 et vice versa. Les changements de format de sérialisation peuvent corrompre silencieusement la progression des joueurs.

  3. Vérifiez la compatibilité des addons — Si vous utilisez des plugins GDExtension ou des addons GDScript de la bibliothèque d'actifs, consultez leurs dépôts GitHub pour les notes de compatibilité 4.8. De nombreux mainteneurs d'addons ne testent pas les bêtas sauf si les développeurs le demandent. Soyez ce développeur.

  4. Testez votre pipeline CI — Si votre projet a des builds automatisés, mettez à jour la version de Godot dans votre runner CI vers la 4.8 bêta 3 et exécutez votre pipeline complet. Les scripts de build qui référencent des chemins d'éditeur ou des flags CLI peuvent casser si ces API ont changé.

  5. Validation de rendu séparée — Exécutez votre jeu avec --rendering-driver vulkan, --rendering-driver opengl3 et --rendering-driver d3d12 (Windows) si applicable. Le comportement des pilotes de rendu diverge entre les versions plus que tout autre sous-système.


Quand votre stack backend doit survivre à la mise à niveau

Les migrations de moteur affectent plus que le code de gameplay. Si votre jeu stocke les données des joueurs à distance — jetons d'authentification, progression sauvegardée, soumissions de classement — le format de sérialisation entre votre client et votre backend doit rester cohérent.

Considérez ce scénario : Godot 4.8 modifie la façon dont JSON.stringify() gère la précision des nombres à virgule flottante dans les valeurs Dictionary. Votre charge utile de sauvegarde cloud passe de {"x": 100.5} à {"x": 100.499999}. Votre backend s'en moque, mais si vous faites de la résolution de conflits côté client (comparaison des versions locales et distantes des données de sauvegarde), cette différence epsilon provoque de faux conflits de fusion.

C'est pourquoi les systèmes de sauvegarde sensibles aux révisions comptent lors des migrations de moteur. horizOn fournit une sauvegarde cloud liée au compte avec des lectures et écritures sensibles aux révisions, où le client gère la résolution des conflits. Lorsque le comportement de sérialisation de votre moteur change entre les versions, un système sensible aux révisions évite les conflits fantômes qu'une comparaison basée sur l'égalité déclencherait.


Vos prochaines étapes

  1. Téléchargez Godot 4.8 bêta 3 depuis la snapshot officielle ou essayez l'éditeur web pour un test rapide
  2. Créez votre branche de test et exécutez les scripts de test de migration ci-dessus
  3. Ouvrez vos scènes les plus complexes et vérifiez qu'elles semblent et se comportent toujours correctement
  4. Exportez et testez sur vos plateformes cibles — pas seulement dans l'éditeur
  5. Signalez les régressions sur le suivi de problèmes GitHub de Godot avec des étapes de reproduction minimales

La version stable arrive, que vous testiez ou non. Les développeurs qui valident avec les bêtas sortent le jour même. Les autres devront déboguer des problèmes de production pendant leur fenêtre de lancement.


Source : Dev snapshot : Godot 4.8 bêta 3