Skip to content
Skills Library
Programming · Testing

godot-performance-optimization

/godot-performance-optimization

Expert blueprint for performance profiling and optimization (frame drops, memory leaks, draw calls) using Godot Profiler, object pooling, visibility culling, and bottleneck identification. Use when diagnosing lag, optimizing for target FPS, or reducing memory usage. Keywords profiling, Godot Profiler, bottleneck, object pooling, VisibleOnScreenNotifier, draw calls, MultiMesh.

Repository
dotfiles ↗
Licence
MIT
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
13
Scripts
0
HTML comments
0
URLs in SKILL.md
1
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Expert blueprint for performance profiling and optimization (frame drops, memory leaks, draw calls) using Godot Profiler, object pooling, visibility culling, and bottleneck identification. Use when diagnosing lag, optimizing for target FPS, or reducing memory usage. Keywords profiling, Godot Profiler, bottleneck, object pooling, VisibleOnScreenNotifier, draw calls, MultiMesh.

Original author description

Expert blueprint for performance profiling and optimization (frame drops, memory leaks, draw calls) using Godot Profiler, object pooling, visibility culling, and bottleneck identification. Use when diagnosing lag, optimizing for target FPS, or reducing memory usage. Keywords profiling, Godot Profiler, bottleneck, object pooling, VisibleOnScreenNotifier, draw calls, MultiMesh.

How it works

  1. Available Scripts
  2. NEVER Do in Performance Optimization
  3. Common Optimizations
  4. Reference
Original SKILL.md headings · 105 lines, 538 words
SKILL.md preview
---
name: godot-performance-optimization
description: "Expert blueprint for performance profiling and optimization (frame drops, memory leaks, draw calls) using Godot Profiler, object pooling, visibility culling, and bottleneck identification. Use when diagnosing lag, optimizing for target FPS, or reducing memory usage. Keywords profiling, Godot Profiler, bottleneck, object pooling, VisibleOnScreenNotifier, draw calls, MultiMesh."
---

# Performance Optimization

Profiler-driven analysis, object pooling, and visibility culling define optimized game performance.

## Available Scripts

### [worker_thread_pool_manager.gd](scripts/worker_thread_pool_manager.gd)
Expert logic for offloading heavy computation to Godot 4's WorkerThreadPool for multi-threaded processing.

### [object_pool_system.gd](scripts/object_pool_system.gd)
Minimal allocation strategy using node visibility and process toggling instead of constant instantiation.

### [rendering_server_direct.gd](scripts/rendering_server_direct.gd)
Bypassing the SceneTree logic for massive canvas item rendering directly via the RenderingServer.

### [low_level_physics_query.gd](scripts/low_level_physics_query.gd)
High-performance direct physics space state queries, faster than using RayCast nodes for hundreds of checks.

### [custom_monitor_profiler.gd](scripts/custom_monitor_profiler.gd)
Implementation of real-time performance monitoring using Performance.get_monitor() for bottleneck detection.

### [manual_culling_logic.gd](scripts/manual_culling_logic.gd)
Disabling off-screen logic manually using VisibilityNotifiers to cull CPU-heavy processing.

### [shared_resource_strategy.gd](scripts/shared_resource_strategy.gd)
Expert management of Local-to-Scene vs Shared resources to balance memory usage and unique instance states.

### [texture_array_batching.gd](scripts/texture_array_batching.gd)
Reducing draw calls and state changes by utilizing TextureArrays for multi-item shader-based batching.

### [multimesh_optimizer.gd](scripts/multimesh_optimizer.gd)
Rendering thousands of animated mesh instances via hardware instancing (MultiMeshInstance3D).

### [navigation_agent_optimization.gd](scripts/navigation_agent_optimization.gd)
Staggered path update strategy for massive AI crowds to prevent pathfinding bottlenecks in a single frame.

## NEVER Do in Performance Optimization

