Volver al Blog

¿Godot 4.8 Beta 3 en camino? Ejecuta estas pruebas de migración antes de que tus escenas se rompan

Publicado el 13 de noviembre de 2026
¿Godot 4.8 Beta 3 en camino? Ejecuta estas pruebas de migración antes de que tus escenas se rompan Generado con ayuda de IA

En resumen

Ejecuta estas pruebas de migración en Godot 4.8 beta 3 y detecta regresiones antes de que tus escenas de Godot se rompan de forma inesperada.

Acaba de publicarse la instantánea de Godot 4.8 beta 3, y el equipo dice que se acerca a la fase de release candidate. Eso significa que la ventana para encontrar y reportar regresiones se está cerrando rápido. Si mantienes un proyecto de Godot — ya sea que salga el próximo mes o dentro de un año — ahora es el momento de abrir tu código en esta compilación y ver qué se rompe.

La mayoría de los desarrolladores no prueban las betas de forma sistemática. Clonan la compilación, abren su proyecto, echan un vistazo a unas pocas escenas y lo dan por bueno. Luego sale la versión estable, la física se siente diferente, los archivos de guardado se deserializan incorrectamente y un jugador se topa con un oscuro error de parsing de GDScript que nunca apareció durante el desarrollo. La solución no es una depuración heroica después del lanzamiento. Es un protocolo de pruebas repetible que detecta estos problemas ahora.

Esta guía te ofrece un flujo de trabajo concreto: un script de prueba de migración que puedes ejecutar hoy, tres trampas específicas a las que prestar atención y una estructura de reporte de regresiones que de verdad capta la atención del equipo de Godot.


Por qué la Beta 3 es tu fecha límite de pruebas

La Beta 3 es la última beta antes de que el equipo de Godot pase a los release candidates. Los release candidates son para pulir, no para descubrir que move_and_slide() se comporta de forma distinta en pendientes de más de 45°. Cuando salga la RC1, las nuevas regresiones se clasificarán como bloqueantes solo si son lo bastante graves como para retrasar el lanzamiento.

Tu trabajo durante la ventana beta es sencillo:

  • Encuentra regresiones antes de que se vuelvan invisibles en la versión estable
  • Documenta los cambios incompatibles específicos de la base de código de tu proyecto
  • Reporta errores con pasos mínimos de reproducción para que los mantenedores puedan corregirlos

El equipo de Godot estuvo en GodotFest la semana pasada y aun así publicó correcciones para los bloqueantes restantes. Ese es el ritmo. Si quieres influir en cómo será 4.8 en el lanzamiento, prueba ahora.


Configurar una rama de pruebas de migración

Antes de abrir nada en la beta 3, crea un entorno de pruebas limpio:

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

Por qué importa una rama separada: los archivos de escena de Godot (.tscn) son de texto e incluyen metadatos específicos del motor. Cuando abres una escena en 4.8 beta 3 y la guardas, el hash del archivo cambia. Si estás fusionando cambios con compañeros de equipo que usan versiones distintas de Godot, esto genera conflictos de merge difíciles de resolver. Mantén las pruebas beta aisladas.


Crear un script de prueba de migración

La mayor carencia de pruebas que tienen los desarrolladores es no tener una línea base. Abres el proyecto, «se ve bien» y sigues adelante. El problema: que se vea bien no detecta la deriva de la física, las diferencias de compilación de shaders ni los cambios de comportamiento de GDScript que solo aparecen en condiciones específicas.

Aquí tienes un script de prueba de migración que puedes incorporar a cualquier proyecto de Godot 4.x. Valida comportamientos clave del motor frente a los valores esperados:

@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

Ejecútalo en ambas compilaciones y haz un diff de la salida:

# 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 la comparación muestra resultados idénticos de aprobado/fallo, tus comportamientos clave han sobrevivido a la actualización. Las divergencias te señalan directamente el cambio de API.


Tres trampas de migración a las que prestar atención

Trampa 1: Parsing de GDScript e inferencia de tipos

