CommunityCodierung & Entwicklunggithub.com

godot-performance

Finde und behebe Performance-Probleme in Godot 4.7 – Profiler und Monitore, Frame-Budgets, MultiMesh und Server-APIs für tausende Objekte, WorkerThreadPool und Thread-Gruppen, GDScript/C#-Hotpaths, Draw Calls, Lichter, LOD, Physik-Kosten, Laden und Speicherlecks. Verwende dies, wenn das Spiel ruckelt, die FPS niedrig sind, das Laden langsam ist oder der Speicher wächst.

Was ist godot-performance?

Dieses Skill hilft Entwicklern, Performance-Probleme in Godot 4.7 systematisch zu identifizieren und zu beheben. Es betont den Grundsatz „Erst messen, dann optimieren“ und gibt klare Budgets für 60 FPS (16,6 ms pro Frame) und 120 FPS (8,3 ms). Du erfährst, wie du die eingebauten Profiler und Monitore des Editors nutzt, um Engpässe in Skripten, Physik, Rendering und Speicher zu finden. Das Skill bietet praktische Strategien – von der Minimierung der CPU-Arbeit über die Optimierung von Tausenden von Objekten mit MultiMesh und Serverschnittstellen bis hin zur richtigen Nutzung von Threads und Hintergrundladen. Es behandelt plattformspezifische Budgets für Mobilgeräte, Webbrowser und Konsolen sowie häufige Fallstricke wie Orphan-Nodes, zu viele Draw Calls, teure Lichter und ineffiziente GDScript/C#-Hotpaths. Du findest auch Hinweise zu nativen Profilern wie Tracy, Perfetto und Apple Instruments sowie zu CLI-Flags für reproduzierbare Benchmarks. Es ist eine umfassende Referenz, um Spiele flüssiger, reaktionsschneller und speicherschonender zu machen.

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

Installed? Explore more Codierung & Entwicklung skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Performance (4.7)

Zuerst messen. Niemals blind optimieren. Ein Budget von 16,6 ms pro Frame (60 FPS) oder 8,3 ms (120 FPS) deckt Skript, Physik, Rendering auf CPU und GPU ab.

Werkzeuge

  • Editor-Debugger: Profiler (Skriptfunktionen; starten, abspielen, dann nach Eigenzeit sortieren), Visual Profiler (CPU vs. GPU pro Renderdurchlauf), Monitore (FPS, Prozess-/Physikzeit, Objekte, Nodes, Orphan-Nodes, Draw Calls, Videospeicher), Netzwerk-Profiler und ObjectDB-Snapshots (4.6+: zwei Snapshots diffs, um Lecks zu finden).
  • Code: Performance.get_monitor(Performance.TIME_PROCESS), RENDER_TOTAL_DRAW_CALLS_IN_FRAME, OBJECT_NODE_COUNT, OBJECT_ORPHAN_NODE_COUNT. Eigene hinzufügen mit Performance.add_custom_monitor(&"game/enemies", callable).
  • Native Profiler (4.6+): Tracy, Perfetto (Android-Standard) und Apple Instruments können GDScript-, C#- und GDExtension-Frames sehen. Verwende sie für Frame-Zeit-Spitzen.
  • CLI: --profiling, --gpu-profile, --print-fps, --benchmark. Verwende --fixed-fps 60 --quit-after N für wiederholbare Läufe.
  • Lecks: Orphan-Nodes sind Nodes, die aus dem Baum entfernt, aber nie freigegeben wurden. Node.print_orphan_nodes(), get_orphan_node_ids() (4.5+).

CPU: Weniger Arbeit machen

  • Nicht benötigte Verarbeitung deaktivieren: set_process(false)/set_physics_process(false) im Leerlauf. VisibleOnScreenEnabler2D/3D pausiert außerschirmige Akteure. Timer sind besser als Pro-Frame-Abfragen.
  • Code pro Frame ist der Hotpath. Nodes in @onready/_Ready cachen. StringName-Literale (&"jump") für Aktionen, Gruppen und Methodennamen verwenden. Nicht jeden Frame get_tree().get_nodes_in_group() aufrufen. Typisiertes GDScript verwenden (typisierte Opcodes sind schneller).
  • Signale und call_group sind billig für Ereignisse, aber sie nicht pro Entität pro Frame für tausende Entitäten senden.
  • Tausende von Dingen: Nicht einen Node pro Ding verwenden.
    • Visuelles: MultiMeshInstance3D/2D (ein Draw Call; multimesh.buffer in Bulk schreiben) oder GPU-Partikel.
    • Logik: Einfache Arrays und Structs in einem Manager-Skript (datenorientiert), nicht ein Skript pro Entität.
    • Physik: PhysicsServer2D/3D-Bodies und Areas ohne Nodes, oder ein Raycast-Batch pro Frame.
    • Rendering ohne Nodes: RenderingServer-Instanzen und Canvas-Items.
  • Physik: physics_ticks_per_second bei 60 belassen, es sei denn, das Spiel braucht mehr. Einfache Primitive-Formen verwenden und ConcavePolygonShape3D bei bewegten Bodies vermeiden. Layer und Masken reduzieren Paarprüfungen. Bodies schlafen lassen (can_sleep).

