CommunityProgramación y desarrollogithub.com

rendimiento-godot

Encuentra y soluciona problemas de rendimiento en Godot 4.7: perfiles y monitores, presupuestos de fotograma, MultiMesh y API de servidor para miles de objetos, WorkerThreadPool y grupos de hilos, rutas calientes GDScript/C#, llamadas de dibujo, luces, LOD, costo de física, carga y fugas de memoria. Úsalo cuando el juego se traba, los FPS son bajos, la carga es lenta o la memoria crece.

¿Qué es rendimiento-godot?

Esta skill te ayuda a diagnosticar y optimizar el rendimiento en Godot 4.7, proporcionando herramientas, métricas y patrones para mantener el juego fluido. Se enfoca en medir primero con el depurador de editor, monitores y perfiles nativos como Tracy o Perfetto, y luego aplicar estrategias precisas: reducir trabajo en CPU (desactivar procesos innecesarios, usar MultiMesh y server APIs para miles de entidades), manejar hilos de forma segura con WorkerThreadPool y thread groups, y optimizar GPU (llamadas de dibujo, luces, LOD). También cubre carga eficiente de recursos, manejo de memoria y diferencias entre GDScript y C#. Funciona en la plataforma Godot 4.7 y se integra con flujos de trabajo de depuración y rendimiento del editor, así como con herramientas externas como Tracy y Perfetto.

Compatible con~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/EL4CTEO/godot-skills/tree/main/skills/godot-performance

Installed? Explore more Programación y desarrollo skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Rendimiento (4.7)

Mide primero. Nunca optimices a ciegas. Un presupuesto de 16,6 ms por fotograma (60 FPS) o 8,3 ms (120 FPS) cubre script, física, renderizado en CPU y GPU.

Herramientas

  • Depurador del editor: Profiler (funciones de script; inícialo, juega, luego ordena por tiempo propio), Visual Profiler (CPU vs GPU por pase de renderizado), Monitores (FPS, tiempo de proceso/física, objetos, nodos, nodos huérfanos, llamadas de dibujo, memoria de video), Network Profiler y instantáneas de ObjectDB (4.6+: compara dos instantáneas para encontrar fugas).
  • Código: Performance.get_monitor(Performance.TIME_PROCESS), RENDER_TOTAL_DRAW_CALLS_IN_FRAME, OBJECT_NODE_COUNT, OBJECT_ORPHAN_NODE_COUNT. Agrega los tuyos propios con Performance.add_custom_monitor(&"game/enemies", callable).
  • Perfiles nativos (4.6+): Tracy, Perfetto (Android por defecto) y Apple Instruments pueden ver fotogramas de GDScript, C# y GDExtension. Úsalos para picos de tiempo de fotograma.
  • CLI: --profiling, --gpu-profile, --print-fps, --benchmark. Usa --fixed-fps 60 --quit-after N para ejecuciones repetibles.
  • Fugas: los nodos huérfanos son nodos eliminados del árbol pero nunca liberados. Node.print_orphan_nodes(), get_orphan_node_ids() (4.5+).

CPU: haz menos trabajo

  • Desactiva el procesamiento que no necesitas: set_process(false)/set_physics_process(false) cuando está inactivo. VisibleOnScreenEnabler2D/3D pausa actores fuera de pantalla. Los temporizadores superan al sondeo por fotograma.
  • El código por fotograma es la ruta caliente. Guarda nodos en caché con @onready/_Ready. Usa literales StringName (&"jump") para acciones, grupos y nombres de método. No llames get_tree().get_nodes_in_group() cada fotograma. Usa GDScript tipado (los opcodes tipados son más rápidos).
  • Las señales y call_group son baratas para eventos, pero no las emitas por entidad por fotograma para miles de entidades.
  • Miles de cosas: deja de usar un Nodo por cosa.
    • Visuales: MultiMeshInstance3D/2D (una llamada de dibujo; escribe multimesh.buffer en bloque), o partículas GPU.
    • Lógica: arreglos simples y estructuras en un script administrador (orientado a datos), no un script por entidad.
    • Física: cuerpos y áreas de PhysicsServer2D/3D sin nodos, o un lote de raycasts por fotograma.
    • Renderizado sin nodos: instancias de RenderingServer y elementos de lienzo.
  • Física: mantén physics_ticks_per_second en 60 a menos que el juego necesite más. Usa formas primitivas simples y evita ConcavePolygonShape3D en cuerpos en movimiento. Las capas y máscaras reducen las comprobaciones de pares. Deja que los cuerpos duerman (can_sleep).