El parser de GDScript recibe actualizaciones en cada versión menor. En 4.8, presta atención a estas áreas específicas:

  • Coerción de arrays tipados — el comportamiento de conversión entre Array[int] y PackedByteArray se ha endurecido en versiones recientes. Si tu código depende de la conversión implícita entre arrays tipados y arrays empaquetados, prueba esas rutas de código explícitamente.
  • Orden de evaluación de scripts @tool — los EditorScripts que dependen de un orden de inicialización específico pueden comportarse de forma distinta si cambia el momento de evaluación.
  • Sintaxis de conexión de señales — el patrón signal.connect(callable) es estable, pero las conexiones basadas en cadenas ("signal_name") están obsoletas y pueden emitir advertencias o errores.
# 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])

Método de detección: haz grep en tu proyecto para encontrar estos patrones:

# 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 ':'

Trampa 2: Metadatos de archivos de escena

Cuando abres un archivo .tscn en el editor de 4.8 beta 3, la escena se guarda de nuevo con metadatos actualizados. El recuento de load_steps, los valores uid y el orden de la sección [resource] pueden cambiar. Esto suele ser inofensivo, pero rompe el git blame y empeora los conflictos de merge.

Antes de abrir escenas en la beta 3:

  1. Exporta los hashes actuales de tus escenas: git ls-files '*.tscn' | xargs md5sum > scene_hashes_stable.txt
  2. Abre el proyecto en la beta 3, revisa algunas escenas y guarda
  3. Vuelve a exportar: git ls-files '*.tscn' | xargs md5sum > scene_hashes_beta.txt
  4. Compara: diff scene_hashes_stable.txt scene_hashes_beta.txt

Si solo cambiaron los metadatos (el contenido de tus escenas se ve igual pero los archivos son diferentes), ya sabes qué esperar cuando migres a la versión estable.

Trampa 3: Deriva de la línea base de la simulación física

Los cambios de física son la categoría de regresión más sigilosa. Nada crashea. No aparecen errores. Tu personaje simplemente se siente un 2% más lento, o el arco de tu proyectil cae 5 píxeles más abajo que antes. Los jugadores quizá no lo noten. Tu equipo de QA solo lo detectará en las pruebas de sensación si presta atención.

La solución: una escena de prueba de regresión de física:

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()

Registra la salida de la estable 4.7.x. Regístrala también desde 4.8 beta 3. Si los números difieren en más de 1-2 píxeles, tienes una regresión de física que vale la pena reportar.


Probar las compilaciones exportadas: lo que la mayoría de los desarrolladores omiten

Las pruebas en el editor detectan problemas de scripting y escenas. Las compilaciones exportadas tienen su propia clase de problemas:

Plataforma Área de enfoque Error común en 4.x
Windows Compilación de shaders, carga de DLL Caché de shaders invalidada entre versiones de Godot
Linux Compatibilidad con drivers Vulkan Diferencias del driver Mesa con funciones de Vulkan 1.3
Android Latencia de entrada táctil, ciclo de vida de la app La pausa/reanudación de la Activity pierde estado en versiones recientes de Android
Web Límites de memoria, rendimiento de GDScript Las compilaciones con Emscripten tienen un límite de memoria más estricto
WebXR Transiciones de modo inmersivo La limpieza al salir de la sesión puede diferir de la XR de escritorio

La prueba de compatibilidad de exportación:

# 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

Ejecuta cada compilación y realiza un bucle de juego estándar de 10 minutos. Presta atención a los tiempos de carga, la tasa de fotogramas y si aparece algún artefacto visual que no estuviera en la versión estable.


Reportar regresiones que se corrigen

El rastreador de incidencias de Godot recibe cientos de informes por versión. Los que consiguen que se asigne un desarrollador rápidamente comparten una estructura:

## 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].