Threads

  • WorkerThreadPool.add_task(callable) / add_group_task(callable, count) (Parallel-für), dann wait_for_task_completion(id). Das ist besser als rohe Thread für die meisten Jobs.
  • Szenenbaum-Regel: Nodes innerhalb des Baums dürfen nur vom Haupt-Thread berührt werden, es sei denn, sie befinden sich in einer Thread-Gruppe (process_thread_group = PROCESS_THREAD_GROUP_SUB_THREAD, die diesen Teilbaum parallel verarbeitet und call_deferred_thread_group für gruppenübergreifende Aufrufe verwendet). Von Arbeits-Threads aus Ergebnisse mit call_deferred / Callable.call_deferred() zurückgeben. Überprüfung mit Thread.is_main_thread() (4.7).
  • Gemeinsame Daten: mit Mutex schützen oder jedem Arbeiter sein eigenes Slice geben und im Haupt-Thread zusammenführen.
  • Hintergrundladen: ResourceLoader.load_threaded_request(path, "", true) verwendet Sub-Threads für Abhängigkeiten.

GPU und Rendering

  • Draw Calls: Statische Meshes zusammenführen und Materialien teilen, da jedes eindeutige Material auf einer Mesh-Oberfläche Aufrufe hinzufügt. MultiMesh für Wiederholungen und Textur-Atlanten in 2D verwenden.
  • Lichter und Schatten sind die üblichen GPU-Fresser. Wenige beschattete Omni- und Spot-Lichter verwenden, directional_shadow_max_distance klein halten und statische Beleuchtung baken (LightmapGI).
  • Überzeichnung: Große transparente Partikel und Vollbild-Alpha. Alpha-Scissor oder Hash für Laub und kleinere Partikel-Quadrate verwenden.
  • Detailstaffelung: LOD (mesh_lod_threshold), visibility_range_*, Occlusion Culling und Auflösungsskalierung (FSR, MetalFX) auf schwachen GPUs. Den richtigen Renderer wählen: Mobile oder Compatibility für schwache Hardware (siehe godot-3d-rendering).
  • Shader-Ruckler: Shader-Baker (Export-Option), weniger Materialvarianten.

Laden und Speicher

  • preload lädt beim Skript-Laden und blockiert. Nur für kleine Dinge verwenden, die man immer braucht. load ist faul. Thread-gesteuertes Laden eignet sich für Level.
  • ResourceLoader cached Ressourcen. Wiederverwenden und duplicate() von gemeinsam genutzten Ressourcen vermeiden, es sei denn, du benötigst pro-Instanz-Zustand.
  • Texturen: VRAM-komprimiert importieren (Standard für 3D; für große 2D aktivieren). Mipmaps für 3D. Maximale Größe pro Plattform begrenzen. Audio: Ogg-Streams für lange Tracks.
  • Freigeben, was du spawnst: queue_free() und Pools für Kugeln. Beobachte, dass die Orphan-Zahl flach bleibt.

GDScript vs. C#

  • GDScript ist gut für Gameplay. Enge Mathe-Schleifen (Pfadfindung, Procgen, Simulationen) nach C# oder GDExtension verschieben und trotzdem API-Aufrufe bündeln.
  • C#: Pro-Frame-Allokationen vermeiden (LINQ, Closures, String-Formatierung, new Godot.Collections.Array). Jeder Godot-API-Aufruf überquert eine Interop-Grenze, also bündeln. Gepackte Arrays kopieren beim Überqueren dieser Grenze.

Plattform-Budgets (Faustregel)

Mobilgeräte: < 100–150 Draw Calls, 1 beschattetes Licht, Mobile oder Compatibility-Renderer, 30–60 FPS-Ziel. Web: Compatibility-Renderer, single-threaded, es sei denn, der Export verwendet Threads (benötigt Cross-Origin-Isolation-Header), und Downloads klein halten. Desktop oder Konsole: Forward+, auf der Minimum-Spec-Hardware profilieren.

Perf HUD + benutzerdefinierte Monitore, MultiMesh-Menge, parallele Gruppenaufgabe, serverseitige Kugeln (von den Tests kompiliert): references/patterns.md

Individual skills in this repo

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

Verwandte Skills