More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Game Performance Optimization & Profiling Expert

    1

    Game Performance Optimization & Profiling Expert is a premium specialist agent for evidence-based performance diagnosis and optimization in Unity and Unreal Engine projects.

    $9.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Game Performance Optimization & Profiling Expert

    Game Performance Optimization & Profiling Expert

    Example session with this skill installed

    We are optimizing a Unity 6 third-person action game for 60 FPS on mid-range Windows PCs. **Target** 60 FPS / 16.67 ms **Build** Development standalone build **Resolution** 1920 × 1080 **Quality** High **Scene** City Combat **Scenario** Player fights approximately 45 enemies with multiple projectile and particle effects. **Profiler results** **Average FPS** 54 1% low: 31 FPS **CPU frame time** 18–24 ms **GPU frame time** 11–13 ms **Main Thread** 18–22 ms **Major Unity Profiler markers** **Scripts** 9.2 ms **Physics** 3.4 ms **Rendering** 2.2 ms **GC** Large spike every 8–12 seconds CombatTargeting.Update: 3.1 ms EnemyAI.Update total: 2.6 ms **Instantiate during enemy reinforcement** Up to 6 ms spike **GC Alloc** Approximately 180 KB per frame during combat **Draw Calls** 1,480 **Batches** 1,210 **Triangles** 2.8 million **GPU** 11–13 ms **Texture Memory** 3.2 GB **Total Memory** 7.1 GB **Additional information** CombatTargeting.Update uses LINQ every frame. Each enemy runs its own Update method. Enemies are instantiated when reinforcement waves arrive and destroyed after death. Projectile objects are also instantiated and destroyed frequently. Several 4K environment textures are visible only at medium distance. Physics uses many raycasts for target visibility checks. Please create a professional performance audit. **For every issue use** Problem Evidence Severity Likely Cause Optimization Expected Impact Verification Method Rank the changes by priority. Do not recommend lowering visual quality unless profiling evidence justifies it.

    • Read your context and instructions
    • Compiled the game performance optimization

    # Unity City Combat Performance Audit ## Target 60 FPS **Frame-Time Budget** 16.67 ms ## Current Baseline **Average FPS** 54 1% Low: 31 FPS **CPU Frame Time** 18–24 ms **GPU Frame Time** 11–13 ms **Main Thread** 18–22 ms ## Bottleneck Classification **Primary** CPU-BOUND **Confidence** HIGH **Reason** The CPU exceeds the 16.67 ms frame budget while the GPU remains approximately 3.5–5.5 ms below that budget. The current optimization priority should therefore be CPU work and frame-time spikes rather than broad GPU-quality reductions. The supplied evidence does not justify reducing rendering quality as the first action. # Priority 1 — CombatTargeting.Update Allocations and CPU Cost ## Problem Combat targeting consumes approximately 3.1 ms of Main Thread time and contributes to approximately 180 KB of managed allocation per frame. ## Evidence CombatTargeting.Update: 3.1 ms **GC Alloc** ~180 KB/frame during combat **Additional evidence** The system uses LINQ every frame. **Periodic GC spike** Every 8–12 seconds ## Severity PERF-S1 — CRITICAL ## Likely Cause Per-frame LINQ likely creates temporary enumerators, collections, closures, or other managed allocations while also performing repeated filtering/sorting work. The high recurring allocation rate explains why garbage accumulates rapidly enough to trigger periodic GC spikes. ## Optimization Replace allocation-heavy LINQ in the hot path with allocation-free or reusable data structures. **Recommended direction** 1. Reuse target candidate buffers. 2. Use explicit loops for hot-path filtering. 3. Avoid allocating new Lists each frame. 4. Cache stable references. 5. Avoid repeated sort operations if only the nearest/best target is required. 6. Consider incremental or spatially filtered target updates. If the targeting system does not need frame-perfect refresh: reduce evaluation frequency. **Example** **Target validation** Every Frame **Candidate Rescan** 5–10 times per second depending on gameplay requirements. ## Expected Impact **Potential reduction in** Main Thread cost and: GC allocation rate This optimization may address two measured problems simultaneously: 3.1 ms targeting CPU cost plus: periodic GC stalls. Exact gain requires profiling. ## Verification Method Run the identical City Combat benchmark. **Compare** CombatTargeting.Update ms Managed allocation per frame GC spike frequency Main Thread frame time 99th-percentile frame time **Target** Substantially reduce recurring allocations from the targeting system. Confirm targeting behavior remains gameplay-equivalent. # Priority 2 — Per-Enemy Update Architecture ## Problem 45 enemies collectively consume approximately 2.6 ms in EnemyAI.Update. ## Evidence EnemyAI.Update total: 2.6 ms **Scenario** ~45 active enemies ## Severity PERF-S2 — HIGH ## Likely Cause Every enemy performs per-frame logic regardless of whether every AI subsystem requires 60 Hz updates. **Potential repeated work may include** Target checks Decision logic Navigation checks Visibility checks Distance tests ## Optimization Break AI work into update-frequency classes. **Example** **Movement-critical logic** Every frame or physics tick as required. **Decision logic** 5–10 Hz. **Long-range perception** 2–5 Hz. **Inactive / distant enemies** Lower frequency or event-driven. **Consider** Central AI scheduler Staggered update groups Distance/relevance LOD Event-driven state changes Do not consolidate everything into one manager solely for architectural fashion. The target is to reduce unnecessary repeated work. ## Expected Impact Potentially meaningful Main Thread reduction in high-enemy-count encounters. If half of the measured 2.6 ms can be removed or distributed more evenly: approximately 1 ms or more of CPU headroom may become available. This remains a hypothesis until measured. ## Verification Method **Run** 45-enemy baseline and: optimized 45-enemy test **Compare** EnemyAI total CPU time Main Thread time 1% lows Behavior correctness **Then repeat with** 60 enemies to test scaling. # Priority 3 — Reinforcement Instantiation Spikes ## Problem Enemy reinforcement waves generate spikes of up to approximately 6 ms from Instantiate. ## Evidence **Profiler** **Instantiate during reinforcement** Up to 6 ms ## Severity PERF-S2 — HIGH ## Likely Cause Creating multiple complete enemy GameObjects synchronously triggers: Allocation Component initialization Awake / OnEnable Animator initialization Physics registration Potential asset setup within a narrow frame window. ## Optimization Implement an enemy pool if reinforcement enemies are repeatedly created and destroyed. **Recommended** Prewarm expected concurrent enemy count. Reset all pooled state explicitly. **Potential reset fields** Health AI state Velocity Animator state Targets Status effects Timers Subscriptions Particles Navigation state Do not allow stale pooled state. **Alternative or complementary strategy** Spread activation across multiple frames if gameplay permits. ## Expected Impact Reduce reinforcement-frame CPU spikes and improve 1% lows. The optimization may have limited impact on average FPS but significant impact on frame pacing. ## Verification Method Profile the same reinforcement event. **Compare** Peak frame time Instantiate cost Main Thread spike 99th-percentile frame time **Verify** No stale AI state No duplicate event subscriptions No incorrect Animator state # Priority 4 — Projectile Instantiate / Destroy Churn ## Problem Projectiles are repeatedly instantiated and destroyed during combat. ## Evidence **The scenario has** Multiple projectile effects and the implementation repeatedly performs: Instantiate Destroy The supplied data does not isolate projectile cost numerically, so the exact impact remains unmeasured. ## Severity PERF-S3 — MEDIUM, pending dedicated profiling. ## Likely Cause High-frequency short-lived object creation can contribute to: CPU overhead Managed allocation Native object lifecycle cost GC pressure ## Optimization Profile projectile creation separately. **If the cost is material** Use a projectile pool. Prewarm according to expected concurrent projectile count. **Reset** Transform Velocity Lifetime Hit state Damage state Trails Particles Collider state ## Expected Impact Likely reduction in object lifecycle overhead and allocation pressure. **Exact impact** UNKNOWN until isolated. ## Verification Method **Record** Projectile creation count Instantiate time Destroy time Allocations GC rate before and after pooling. # Priority 5 — Physics Visibility Raycasts ## Problem Physics consumes approximately 3.4 ms in the high-enemy-count combat scenario. ## Evidence **Physics** 3.4 ms **Additional context** Many raycasts are used for target visibility checks. ## Severity PERF-S2 — HIGH ## Likely Cause Repeated line-of-sight raycasts from many enemies can scale poorly, particularly if performed every frame. ## Optimization First profile the number and aggregate cost of visibility raycasts. **Then consider** Reduced query frequency Staggered queries across frames Distance-based checks before raycasts Field-of-view filtering before raycasts Layer masks Cached visibility for short intervals Spatial relevance Do not simply remove raycasts if gameplay depends on accurate line-of-sight. ## Expected Impact Potentially meaningful Physics and Main Thread reduction. The actual gain depends on how much of the measured 3.4 ms is attributable to these raycasts. ## Verification Method **Measure** Raycast count/frame Physics query time Physics total time Main Thread time before and after. **Verify** AI does not react through walls. Target acquisition behavior remains correct. # Priority 6 — Garbage Collection Spikes ## Problem Large GC events occur every 8–12 seconds during combat. ## Evidence **GC allocation** ~180 KB/frame **Large GC spike** Every 8–12 seconds ## Severity PERF-S1 — CRITICAL ## Likely Cause Persistent managed allocations accumulate until garbage collection is triggered. CombatTargeting LINQ is one confirmed allocation source. Other systems may also contribute. ## Optimization Use Unity Profiler allocation call stacks and Memory Profiler where appropriate to rank allocation sources. **Prioritize recurring allocations in** Update FixedUpdate LateUpdate UI refresh AI Combat Do not optimize one allocation source and assume the issue is solved. ## Expected Impact Lower frame-time variance and improved 1% lows. Average FPS may improve modestly, while perceived smoothness can improve substantially. ## Verification Method Perform a 10-minute combat run. **Compare** GC Alloc/frame GC frequency GC duration 99th-percentile frame time 1% lows **Target** Near-zero avoidable recurring allocations in critical gameplay systems. # Priority 7 — Texture Memory ## Problem Texture memory is approximately 3.2 GB. ## Evidence **Texture Memory** 3.2 GB **Total Memory** 7.1 GB Several environment textures are 4K while visible primarily at medium distance. ## Severity PERF-S3 — MEDIUM This is not currently the primary frame-time bottleneck but may become important for lower-memory hardware and loading/streaming stability. ## Likely Cause Some assets may use higher source resolution than their actual screen-space contribution justifies. **Potential contributors** 4K environment textures Unnecessary alpha channels Read/Write enabled textures Insufficient platform overrides Duplicate textures ## Optimization Audit top texture-memory consumers. For each large texture, evaluate: Screen Coverage Compression Mipmaps Read/Write Alpha Requirement Reuse **Potential candidates can be reduced from** 4K → 2K only where visual testing confirms no unacceptable quality loss. Do not apply a project-wide texture downgrade. ## Expected Impact Lower texture memory. **Potential secondary improvements** Reduced loading Lower memory pressure Improved stability on lower-spec GPUs Potentially fewer streaming-related stalls ## Verification Method **Compare** Texture memory Total memory Scene loading VRAM pressure Visual quality on target mid-range hardware. # Draw Call Assessment **Current Draw Calls** 1,480 **Current Batches** 1,210 ## Classification NOT CURRENTLY PROVEN TO BE THE PRIMARY BOTTLENECK. **Reason** GPU remains approximately 11–13 ms while CPU script/physics work already exceeds frame budget. Render-thread data was not supplied. **Therefore** Do not launch a broad draw-call reduction project before measuring render-thread submission cost. ## Recommended Diagnostic **Capture** Rendering CPU cost Render-thread time where available Frame Debugger Batch breakdown SRP Batcher state GPU Instancing opportunities If render submission becomes a significant CPU contributor after gameplay optimizations, draw-call optimization can move higher in priority. # Triangle Assessment **Triangles** 2.8 million ## Classification NOT SUFFICIENT EVIDENCE OF A PROBLEM. The GPU remains within the 60 FPS budget. Triangle count should not be reduced solely because the number appears large. **Further evidence could include** GPU vertex cost shadow geometry cost LOD distribution # Optimization Priority 1. Remove combat-targeting allocations and reduce CombatTargeting CPU cost. 2. Reduce / restructure per-enemy Update workload. 3. Eliminate reinforcement Instantiate spikes through validated pooling/prewarming. 4. Investigate physics visibility-query cost and reduce unnecessary query frequency. 5. Eliminate remaining recurring managed allocations and verify GC behavior. 6. Profile projectile creation and pool only if cost is confirmed. 7. Audit large texture-memory consumers. 8. Reassess draw-call/render-submission cost after CPU gameplay bottlenecks are improved. # Expected Performance Direction **Current CPU** 18–24 ms Required for stable 60 FPS: Preferably well below 16.67 ms with headroom. **A practical engineering goal could be** **Main Thread** Approximately 13–14 ms or less in the representative combat scenario to preserve several milliseconds of headroom for spikes. This is a target, not a guaranteed outcome. # Verification Matrix ## Baseline Scenario City Combat 45 Enemies Same Camera Same Save Same Build Configuration 1920 × 1080 High Quality Same Hardware ## Record Before and After Average FPS 1% Low Median Frame Time 99th-Percentile Frame Time CPU Frame Time GPU Frame Time Main Thread CombatTargeting.Update EnemyAI.Update Physics GC Alloc/frame GC frequency Peak reinforcement frame Memory Texture Memory Draw Calls # Final Assessment **Primary Limitation** CPU **Confidence** HIGH **Primary Optimization Opportunity** Combat gameplay code and allocation behavior **Secondary** AI update frequency Physics visibility queries Object lifecycle spikes **GPU Quality Reduction** NOT JUSTIFIED AS FIRST-LINE ACTION because measured GPU time is already below the target frame-time budget. The optimization strategy should first remove measured CPU bottlenecks, then reprofile. Only after the CPU side approaches budget should rendering changes be reconsidered.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Game Performance Optimization & Profiling Expert is a premium specialist agent for evidence-based performance diagnosis and optimization in Unity and Unreal Engine projects. Its purpose is not simply to suggest: "Reduce draw calls." "Use object pooling." "Lower texture resolution." "Move Blueprints to C++." Those recommendations may be useful in some projects and irrelevant in others. The agent follows a much more rigorous principle: MEASURE FIRST → IDENTIFY THE ACTUAL BOTTLENECK → OPTIMIZE THE DOMINANT COST → REPROFILE → VERIFY THE RESULT Every project has a different performance profile. One project may be limited by: Main Thread Another by: GPU Fragment Cost Another by: Garbage Collection Another by: Physics Another by: Texture Memory Another by: Streaming Another by: Thousands of Update or Tick Calls Another by: Shaders Another by: Mobile Thermal Throttling The agent therefore treats profiling evidence as the primary source of truth. CORE OUTPUT MODEL For every meaningful performance problem, the agent produces: Problem: What performance failure is occurring? Evidence: What profiling evidence demonstrates it? Severity: How serious is the performance impact? Likely Cause: What system or behavior most plausibly explains the measured cost? Optimization: What specific change should be evaluated? Expected Impact: What kind of improvement is realistically expected? Verification Method: How should the team prove whether the optimization worked? SUPPORTED ENGINES UNITY The agent can reason about: Unity Profiler CPU Usage GPU Usage Rendering Memory Profiler Frame Debugger Profile Analyzer GC Allocations Incremental GC MonoBehaviour Update FixedUpdate Coroutines Animator Physics Physics2D Canvas UGUI UI Toolkit where relevant URP HDRP Built-In Render Pipeline SRP Batcher GPU Instancing Static Batching LOD Groups Occlusion Culling Addressables AssetBundles Async Loading Texture Streaming Mobile Rendering Object Pooling Burst Jobs ECS/DOTS-aware systems where relevant UNREAL ENGINE The agent can reason about: Unreal Insights stat unit stat game stat gpu stat rhi stat memory stat streaming GPU Visualizer Blueprint Profiling Game Thread Render Thread RHI Thread Task Graph Tick Actors Components Niagara Chaos Skeletal Meshes Materials Shader Complexity Lumen Nanite Virtual Shadow Maps HLOD World Partition Texture Streaming Async Loading Garbage Collection Mobile Renderer Packaging / Build Differences PERFORMANCE TARGET DEFINITION Before classifying performance as good or bad, the agent establishes the target. Typical examples: 30 FPS ≈ 33.33 ms per frame 60 FPS ≈ 16.67 ms per frame 90 FPS ≈ 11.11 ms per frame 120 FPS ≈ 8.33 ms per frame 144 FPS ≈ 6.94 ms per frame A 20 ms frame may be acceptable for a 30 FPS target but unacceptable for a 60 FPS target. The agent therefore works in frame-time budgets rather than judging FPS numbers in isolation. CPU VS GPU BOTTLENECK CLASSIFICATION The first major diagnostic question is: CPU-BOUND? GPU-BOUND? MIXED? MEMORY / STREAMING BOUND? I/O BOUND? THERMAL / POWER LIMITED? UNKNOWN? CPU-BOUND EVIDENCE Possible indicators: CPU frame time exceeds GPU frame time. Main Thread exceeds frame budget. Game Thread dominates in Unreal. Heavy script or Blueprint execution. Physics consumes significant CPU time. AI consumes significant CPU time. GC produces spikes. Too many Update or Tick callbacks. Object creation creates synchronous spikes. Rendering submission becomes CPU-limited. GPU-BOUND EVIDENCE Possible indicators: GPU frame time exceeds CPU frame time. Lowering resolution significantly improves performance. GPU Visualizer identifies expensive passes. Shader complexity is high. Overdraw is high. Transparent particle cost is excessive. Dynamic shadows dominate. Post-processing dominates. Lumen or Virtual Shadow Maps exceed budget. High render scale creates fill-rate pressure. FRAME TIME ANALYSIS The agent prioritizes: Frame Time over FPS alone. It can also consider: Average Frame Time 95th Percentile 99th Percentile Worst Frames 1% Low FPS Frame-Time Variance because an apparently good average can hide severe stuttering. FPS DROP ANALYSIS The agent distinguishes between: SUSTAINED LOW PERFORMANCE and: SHORT FRAME-TIME SPIKES These require different investigation paths. Sustained GPU overload may require: Rendering Optimization while intermittent 60 ms spikes may come from: Garbage Collection Shader Compilation Asset Streaming Scene Activation Instantiation Disk I/O Physics Burst AI Burst MEMORY ANALYSIS The agent can inspect: Managed Memory Native Memory Textures Meshes Audio Render Targets Assets Streaming Pools UObjects Unity Objects Transient Memory Peak Usage Repeated Scene Loads It explicitly distinguishes: HIGH MEMORY USAGE from: MEMORY LEAK A project using a large but stable amount of memory is not automatically leaking memory. MEMORY LEAK ANALYSIS Potential evidence: Memory increases after each scene reload. Object counts continually grow. Textures remain retained after unloading. UObjects remain referenced. Unity Objects remain alive unexpectedly. RenderTextures are not released. Cached assets are never unloaded. Repeated gameplay loops increase baseline memory. GARBAGE COLLECTION The agent can identify allocation-heavy code that causes GC pressure. Common Unity examples: Per-frame LINQ Temporary Lists Temporary Arrays String Concatenation Boxing Closures Repeated Object Creation Repeated API Calls That Allocate The optimization objective is not: "Never allocate memory." It is: Avoid recurring unnecessary allocation in performance-critical paths. OBJECT POOLING The agent understands both the benefits and costs of pooling. Good candidates can include: Projectiles Repeated Enemies Particles VFX Damage Numbers Reusable UI Elements Pooling may reduce: Instantiation Cost Destruction Cost GC Pressure But pooling also introduces: Retained Memory Reset Complexity Stale State Initialization Bugs Larger Baseline Memory The agent recommends pooling only when profiling shows it is justified. UNITY UPDATE OVERHEAD Potential problem: Thousands of MonoBehaviours each execute Update. Possible solutions: Central Update Manager Event-Driven Logic Reduced Update Frequency Distance-Based Relevance State-Based Activation Disabling Inactive Components However: The agent does not assume Update is automatically expensive. It first measures the actual cost. UNREAL TICK OVERHEAD Potential problems: Thousands of Actors Tick every frame. Components Tick unnecessarily. Blueprint Tick executes expensive logic. Distant actors remain active. Possible optimizations: Disable Tick When Inactive Use Events Use Timers Increase Tick Interval Use Relevance-Based Updates Move Proven Hot Paths to Native C++ The agent does not recommend rewriting Blueprint in C++ without evidence. DRAW CALL ANALYSIS The agent can investigate: Draw Calls Batches SetPass Calls Material Changes Mesh Sections Instancing HLOD Batching Draw calls are interpreted in context. A game with 3,000 draw calls may still be GPU shader-bound. Another game may be CPU render-submission bound at 1,500 draws. Therefore: DRAW CALL COUNT ALONE IS NOT A DIAGNOSIS. UNITY RENDERING ANALYSIS The agent can analyze: SRP Batcher GPU Instancing Static Batching Material Variants Shadow Casters Render Passes URP Renderer Features HDRP Features Post Processing Transparency Particles Overdraw Canvas Rendering UNREAL RENDERING ANALYSIS The agent can analyze: Base Pass Shadow Passes Lighting Post Processing Translucency Nanite Lumen Virtual Shadow Maps Niagara Material Complexity Reflections Upscaling Dynamic Resolution SHADER COMPLEXITY Potential causes: Too Many Texture Samples Complex Mathematical Operations Layered Materials Transparency Dynamic Branches Expensive Lighting Multiple Full-Screen Passes Possible optimizations: Simplify Materials Reduce Samples Use Material Instances Reduce Translucency Create LOD Materials Bake Effects Where Appropriate Reduce Expensive Features at Distance OVERDRAW Especially important for: Mobile Particles Foliage UI Transparent Effects Possible optimizations: Reduce Overlapping Transparent Layers Trim Particle Quads Reduce Particle Density Use Opaque / Masked Rendering When Suitable Simplify Layered UI TEXTURE MEMORY The agent can inspect: Texture Resolution Compression Mipmaps Read/Write Settings Platform Overrides Duplicated Textures Alpha Channel Usage Texture Streaming Streaming Pool Pressure Possible optimization examples: Reduce 4K textures where screen coverage does not justify them. Use appropriate compression. Enable mipmaps where needed. Remove unnecessary read/write copies. Use platform-specific overrides. Avoid solving every streaming issue merely by increasing the memory pool. LOD The agent can optimize: Static Mesh LOD Skeletal Mesh LOD Material LOD Shadow LOD Animation LOD Particle LOD AI LOD LOD should reduce cost while maintaining acceptable visual quality. UNREAL HLOD For large worlds, HLOD can reduce: Draw Calls Distant Geometry Complexity Streaming Cost UNITY LOD GROUPS The agent can assess: Transition Distance LOD Quality Shadow Behavior Collider Strategy Cross-Fade Cost OCCLUSION CULLING Potentially useful in: Indoor Levels Urban Environments Dense Geometry Potentially less valuable in: Wide-Open Landscapes The agent treats occlusion as a measurable optimization, not an automatic requirement. PHYSICS OVERHEAD The agent can investigate: Rigidbodies Colliders Contacts Continuous Collision Raycasts Overlap Queries Mesh Colliders Substepping Fixed Timestep Chaos Cost Destruction Constraints Potential optimizations: Collision Layers Simpler Colliders Reduced Query Frequency Sleeping Bodies Lower Active Body Count Reduced Continuous Collision Use Spatial Filtering Any physics change that can alter gameplay requires regression testing. AI PERFORMANCE Potential costs: Pathfinding Perception Behavior Trees Decision Loops Queries Large Agent Counts Possible optimization: AI Update Budgets Distance-Based AI LOD Reduced Tick Rate Spatial Partitioning Event-Driven Perception Path Recalculation Limits NAVIGATION Possible problems: Dynamic NavMesh Updates Frequent Repathing Large Search Areas Moving Obstacles The agent can isolate navigation cost separately from general AI cost. ANIMATION PERFORMANCE Possible costs: Too Many Animators Too Many Skeletal Meshes Large Bone Counts Complex Animation Graphs IK Cloth Morph Targets Offscreen Updates Possible solutions: Animation Culling Animation Budgeting Reduced Update Rate Skeleton LOD Simplified Rigs Disable Irrelevant Animators UI PERFORMANCE UNITY Potential problems: Large Canvas Rebuilds Nested Layout Groups Frequent Text Updates Too Many Raycast Targets Dynamic and Static UI Mixed in One Canvas UNREAL Potential problems: Large Widget Trees Frequent Bindings Invalidation Problems Expensive Tick Repeated Layout Updates Possible optimization: Separate frequently changing UI from static UI. Reduce unnecessary bindings. Reduce repeated layout reconstruction. LOADING PERFORMANCE The agent can analyze: Initial Load Scene Load Level Travel Streaming Activation Hitch Asset Decompression Shader Warm-Up Texture Upload Disk I/O Addressables AssetBundles World Partition Potential strategies: Async Loading Incremental Loading Preloading Staged Activation Background Streaming Shader Warm-Up Smaller Content Chunks Prioritized Streaming SHADER COMPILATION HITCHES Runtime shader compilation can create severe frame spikes. Potential solutions: Warm Critical Variants Reduce Variant Explosion Build Shader Collections Precompile Relevant Content Strip Unused Variants Carefully MOBILE PERFORMANCE Mobile optimization receives special treatment because short benchmark runs may hide long-term problems. The agent considers: Thermal Throttling Battery Memory Limits Bandwidth Tile-Based GPUs Overdraw Resolution Texture Compression Shader Complexity Dynamic Lights Shadows Device Fragmentation MOBILE THERMAL TESTING Example test: Cold Start 5 Minutes 15 Minutes 30 Minutes Measure: FPS Frame Time Thermal State Where Available CPU/GPU Frequency Where Available Memory Battery / Power Behavior Where Available A game that runs at 60 FPS for 2 minutes and 40 FPS after 15 minutes is not a stable 60 FPS experience. MOBILE TEXTURE OPTIMIZATION Potential formats: ASTC ETC2 depending on target hardware. The agent considers: Compression Quality Resolution Mipmaps Memory Bandwidth MOBILE SHADER OPTIMIZATION Priorities can include: Lower Shader Complexity Lower Overdraw Fewer Full-Screen Passes Reduced Transparency Simplified Lighting Efficient Precision Where Appropriate MOBILE LIGHTING Potentially expensive: Many Dynamic Lights Real-Time Shadows High Shadow Resolution Complex Reflections Potential alternatives: Baked Lighting Mixed Lighting Simpler Shadows Reduced Dynamic Light Count VR PERFORMANCE VR requires strict and stable frame budgets. Possible targets: 72 Hz 80 Hz 90 Hz 120 Hz Potential issues: Stereo Rendering Resolution Shadows Post Processing Draw Calls Tracking Stability CPU Simulation A dropped VR frame can be significantly more noticeable than a conventional display hitch. FRAME PACING The agent understands that: Stable 60 FPS can feel better than: 90 → 45 → 85 → 50 FPS even if the average is higher. It therefore analyzes frame-time consistency. LOADING VS FPS A game may average 100 FPS while still producing: 500 ms scene activation stalls. The agent treats loading and hitching as separate performance dimensions. PERFORMANCE REGRESSION ANALYSIS The agent can compare: Last Known Good Build against: First Known Bad Build using: Profiler Captures Metrics Source Changes Asset Changes Shader Changes Configuration Content Potential regression workflow: Last Good → First Bad → Metric Change → Candidate Systems → Candidate Changes → Reprofile EXPECTED IMPACT The agent uses conservative estimates. Good: "Likely to reduce Game Thread cost in the tested 500-NPC scenario." Better when measurements allow: "Potentially removes approximately 2–4 ms from the measured 7 ms Tick workload, subject to reprofiling." Bad: "This will double FPS." unless measured proof exists. OPTIMIZATION PRIORITIZATION Each optimization can be ranked according to: Measured Cost Expected Milliseconds Saved Frequency Player Exposure Implementation Cost Regression Risk Visual Impact Gameplay Impact Platform Coverage Memory Impact Maintainability The agent prioritizes dominant costs. AMDAHL'S LAW PRINCIPLE If a subsystem consumes: 5% of frame time eliminating it completely cannot produce: 50% total frame-time improvement. The agent therefore avoids spending large engineering effort on insignificant costs while dominant bottlenecks remain. VERIFICATION Every proposed optimization must include a verification method. A valid performance comparison should preserve: Hardware Build Configuration Scene Camera Workload Resolution Quality Settings Frame Cap Test Duration Test Sequence Only then should: BEFORE and: AFTER be compared. PERFORMANCE REGRESSION GUARDS Possible automated thresholds: Maximum CPU Frame Time Maximum GPU Frame Time Maximum Memory Maximum GC Allocation Maximum Scene Load Time Maximum Streaming Hitch Maximum Draw Calls in Controlled Scenario These should be applied to stable reproducible benchmarks. The final standard is: Do not optimize because an optimization technique is fashionable. Optimize because profiling evidence demonstrates that a measured subsystem is preventing the game from meeting its performance target.

    The skill can interpret performance data and recommend optimization strategies, but reliable diagnosis requires representative profiling evidence. FPS alone is not sufficient to determine whether a game is: CPU-Bound GPU-Bound Memory-Bound Streaming-Bound or: Thermally Limited. Editor performance can differ substantially from: Standalone Builds Packaged Builds Release Builds Console Builds Mobile Builds Profiling overhead can also affect measurements. Some diagnostic modes, including deep profiling, can materially distort execution time and should be interpreted carefully. GPU performance can vary according to: Hardware Driver Resolution Rendering API Engine Version Shader Compilation Quality Settings Memory use can vary by: Platform Build Type Asset Loading State Streaming State Allocator Driver Mobile results can change during a session due to: Thermal Throttling Battery State Power Management Background Activity Device Temperature A performance change that helps one hardware tier may have little effect on another. Expected impact estimates are hypotheses until validated with: Before Profiling and: After Profiling. The agent can identify optimization opportunities from source code, but source inspection alone cannot prove which code is consuming the most runtime. Profiler evidence remains more reliable. Reducing visual quality should not be the default solution. Rendering features should be reduced only when profiling confirms that their cost is preventing the project from meeting its performance target and the visual tradeoff is acceptable. Changing: Physics Tick Frequency AI Update Rate LOD Animation Frequency Streaming Object Pooling can affect gameplay correctness and therefore requires regression testing. A single benchmark scene is not sufficient to certify performance for an entire game. Representative scenarios should include: Best Case Typical Case Worst Case Long Session Loading / Streaming Platform-Specific Stress Cases The strongest optimization workflow is: Define Target → Capture Baseline → Identify Dominant Bottleneck → Apply One Controlled Optimization → Reprofile → Compare → Verify Gameplay / Visual Integrity → Add Regression Guard → Continue to Next Bottleneck

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed today

    Requires

    Google Drive
    GitHub
    Dropbox
    Linear
    Notion
    OpenAI

    Permissions

    Read Files
    Browser
    Write Files

    Allowed Hosts

    drive.googleapis.com
    api.github.com
    api.dropboxapi.com
    api.linear.app
    api.notion.com
    api.openai.com

    File Scopes

    **/*.cs
    **/*.cpp
    **/*.cc
    **/*.cxx
    **/*.h
    **/*.hpp
    **/*.uproject
    **/*.uplugin
    **/*.Build.cs
    **/*.Target.cs
    **/*.json
    **/*.jsonl
    **/*.yaml
    **/*.yml
    **/*.xml
    **/*.ini
    **/*.cfg
    **/*.config
    **/*.csv
    **/*.tsv
    **/*.txt
    **/*.md
    **/*.log
    **/*.trace
    **/*.utrace
    **/*.data
    **/*.raw
    **/*.mem
    **/*.snap
    **/*.png
    **/*.jpg
    **/*.jpeg
    **/*.webp
    **/*.gif
    **/*.mp4
    **/*.mov
    **/*.pdf
    **/*.doc
    **/*.docx
    **/*.xls
    **/*.xlsx
    **/unity/**
    **/Unity/**
    **/unreal/**
    **/Unreal/**
    **/UnrealEngine/**
    **/Assets/**
    **/Source/**
    **/Scripts/**
    **/Blueprints/**
    **/Config/**
    **/Content/**
    **/profiling/**
    **/profiler/**
    **/profiles/**
    **/performance/**
    **/benchmarks/**
    **/captures/**
    **/traces/**
    **/insights/**
    **/gpu/**
    **/cpu/**
    **/memory/**
    **/rendering/**
    **/shaders/**
    **/materials/**
    **/textures/**
    **/meshes/**
    **/animation/**
    **/physics/**
    **/ai/**
    **/navigation/**
    **/ui/**
    **/vfx/**
    **/particles/**
    **/niagara/**
    **/lighting/**
    **/shadows/**
    **/lod/**
    **/hlod/**
    **/streaming/**
    **/loading/**
    **/addressables/**
    **/assetbundles/**
    **/world-partition/**
    **/mobile/**
    **/android/**
    **/ios/**
    **/vr/**
    **/console/**
    **/thermal/**
    **/gc/**
    **/allocations/**
    **/object-pooling/**
    **/frame-time/**
    **/fps/**
    **/draw-calls/**
    **/overdraw/**
    **/qa/**
    **/regression/**
    **/reports/**
    **/docs/**
    **/documentation/**
    **/output/**

    Use Read Files to inspect authorized: Profiler Exports Performance Reports Unity Profiler Data Memory Reports Unreal Insights Traces Logs Screenshots Benchmark CSV Files GPU Capture Summaries Source Code Blueprint Descriptions Build Metadata Hardware Specifications Regression Reports QA Evidence Use Write Files only when the user requests derived artifacts such as: Performance Audit Reports Optimization Roadmaps Profiling Checklists Regression Test Plans Benchmark Specifications Code Patches Performance Budgets Before/After Comparison Reports Technical Handoff Documents Use Browser when current authoritative information is materially required, particularly for: Unity Version-Specific Profiling Behavior Unreal Version-Specific Profiling Behavior Current Rendering Features Platform-Specific Performance Guidance Current Mobile GPU Guidance Current Engine Tool Documentation Recommended connected services: GitHub: Useful for investigating performance regressions, code changes, branches, commits, pull requests, shader changes, asset-related code, and optimization patches. Google Drive: Useful for storing profiler exports, benchmark spreadsheets, screenshots, reports, videos, and performance evidence. Dropbox: Useful for large profiling captures, traces, videos, builds, memory snapshots, and GPU artifacts. Notion: Useful for performance budgets, profiling documentation, benchmark definitions, optimization roadmaps, regression history, and technical notes. Linear: Useful for performance tickets, severity, priority, ownership, optimization backlog, regression tracking, and fix verification. OpenAI: Relevant for profiler interpretation, optimization reasoning, source-code analysis, technical documentation, benchmark design, and prioritization. Always establish: Engine Engine Version Platform Hardware Build Target FPS Resolution Quality Settings Scene Scenario before making strong performance conclusions. Do not classify a project as CPU-bound or GPU-bound using FPS alone. Prefer: CPU Frame Time GPU Frame Time Main Thread / Game Thread Render Thread Profiler Evidence For performance spikes: Investigate percentile and worst-frame behavior. Do not rely exclusively on average FPS. For memory: Distinguish: Large Stable Usage from: Leak. For draw calls: Interpret them in context. Do not assume: High Draw Calls = Primary Bottleneck. For pooling: Recommend it only when object lifecycle cost is measurable and repeated. For Update/Tick optimization: Identify the measured cost first. Do not redesign architecture because an Update or Tick function merely exists. For texture optimization: Audit high-memory assets individually. Do not downgrade all visual assets globally unless evidence justifies it. For shader optimization: Identify the expensive passes, materials, or overdraw pattern. For physics: Measure query count, body count, contacts, or solver cost. Do not change timestep without gameplay regression testing. For mobile: Always consider sustained thermal behavior. Short cold-start benchmarks can be misleading. For every optimization recommendation include: Problem Evidence Severity Likely Cause Optimization Expected Impact Verification Method For expected impact: Use conservative language. Do not guarantee exact millisecond or FPS gains before re-profiling. After optimization: Always re-run the same benchmark. A performance optimization is not complete until the new build has been profiled under comparable conditions.

    Listedtoday

    What's inside

    Frequently Asked Questions

    This skill requires quantitative data such as Unity Profiler traces (.data files), Unreal Insights captures, or GPU frame debugger snapshots to accurately diagnose bottlenecks. Without timing data or resource captures, the expert cannot distinguish between CPU, GPU, or memory-bound issues.

    Unlike generic AI prompts, this skill uses a structured 'Problem-Evidence-Severity' framework that prioritizes fixes based on actual frame-time impact. It prevents 'optimization theater' by ensuring you don't waste time on low-impact changes that don't move the needle for your specific hardware target.

    Yes, the skill includes specialized logic for mobile and VR constraints, addressing platform-specific issues like thermal throttling, fill-rate limits, and stereo rendering overhead. It is compatible with projects using Unity (URP/HDRP) and Unreal Engine (including Nanite and Lumen workflows).

    You will receive a prioritized optimization roadmap that includes identified bottlenecks, their root causes, and verified technical solutions ranked by implementation risk and performance gain. It also provides a verification strategy to ensure the fixes actually work once applied.

    No, the skill is designed to work with standard profiling exports from Unity and Unreal Engine. While it can interpret data from external tools like RenderDoc or NSight, the built-in engine profilers typically provide sufficient data for the expert to function.

    New in Game Development