2026.03 - Agentic E2E Workflows
Your personal dev agent can already read code. It can profile. It can even fix things. But if it still goes blind the moment the real answer lives
2026.02 - Agentic Optimization
Agentic Optimization: You already know the pattern: profiler finds pain, the team patches random code, and frame time still looks like a heart attack. In this lesson, you move from agentic profiling into agentic optimization so you stop guessing.
2026.01 - Agentic Profiling
Agentic Profiling: You hit Ctrl+7, record a capture, open the Profiler Timeline, and… your frame time graph still looks like a heart attack. Better ways to do this? Yeah, plenty!
2025.12 - The Few Groups You'll Ever Need: Mipmap & Culling Groups
The Few Groups You'll Ever Need: Mipmap & Culling Groups: Texture shimmer and off-screen simulation waste are two classic performance leaks that quietly stack into stutter. If you ignore both, you pay twice: GPU memory pressure plus CPU work the player never sees.
2025.11 - APV in Your Game? (Adaptative Probe Volumes)
APV in Your Game? (Adaptative Probe Volumes): Learn when Adaptive Probe Volumes beat fragile manual probe workflows, how to switch them on in Unity 6, and the first debugger checks to catch bad probe coverage before it turns into lighting debt.
2025.10 - Mesh LODs in Unity 6.2+
Mesh LODs in Unity 6.2+: Reduce LOD work without hand-authoring every variant, start with automatic import-time simplification, and know when Mesh LOD is a better first pass than classic LOD Groups.
Unlock the full library
Choose a plan and get instant access to every module, audio, and resources.
2025.09 - Review Your Auditor, Presets & Assets
Review Your Auditor, Presets & Assets: Cross-platform performance pain usually starts with inconsistency, not one giant bug. One asset imported wrong, one shader variant too heavy, one quality profile forgotten, and you are back in firefighting mode.
2025.08 - Squeezing Ray-Tracing
Squeezing Ray-Tracing: Ray tracing can either elevate your game or trigger a performance disaster, depending on how disciplined your setup is. If you enable everything globally, your frame-time cliff arrives fast.
2025.07 - Throw WebGL, learn WebGPU
Throw WebGL, learn WebGPU: If your web build still rides legacy assumptions, you are heading into a compatibility and performance bottleneck at the same time. Browser players feel every hitch, and they bounce fast.
2025.06 - UI Toolkit - Faster Than You'd Imagine
UI Toolkit - Faster Than You'd Imagine: Stop losing frame time to menus, inventories, and overdraw. Learn how UI Toolkit cuts draw calls, when vertex budgets and atlases matter, and how to prove the UI is actually cheap.
2025.05 - "VRS" - Variable Rate Shading
"VRS" - Variable Rate Shading: Learn when Variable Rate Shading can cut GPU cost without obvious quality loss, how to gate it safely in Unity 6.1+ and URP 17, and the first SRI plus debug checks to prove the gains before you commit to a full implementation.
2025.04 - Fast&Sexy Audio Import Settings
Fast&Sexy Audio Import Settings: Audio settings can quietly become a frame-time cliff: random spikes, memory bloat, and loading hitches that look like gameplay bugs. If you leave importer defaults untouched, you are likely burning cycles where players feel it most.
2025.03 - Building Your Own Performance Lab
Building Your Own Performance Lab: Stop shipping blind. Build a multi-device Unity testing lab with heterogeneous hardware, remote access, and automated build distribution so regressions show up before launch.
2025.02 - Coding Like a `LLM Ninja`
Coding Like a `LLM Ninja`: Learn when to use one-shot prompts, IDE plugins, model/provider control, and plan-then-code workflows to ship Unity work faster without buying the hype.
2025.01 - The Six Exotic "Profiling Toys"
The Six Exotic "Profiling Toys": You are probably losing time in a performance firefighting loop: the game stutters, you patch one script, and the hitch comes back somewhere else.
2024.12 - Frame Debugger Mastery & Maybe Render Graph?
Frame Debugger is how you stop guessing why Rendering is slow: inspect the exact draw event (GPU state, batching breaks, bound textures) and map the frame with Render Graph Viewer. Complete members-only module + video below.
2024.11 - Let AI Help You Optimize Performance
Stop guessing when you hit a bottleneck. This module shows how to use an LLM/VLM to analyze a Unity Profiler capture, starting with the exact questions to ask and a system-message template pinned to your target hardware + FPS.
2024.10 - Motion Vectors - Get Away With Cheap Upscaling& More
Motion vectors are the difference between cheap upscaling and ghosting soup. Learn what they are, how Unity generates them, how to debug them (Frame Debugger, RenderDoc, Rendering Debugger), and how Camera Motion Only vs Per Object affects both quality and cost. Full members-only module below.
2024.09 - Risk-Reward of AppSw (Application SpaceWarp)
Application SpaceWarp can double your Quest frame budget (pay 60, display 120), but it will punish motion-vector gaps and transparency fast. This module shows the setup, how to prove it is working, and the failure cases before you bet your build.
2024.08 - The Utility of XR Composition Layers
XR composition layers are the VR comfort cheat: keep UI/video crisp while the scene is loading or downscaled. The members-only module shows overlays vs underlays, depth submission tradeoffs, and the Quest profiling steps you need before you ship this into a headset.
2024.07 - From Zero to Perfect CPU Scaling
Your 350-boid prototype can be 35ms and still 'look fine'. That's how games die. This module walks GameObjects -> ECS -> Jobs + Burst -> spatial partitioning, and teaches the one metric that matters for scaling: total CPU time.
2024.06 - Budget-Friendly Serialization & Deserialization
Serialization looks easy. Then you ship an update, change a data structure, and corrupt thousands of saves. This module gives you benchmarks + decision rules (time, GC allocs, size, migrations) so you pick the right format before it bites you.
2024.05 - Texture Arrays — The Forgotten Tool
Texture arrays are the forgotten tool: one texture object with many slices, switched by an index. Set Texture Shape = 2D Array, verify slices in RenderDoc, and sanity-check sample cost with Mali Offline Compiler. Full module + video is members-only below.
2024.04 - RenderMode's & Graphics Jobs
Rendering taking 40-50% on the Main Thread while worker threads idle? Not cool. Prove your render mode in Profiler + Player log, then enable Graphics Jobs (Native/Split) only when your target actually supports it.
2024.03 - My Top Tools I Don't Want to Live Without
A no-BS stack to speed up your developer loop: Perplexity, ripgrep, T4 templates, Restic snapshots, WhisperX transcripts, Windmill automation, and remote hierarchy debugging for fast A/B performance signal.
2024.02 - BatchRendererGroup - Architecting Your Own Draw Calls
BatchRendererGroup (BRG) is the stop-hoping-Unity-batches-it API. If you have repeated, static-like props and your render thread is paying for draw calls, this module shows the pattern: push data once, then drive visibility without exploding batches.
2024.01 - GPU Resident Drawer
GPU Resident Drawer (GPU-driven rendering) can cut CPU rendering cost fast if your content fits. Benchmark snapshot: camera rendering 5.86ms -> 4.54ms, SetPasses 50 -> 13, draw calls 339 -> 139. Full step-by-step module + video is members-only.
2023.12 - SRP Batcher - Does it Truly Suck?
SRP Batcher is not about making draw calls disappear. It is about making them cheaper. This module shows the Frame Debugger and RenderDoc proof, the compatibility rules that break it, and the profiling flow that tells you whether it is actually saving CPU time.
2023.11 - 3 Ways to Prewarm Your Lazy Shaders
Lazy shader compilation is a launch-day stutter trap. This module shows how to catch CreateGPUProgram in a real build, when ShaderVariantCollection is not enough, and how to prewarm the right variants during startup or a loading screen before players ever feel the hitch.
2023.10 - Boost that Asset Loading, Integration & Threading
Asset loading is a three-stage problem, not a mystery. Learn how to profile CPU Usage, File Access, and Asset Loading together, where Awake and asset integration create hitches, and how to use backgroundLoadingPriority and lightmap discipline to cut real load pain.
2023.09 - Decals: Fast & Furious
Decals can make a scene look shipped or quietly wreck your frame time. This module shows why BIRP Projector does not scale, when URP DBuffer vs Screen Space makes sense, and when decal stamping is the smarter call if the result does not need to move.
2023.08 - It's Hot Down There! Optimizing for Heat, Energy & Battery
Heat and battery drain are a retention problem. This module shows how to measure power at the wall, inspect CPU activity with Battery Historian, and cut waste with simple Unity-side moves like lower frame rates and rendering on demand.
2023.07 - Compute Shaders "Behind the Scenes"
Compute Shaders are the move you make when CPU-side optimization is still not enough. This module shows the real Tape to Tape use case, the API/support gates, the SIMD mindset, and the buffer and readback decisions that separate a real GPU win from a slow science project.
2023.06 - THE High-Performance Build Pipeline
Manual Unity builds are a delivery tax. This module shows the GitLab CI plus Docker plus Game CI path, why a Linux VPS beats blocking your workstation, and how to get from commit to build artifact and team notifications without the usual pipeline mess.
2023.05 - High-Performance Collections: Multithreading, Burst, Jobs! <3
High-performance collections can cut managed overhead, but only if you stop treating NativeList, Burst, safety checks, and allocators like magic. This module shows when native containers win, when they lose, and how to make the switch without fooling yourself.
2023.04 - Forward+ Awesomeness in Unity URP
Forward+ in URP is not a magic switch. This module shows where classic Forward breaks at 8 real-time lights per object, when Forward+ starts to make sense, and why mobile memory bandwidth can still make deferred the wrong call.
2023.03 - Run-time Material Fusing
Runtime material fusing is what you do when batching dies because of material variants. Learn the vertex-attribute trick for colors/properties, the texture-atlas path for multiple textures, and the checks that prove you really recovered the batch win.
2023.02 - Run-time Static Batching - How?!
Runtime static batching is what you reach for when design adds procedural rooms, spawned props, or runtime layouts and your old fix stops applying. Learn when to use StaticBatchingUtility.Combine vs Mesh.CombineMeshes, and how to prove the draw-call win before you commit.
2023.01 - Static Batching Like You Never Saw
Static batching looks easy until it blows up your memory budget or silently fails. Learn when it helps, what Unity really builds under the hood, how Awake/Start can break it, and how to verify the result with Stats, Frame Debugger, and RenderDoc.
2022.12 - Exploring Low-Level GPU Metrics With SMM
Exploring Low-Level GPU Metrics With SMM: When GPU performance collapses, generic profiling views are often too high-level to explain why. You need low-level counters, or you stay stuck in expensive guess-and-check loops.
2022.11 - IL2CPP's Most Intimate Performance Secrets
IL2CPP's Most Intimate Performance Secrets: If your hot C# path runs thousands of times per frame, tiny IL2CPP details become real frame time.
2022.10 - Butchering Shaders for Performance
Butchering Shaders for Performance: Most shader slowdowns are not magic, they are expensive instructions repeated millions of times.
2022.09 - Rocket-Performance: From 0 to 90FPS+
Rocket-Performance: From 0 to 90FPS+: You do not jump from bad FPS to stable 90 by random tweaks. You get there by killing the right bottleneck, in the right order, with evidence instead of panic.
2022.08 - "Niche" Shader Tricks to Remove Costly Overdraw
"Niche" Shader Tricks to Remove Costly Overdraw: Overdraw is where your GPU starts burning cycles for pixels players never really see. Ignore it, and your game can fall off a frame-time cliff the moment effects stack up.
2022.07 - Huge Worlds, Huge Performance
Huge Worlds, Huge Performance: Huge worlds fail when you treat memory like it is infinite. If everything stays loaded, you hit a bottleneck wall in memory, loading, and frame stability long before your content roadmap is done.
2022.06 - Metrics: The Gathering
Metrics only matter if they drive decisions. This module shows how to set red/orange/green budgets, measure main vs render thread correctly, and automate repeatable Unity performance tests with markers, medians, and GC data.
2022.05 - Sexy Scripting: Events, Delegates & More
Events and delegates can look innocent and still feed the GC. This module shows the cached-delegate fix, the custom event-manager route, and the JSON overwrite/manual parsing moves that cut scripting allocs before they turn into hitching.
2022.04 - Dynamic Resolution & Upscaling: FSR, DLSS, TAAU & more
Dynamic resolution and upscaling are how you buy back GPU frame time without defaulting to a blurry disaster. This module shows the first support gates, the camera/pipeline setup, the Frame Debugger proof path, and the quality tradeoffs across TAAU, FSR, and DLSS.
2022.03 - MEM - Class vs Struct in Gamedev
MEM - Class vs Struct in Gamedev: stop repeating the stack-vs-heap myth and start profiling what actually hurts. This module shows when structs help, when copies bite back, and how a simple string path can jump from hidden GC debt to a measured fix.
2022.02 - Engineering a Consistent Profiling Scenario (CPS)
A Consistent Profiling Scenario is how you stop optimizing profiler noise. This module shows how to build one deterministic worst-case test, compare builds with real charts, and control CPU-frequency drift so your performance decisions are actually trustworthy.
2022.01 - Nuke Your Loading Times
Loading time starts at app tap, not when your splash screen feels done. This module shows Rubens 10-second-profiler trick, the 11-second Android proof, and one practical win: moving long audio clips from Decompress On Load to Streaming to claw back about 1.5 seconds.
2021.12 - Oculus Developer Hub, 'Sealed' Keyword, Overdraw Introduction, Incremental GC
2021 Unity Performance Taskforce lessons are now free for registered members, enjoy! Oculus Developer Hub gives you better visibility, `sealed` keeps inheritance under control, overdraw shows where the GPU is burning cycles, and incremental GC helps you avoid spikes when the frame budget is already
2021.11 - CommandFactory, == Overloading, RenderDoc Filtering, Hunting Allocs
2021 Unity Performance Taskforce lessons are now free for registered members, enjoy! CommandFactory, `==` overloading, RenderDoc filtering, and hunting allocs all attack a different kind of waste: unclear code, noisy captures, and garbage collector pressure. This month is about making the ugly stuf
2021.10 - KISS Dependency Injection, The CullingGroup API, Tile-Based Rendering, Preloading Expensive Shaders
2021 Unity Performance Taskforce lessons are now free for registered members, enjoy! Dependency injection keeps classes honest, the CullingGroup API helps you skip useless work, tile-based rendering keeps the GPU from grinding, and preloading costly shaders stops loading-time freezes. In this modul
2021.09 - KISS Transaction Pattern, Raycasting FTL, Fast Reflection Probes, Advanced Mipmapping Settings
2021 Unity Performance Taskforce lessons are now free for registered members, enjoy! Transaction patterns, raycasting FTL, fast reflection probes, and advanced mipmapping settings are all about the same thing: stop wasting cycles on work the player does not see. This month is where the small wins s
2021.08 - KISS Command Pattern, Physics Optimization, Affordable Shadows, Addressables Overview
2021 Unity Performance Taskforce lessons are now free for registered members, enjoy! The command pattern keeps gameplay flow under control, physics optimization keeps the simulation from burning time, affordable shadows keep lighting from getting silly, and the Addressables overview shows how to st
2021.07 - Performance Checklist Q&A, Character Animation, Forward vs Deferred Rendering, Cache Efficiency
2021 Unity Performance Taskforce lessons are now free for registered members, enjoy! This is a practical catch-all month: performance checklist Q&A, character animation, forward vs deferred rendering, and cache efficiency. If the scene looks fine but the frame budget still leaks, this is where you
2021.06 - Unity Accelerator, CPU Slicing, Squeezing RenderDoc, Texture Filtering & Mipmapping
2021 Unity Performance Taskforce lessons are now free for registered members, enjoy! Textures are everywhere, and that means texture filtering and mipmapping are not background details. This month also covers Unity Accelerator, CPU slicing, and squeezing RenderDoc so iteration stays fast without hi
2021.05 - Profiling, Stripping Shader Variants, Efficient Lightmap Settings, Texture Compression
2021 Unity Performance Taskforce lessons are now free for registered members, enjoy! Start by profiling so you know where your game is standing, then chase the bottleneck instead of guessing. The rest of the month goes after shader variants, efficient lightmap settings, and texture compression. In
2021.04 - Performance Mindset, DOTS, LODs, Memory Profiling
2021 Unity Performance Taskforce lessons are now free for registered members, enjoy! Bad performance is expensive. It hits reviews, platform targets, and the moment you leave it to the end, it turns into a late-stage cleanup problem. This opening month walks through the P3 mindset, DOTS, LODs, memo