Elementos clave que hacen que los informes sean accionables:

  • Números específicos, no «parece más lento»
  • Hash de la compilación desde el menú Ayuda, no solo «beta 3»
  • Un único archivo de escena que reproduzca el problema sin todo tu proyecto
  • Comparación con la estable que muestre los valores exactos esperados frente a los reales
  • Información de GPU y driver, ya que los problemas de renderizado dependen del hardware

Si quieres hacer bisect del commit exacto, clona el código fuente de Godot y usa git bisect. Es la forma más eficiente de identificar cuándo se introdujo una regresión y acelera enormemente las correcciones.


Buenas prácticas para tu migración a Godot 4.8

  1. Mantén un MIGRATION-4.8.md en tu repositorio — documenta cada cambio de API que encuentres y cada diferencia de comportamiento con la línea de GDScript y la solución alternativa. Cuando salga la versión estable, tendrás una guía de migración completa y específica de tu proyecto en lugar de redescubrir los problemas.

  2. Prueba los ciclos de guardado/carga — si tu juego serializa datos del jugador con JSON.stringify() o ResourceSaver.save(), verifica que los datos escritos con 4.7.x se carguen correctamente en 4.8 beta 3 y viceversa. Los cambios de formato en la serialización pueden corromper silenciosamente el progreso del jugador.

  3. Comprueba la compatibilidad de los addons — si usas plugins GDExtension o addons de GDScript de la Asset Library, revisa sus repositorios de GitHub para ver notas de compatibilidad con 4.8. Muchos mantenedores de addons no prueban contra betas a menos que los desarrolladores lo pidan. Sé ese desarrollador.

  4. Prueba tu pipeline de CI — si tu proyecto tiene compilaciones automatizadas, actualiza la versión de Godot en tu runner de CI a 4.8 beta 3 y ejecuta todo tu pipeline. Los scripts de compilación que referencian rutas del editor o flags de CLI pueden romperse si esas APIs cambiaron.

  5. Validación de renderizado por separado — ejecuta tu juego con --rendering-driver vulkan, --rendering-driver opengl3 y --rendering-driver d3d12 (Windows) si corresponde. El comportamiento de los drivers de renderizado diverge entre versiones más que cualquier otro subsistema.


Cuando tu stack de backend necesita sobrevivir a la actualización

Las migraciones del motor afectan a más que al código del juego. Si tu juego almacena datos del jugador de forma remota — tokens de autenticación, progreso guardado, envíos a la tabla de clasificación — el formato de serialización entre tu cliente y tu backend debe mantenerse consistente.

Considera este escenario: Godot 4.8 cambia cómo JSON.stringify() maneja la precisión de punto flotante en valores de Dictionary. Tu payload de guardado en la nube pasa de {"x": 100.5} a {"x": 100.499999}. A tu backend no le importa, pero si haces resolución de conflictos en el cliente (comparando versiones locales y remotas de los datos guardados), esa diferencia épsilon causa conflictos de merge espurios.

Por eso los sistemas de guardado conscientes de la revisión importan durante las migraciones del motor. horizOn ofrece Cloud Save vinculado a la cuenta con lecturas y escrituras conscientes de la revisión, donde el cliente maneja la resolución de conflictos. Cuando el comportamiento de serialización de tu motor cambia entre versiones, un sistema consciente de la revisión evita los conflictos fantasma que provocaría una comparación basada en igualdad.


Tus próximos pasos

  1. Descarga Godot 4.8 beta 3 desde la instantánea oficial o prueba el editor web para hacer un smoke test rápido
  2. Crea tu rama de pruebas y ejecuta los scripts de prueba de migración anteriores
  3. Abre tus escenas más complejas y verifica que sigan viéndose y comportándose correctamente
  4. Exporta y prueba en tus plataformas objetivo, no solo en el editor
  5. Reporta regresiones en el rastreador de incidencias de Godot en GitHub con pasos mínimos de reproducción

La versión estable llegará tanto si pruebas como si no. Los desarrolladores que validan contra las betas lanzan el primer día. El resto termina depurando problemas de producción durante su ventana de lanzamiento.


Fuente: Instantánea de desarrollo: Godot 4.8 beta 3