Hilos

  • WorkerThreadPool.add_task(callable) / add_group_task(callable, count) (paralelo para), luego wait_for_task_completion(id). Esto es mejor que Thread crudo para la mayoría de los trabajos.
  • Regla del árbol de escena: los nodos dentro del árbol solo pueden ser tocados desde el hilo principal, a menos que estén en un grupo de hilos (process_thread_group = PROCESS_THREAD_GROUP_SUB_THREAD, que procesa ese subárbol en paralelo y usa call_deferred_thread_group para llamadas entre grupos). Desde hilos de trabajo, devuelve resultados con call_deferred / Callable.call_deferred(). Afirma con Thread.is_main_thread() (4.7).
  • Datos compartidos: protégelos con Mutex, o dale a cada trabajador su propio segmento y combínalos en el hilo principal.
  • Carga en segundo plano: ResourceLoader.load_threaded_request(path, "", true) usa sub-hilos para las dependencias.

GPU y renderizado

  • Llamadas de dibujo: fusiona mallas estáticas y comparte materiales, porque cada material único en una superficie de malla agrega llamadas. Usa MultiMesh para repeticiones y atlas de textura en 2D.
  • Luces y sombras son los consumidores habituales de GPU. Usa pocas luces omnidireccionales y de foco con sombras, mantén directional_shadow_max_distance pequeño y hornea la iluminación estática (LightmapGI).
  • Sobredibujado: grandes partículas transparentes y alfa de pantalla completa. Usa alfa scissor o hash para follaje y quads de partículas más pequeños.
  • Escala de detalle: LOD (mesh_lod_threshold), visibility_range_*, oclusión de geometría y escalado de resolución (FSR, MetalFX) en GPUs débiles. Elige el renderizador correcto: Mobile o Compatibility para gama baja (ver godot-3d-rendering).
  • Tirones de shader: horneado de shaders (opción de exportación), menos variantes de material.

Carga y memoria

  • preload carga al cargar el script y bloquea. Úsalo solo para cosas pequeñas que siempre necesites. load es perezoso. La carga con hilos es adecuada para niveles.
  • ResourceLoader guarda en caché los recursos. Reutilízalos y no hagas duplicate() de recursos compartidos a menos que necesites estado por instancia.
  • Texturas: importación comprimida en VRAM (por defecto para 3D; actívala para 2D grande). Mipmaps para 3D. Limita el tamaño máximo por plataforma. Audio: streams Ogg para pistas largas.
  • Libera lo que creas: queue_free() y pools para balas. Vigila que el conteo de huérfanos se mantenga estable.

GDScript vs C#

  • GDScript está bien para jugabilidad. Mueve bucles matemáticos ajustados (pathfinding, procgen, simulaciones) a C# o GDExtension, y aún así agrupa las llamadas a la API.
  • C#: evita asignaciones por fotograma (LINQ, cierres, formato de cadenas, new Godot.Collections.Array). Cada llamada a la API de Godot cruza un límite de interoperabilidad, así que agrúpalas. Los arreglos empaquetados se copian cuando cruzan ese límite.

Presupuestos de plataforma (regla general)

Móvil: < 100–150 llamadas de dibujo, 1 luz con sombra, renderizador Mobile o Compatibility, objetivo 30–60 FPS. Web: renderizador Compatibility, un solo hilo a menos que la exportación use hilos (necesita cabeceras de aislamiento de origen cruzado), y mantén las descargas pequeñas. Escritorio o consola: Forward+, perfila en el hardware de especificaciones mínimas.

Perf HUD + monitores personalizados, MultiMesh para multitudes, tarea de grupo paralela, balas del lado del servidor (compilado por las pruebas): references/patterns.md

Individual skills in this repo

This repo contains 4 individual skills — each has its own dedicated page.

Skills relacionados