- **NEVER optimize without profiling first** — "I think physics is slow" without data? Premature optimization. ALWAYS use Debug → Profiler (F3) to identify actual bottleneck [20].
- **NEVER use `print()` in release builds** — `print()` every frame = file I/O bottleneck + log spam. Use `@warning_ignore` or conditional `if OS.is_debug_build():` [21].
- **NEVER ignore `VisibleOnScreenNotifier2D` for off-screen entities** — Enemies processing logic off-screen = wasted CPU. Disable `set_process(false)` when `screen_exited` [22].
- **NEVER instantiate nodes in hot loops** — `for i in 1000: var bullet = Bullet.new()` = 1000 allocations. Use object pools, reuse instances [23].
- **NEVER use `get_node()` in `_process()`** — Calling `get_node("Player")` 60x/sec = tree traversal spam. Cache in `@onready var player := $Player` [24].
- **NEVER forget to batch draw calls** — 1000 unique sprites = 1000 draw calls. Use TextureAtlas (sprite sheets) + MultiMesh for instanced rendering [25].
- **NEVER block the main thread for heavy operations** — Avoid `OS.delay_msec()` or long synchronous data processing. Use `WorkerThreadPool` to keep framerates steady.
- **NEVER use complex collision shapes for physics queries** — High-poly convex shapes are expensive to resolve. Prefer simplified primitives (Circle, Rectangle, Box).
- **NEVER forget to disconnect local lambda signals** — Anonymous lambdas connected to global signals can cause memory leaks if the capturing object is freed.
- **NEVER use large textures without compression** — VRAM is limited. Use VRAM Compressed (S3TC/BPTC) for fast lookup and reduced memory footprint.
- **NEVER perform tree modifications during physics steps** — Adding/removing nodes during `_inter_ray` or `_physics_process` can lock the physics server. Use `call_deferred`.

---

**Debug → Profiler** (F3)

Tabs:
- **Time**: Function call times
- **Memory**: RAM usage
- **Network**: RPCs, bandwidth
- **Physics**: Collision checks

## Common Optimizations

### Object Pooling

```gdscript
var bullet_pool: Array[Node] = []

func get_bullet() -> Node:
    if bullet_pool.is_empty():
        return Bullet.new()
    return bullet_pool.pop_back()

func return_bullet(bullet: Node) -> void:
    bullet.hide()
    bullet_pool.append(bullet)
```

### Visibility Notifier

```gdscript
# Add VisibleOnScreenNotifier2D
# Disable processing when off-screen
func _on_screen_exited() -> void:
    set_process(false)

func _on_screen_entered() -> void:
    set_process(true)
```

### Reduce Draw Calls

```
# Use TextureAtlas (sprite sheets)
# Batch similar materials
# Fewer unique textures
```

## Reference
- [Godot Docs: Performance Optimization](https://docs.godotengine.org/en/stable/tutorials/performance/general_optimization.html)


### Related
- Master Skill: [godot-master](../godot-master/SKILL.md)
Files in this package (13)
  • SKILL.md 5 KB
  • scripts/custom_monitor_profiler.gd 1 KB
  • scripts/custom_performance_monitor.gd 1 KB
  • scripts/low_level_physics_query.gd 1 KB
  • scripts/manual_culling_logic.gd 1 KB
  • scripts/multimesh_foliage_manager.gd 2 KB
  • scripts/multimesh_optimizer.gd 1 KB
  • scripts/navigation_agent_optimization.gd 1 KB
  • scripts/object_pool_system.gd 1 KB
  • scripts/rendering_server_direct.gd 1 KB
  • scripts/shared_resource_strategy.gd 1 KB
  • scripts/texture_array_batching.gd 1 KB
  • scripts/worker_thread_pool_manager.gd 1 KB

Versions

RepositoryScoreLicence
This page · ahmet-cetinkaya/dotfiles100MIT
thedivergentai/game-dev-agentic-skills90LGPL

Database snapshot: 13.11.2026 · package version 31bc4ff28e22 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100performance-optimization
    Find and fix game performance problems methodically — measure with the engine profiler first, reason about the frame-time budget, locate the CPU-vs-GPU bottleneck, then apply the right fix: object pooling, draw-call batching, fewer allocations/GC spikes, and asset budgets.…
  • 100performance-optimization
    Find and fix game performance problems methodically — measure with the engine profiler first, reason about the frame-time budget, locate the CPU-vs-GPU bottleneck, then apply the right fix: object pooling, draw-call batching, fewer allocations/GC spikes, and asset budgets.…
  • 100godot-optimization
    Use when optimizing Godot games — profiler, draw calls, physics tuning, memory management, and common bottlenecks
  • 100performance-optimization
    Find and fix game performance problems methodically — measure with the engine profiler first, reason about the frame-time budget, locate the CPU-vs-GPU bottleneck, then apply the right fix: object pooling, draw-call batching, fewer allocations/GC spikes, and asset budgets.…
  • 100godot-optimization
    Use when optimizing Godot games — profiler, draw calls, physics tuning, memory management, and common bottlenecks
  • 100pixijs-performance
    Use this skill when profiling or optimizing a PixiJS v8 app for FPS, draw calls, or GPU memory. Covers destroy patterns (cacheAsTexture(false), releaseGlobalResources), GCSystem and TextureGCSystem, PrepareSystem, object pooling, batching rules, BitmapText for dynamic text,…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.