Runtime Optimizer Part 2 - GPU Textures and Mixed Reality | Performance Series
In Part 2 of our technical deep dive, Meta software engineers Jay Hsia and Nico Lopez move from high-level profiling into real GPU problem solving for mixed reality on Meta Quest. You’ll see how they use the Runtime Optimizer to study Passthrough projects and large texture collections, then turn that data into shader changes and day-to-day profiling routines that keep performance predictable. 💡After viewing this session, you’ll understand how to: Configure Runtime Optimizer experiments for Passthrough and mixed reality projects. Choose between Texture 2D Array and atlases for large texture sets. Stream high resolution textures in smaller chunks. Move UV work into the vertex shader and add profiler markers. 🎬 CHAPTERS 👋 INTRODUCTION 🕒 00:00 - Welcome & Agenda Overview 🛠️ DEBUGGING & MIXED REALITY 🕒 03:19 - Profiling Passthrough & Mixed Reality 🕒 06:24 - Texture Arrays vs. Texture Atlases 🎨 Shader & Code Optimization 🕒 12:52 - Fixing Texture Fetch Stalls (Vertex Shaders) 🕒 16:52 - Best Practices for Profiler Markers ✅ FINAL THOUGHTS 🕒 20:20 - Recap & Next Steps 📖 OPTIMIZATION EXAMPLES REFERENCED IN THIS VIDEO 🔖 Meta Quest Runtime Optimizer Docs: https://developers.meta.com/horizon/documentation/unity/unity-quest-runtime-optimizer/ 🔖 Unity Profiler Documentation: https://docs.unity3d.com/Manual/Profiler.html 📚 RESOURCES ➡️ Developers Blog: https://developers.meta.com/resources/blog/ ➡️ Meta Quest Developer Hub: https://developers.meta.com/horizon/documentation/unity/ts-mqdh/ 🔗 CONNECT WITH US ➡️ Sign up to get the latest news from Meta Horizon: https://developers.meta.com/horizon/newsletter 💡 LEARN ABOUT THE META HORIZON START PROGRAM The Meta Horizon Start program provides intermediate and advanced developers with the resources, hands-on support, and expert guidance needed to accelerate their app development. Join a thriving community to get the tools and go-to-market guidance you need to successfully deploy and grow your app on Meta Horizon OS. Apply to Start today: https://developers.meta.com/horizon/discover/programs/start
Fix Performance Bottlenecks with the Meta Quest Runtime Optimizer | Performance Series
In this technical deep dive, Meta Software Engineers Jay Hsia and Nico Lopez walk you through the complete workflow for identifying and resolving latency issues in real-time using the Meta Quest Runtime Optimizer. If you’re looking to optimize your build, this session is an essential resource for fixing performance bottlenecks prior to launch. 💡After viewing this session, you’ll understand how to: Enable and configure Runtime Optimizer overlay in Unity Interpret real-time metrics to distinguish between CPU and GPU bottlenecks Apply actionable insights to reduce draw calls and texture overhead 🎬 CHAPTERS 👋 INTRODUCTION 🕒 00:00 - Introduction to the Performance Series & Runtime Optimizer 🕒 01:52 - The Optimization Profiling Funnel 🛠️ RUNTIME OPTIMIZER SETUP 🕒 05:31 - Core Concepts of the Runtime Optimizer 📉 ANALYZING METRICS 🕒 09:32 - Bottleneck Analysis: Finding What's Expensive 🕒 15:27 - What-If Analysis: Quantifying Performance Costs 🛠️ LIVE DEMO & WORKFLOW 🕒 20:51 - Live Demo: Putting the Tool into Practice 🕒 26:12 - Final Recap and Recommended Workflow 📖 OPTIMIZATION EXAMPLES REFERENCED IN THIS VIDEO 🔖 Meta Quest Runtime Optimizer Docs: https://developers.meta.com/horizon/documentation/unity/unity-quest-runtime-optimizer/ 🔖 Unity Profiler Documentation: https://docs.unity3d.com/Manual/Profiler.html 📚 RESOURCES ➡️ Developers Blog: https://developers.meta.com/resources/blog/ ➡️ Meta Quest Developer Hub: https://developers.meta.com/horizon/documentation/unity/ts-mqdh/ 🔗 CONNECT WITH US ➡️ Sign up to get the latest news from Meta Horizon: https://developers.meta.com/horizon/newsletter 💡 LEARN ABOUT THE META HORIZON START PROGRAM The Meta Horizon Start program provides intermediate and advanced developers with the resources, hands-on support, and expert guidance needed to accelerate their app development. Join a thriving community to get the tools and go-to-market guidance you need to successfully deploy and grow your app on Meta Horizon OS. Apply to Start today: https://developers.meta.com/horizon/discover/programs/start
The Complete List of Sample Unity VR Projects
Hey guys, I wanted to put together a list of my favorite sample projects that you can grab and learn from. In my opinion, these projects are pure goldmines, they don’t just showcase design principles around specific features but also provide direct examples of how to use them, which is especially important right now for something like a hackathon. For an even larger collection of Meta samples, see the GitHub list of all Meta sample repos here: https://github.com/orgs/oculus-samples/repositories?type=all Let’s start with our first category, the interaction samples. Interaction Samples Meta XR All-In-One (Interaction SDK) Sample Links: https://github.com/oculus-samples/Unity-InteractionSDK-Samples https://assetstore.unity.com/packages/tools/integration/meta-xr-all-in-one-sdk-269657 Description: A comprehensive demo from Meta’s XR Interaction SDK featuring core VR interactions like poking, grabbing, raycasting, UI, and locomotion, all working together. Perfect to understand how to integrate both hands and controllers in one system. First Hand Link: https://github.com/oculus-samples/Unity-FirstHand Description: A full VR game demo focused on hand-tracked interactions. It showcases a complete Unity experience using the Interaction SDK with hand tracking as the main input and controller fallback. XR Interaction Toolkit Examples Link: https://github.com/Unity-Technologies/XR-Interaction-Toolkit-Examples Description: Unity’s official XR Interaction Toolkit samples showing how to implement locomotion, selection, grabbing, and UI interactions. A solid starting point for setting up XR Origin and interactor/interactable components. Move Fast Link: https://github.com/oculus-samples/Unity-MoveFast Description: A fast-paced VR fitness demo using hand tracking and the Interaction SDK. The sample shows how to build an energetic workout game with responsive, punch-based interactions. Whisperer Link: https://github.com/oculus-samples/voicesdk-samples-whisperer Description: A voice-controlled VR experience demonstrating the Meta Voice SDK. Use voice commands as part of gameplay to learn how to integrate real-time voice recognition into your own projects. Tilt Brush (Open Brush) Link: https://github.com/icosa-foundation/open-brush Description: An open-source continuation of Google’s Tilt Brush. Lets users paint and sculpt in 3D space — an excellent reference for creative VR tools and spatial drawing. Multiplayer & Social Samples VR Multiplayer Sample (Unity XRI) Link: https://docs.unity3d.com/Packages/com.unity.template.vr-multiplayer@2.0/manual/index.html Description: Unity’s official multiplayer VR template featuring a prebuilt scene, avatars, and networking setup using Netcode for GameObjects. Great for learning multi-user interactions in VR. Mixed Reality Multiplayer (XR Multiplayer) Sample Link: https://docs.unity3d.com/Packages/com.unity.template.mr-multiplayer@1.0/manual/index.html Description: A tabletop MR multiplayer demo that includes avatars, voice chat, and shared AR/VR spaces. Features games like balloon slingshot and chess while teaching MR networking and colocation concepts. Tiny Golf Link: https://github.com/Meta-Horizon-Start-Program/Tiny-Golf Description: A free-to-play multiplayer mini-golf VR game created for the Meta Start program. Demonstrates basic physics, scoring, and networked multiplayer. Ultimate Glove Ball Link: https://github.com/oculus-samples/Unity-UltimateGloveBall Description: A VR e-sport showcase demonstrating multiplayer, avatars, voice, and in-app purchases. Integrates Photon networking and Oculus social APIs, making it a great reference for social competitive games. Spirit Sling Link: https://github.com/oculus-samples/Unity-SpiritSling Description: A social MR tabletop game letting players place a shared game board in real space and invite friends to join. Highlights Avatars SDK and MR colocated play. Decommissioned Link: https://github.com/oculus-samples/Unity-Decommissioned Description: A social-deduction VR game inspired by titles like Among Us. Shows how to handle multiplayer lobbies, Oculus invites, and social APIs in a networked Unity project. Mixed Reality (MR) Samples A World Beyond (Presence Platform Demo) Link: https://github.com/oculus-samples/Unity-TheWorldBeyond Description: A full MR showcase combining Scene Understanding, Passthrough, hand tracking, voice input, and spatial audio. A must-see for developers building immersive MR scenes blending real and virtual spaces. Phanto (MR Reference App) Links: https://github.com/oculus-samples/Unity-Phanto https://developers.meta.com/horizon/blog/phanto-unreal-showcase/ Description: An MR reference app focused on environmental awareness. Uses the Scene Mesh and MR APIs to blend gameplay with real-world geometry. Unity Discover (featuring Drone Rage and others) Links: https://www.meta.com/en-gb/experiences/discover/7041851792509764/ https://github.com/oculus-samples/Unity-Discover Description: A collection of MR showcase mini-experiences like Drone Rage. Demonstrates MR features including Passthrough, Spatial Anchors, and Shared Anchors in various game prototypes. MR Motifs Link: https://github.com/oculus-samples/Unity-MRMotifs Description: A library of MR “motifs”, small, reusable templates showcasing mechanics such as passthrough transitions, colocated multiplayer, and instant content placement. Cryptic Cabinet Link: https://github.com/oculus-samples/Unity-CrypticCabinet Description: A short MR escape-room experience that adapts to your room’s layout. Demonstrates interactive storytelling in mixed reality using environmental awareness. Passthrough Camera API Samples Link: https://github.com/oculus-samples/Unity-PassthroughCameraApiSamples Description: A sample project demonstrating how to access and process Quest’s Passthrough camera feed for effects, object detection, and image manipulation. Tool and Utilities Asset Streaming Link: https://github.com/oculus-samples/Unity-AssetStreaming Description: An open-world streaming sample that shows how to dynamically load content using Addressables and LOD systems — ideal for maintaining performance in large VR environments. Shader Prewarmer Link: https://github.com/oculus-samples/Unity-ShaderPrewarmer Description: A utility sample that preloads shader variants at startup to eliminate hitching or stutters when shaders first compile — an important optimization for smooth VR performance. Complete Game Showcase Northstar Link: https://github.com/oculus-samples/Unity-NorthStar Description: A complete VR game showcasing advanced interaction and visual technique for VR. Featuring rope physics, narrative story telling, lip sync and more.VR Optimization in Unity - A Complete List of Tools and Resources
Hey guys, I wanted to put together a list of tools and resources for optimizing a VR game in Unity. As the process can be tricky (profiling, debugging, etc.) and there are a lot of different tools, I hope this helps show the different use cases and workflows. This list is a work in progress, so if you want to add your favorites or ask questions, please do it here. :) OVERVIEW OF OPTIMIZATION TOOLS In-Editor Stats Window Documentation: https://docs.unity3d.com/Manual/RenderingStatistics.html Shows real time rendering statistics (triangles, draw calls, batches) in the Game View to quickly spot bottlenecks. Profiler Documentation: https://docs.unity3d.com/Manual/Profiler.html Records CPU, GPU, memory, and other subsystem usage to identify hotspot frames or assets. Project Validation and Project Setup Tool Documentation: https://developers.meta.com/horizon/documentation/unity/unity-upst-overview/ Test a registry of rules called Configuration Tasks (xr setup and optimization) and provide default rules to make your project Meta Quest ready. Quest Runtime Optimizer https://developers.meta.com/horizon/documentation/unity/unity-quest-runtime-optimizer/ Provides real time analysis and actionable insights to optimize performance on device. Unity Project Auditor https://docs.unity3d.com/Packages/com.unity.project-auditor@1.0/manual/index.html Audits your Unity project for performance and best practice compliance. Frame Debugger Documentation: https://docs.unity3d.com/Manual/FrameDebugger.html Step through draw calls and frame rendering to find overdraw or inefficient passes. Auto VR Optimizer https://assetstore.unity.com/packages/tools/utilities/auto-vr-optimizer-318687 Automated utility to apply common VR optimization settings to your Unity project. Memory Profiler and Profile Analyzer Documentation: https://unity.com/how-to/use-memory-profiling-unity Capture memory snapshots, compare them, and analyze fragmentation or leaks. Outside Editor OVR Metrics Tool https://developers.meta.com/horizon/downloads/package/ovr-metrics-tool/ Capture performance metrics on device, including CPU, GPU, and memory. Meta Quest Developer Hub https://developers.meta.com/horizon/downloads/package/oculus-developer-hub-win/ Deploy to device, profile, view logs, and measure thermal and throttling behavior. RenderDoc Documentation: https://developers.meta.com/horizon/documentation/unity/ts-renderdoc-for-oculus/ Graphics frame capture and inspection of draw calls, states, and textures. Perfetto Guide: https://developers.meta.com/horizon/documentation/unity/ts-perfettoguide Open source system tracing for CPU, GPU, and OS events. Immersive Debugger https://developers.meta.com/horizon/documentation/unity/immersivedebugger-overview/ Resources Profiling and debugging tools in Unity https://unity.com/how-to/profiling-and-debugging-tools Ultimate Guide to Profiling Unity Games (e book) https://unity.com/resources/ultimate-guide-to-profiling-unity-games-unity-6 Meta XR Performance Best Practices https://developers.meta.com/horizon/documentation/unity/unity-best-practices-intro Optimization for web, XR, and mobile games in Unity 6 (YouTube) https://youtu.be/2J0kDtUGlrY?si=DfiogFWQronhdowQ Unity Optimization E book (Unity 6 edition) https://unity.com/resources/mobile-xr-web-game-performance-optimization-unity-6 Valem Tutorials How to Optimize VR Game Part 1 https://www.youtube.com/watch?v=BeB9Cx_msKA How to Optimize VR Game Part 2 https://www.youtube.com/watch?v=Jgf3F--VoPg How to Optimize VR Game Part 3 https://youtu.be/qm4-6zHkanM Hope this helps. :) What do you think? Do you have other tools or resources that should be on this list?What's Trending in VR Development? | Tech, Content & Community
What does it take to succeed as a VR developer today? Join renowned YouTube creators and expert developers Dilmer Valecillos, Quentin Valembois, and Roberto Coviello in a roundtable discussion hosted by Darby Blaney. They explore the latest tech trends, such as the Passthrough Camera Access API and essential optimization tools, and share proven strategies for accelerating your workflow, creating content, and building an engaged community. 💡 In this session, you’ll learn: Insights into the latest VR technologies, including the creative potential of the Passthrough Camera Access API and underutilized tools like the Immersive Debugger. Best practices for optimizing performance and accelerating your development workflow using tools like Building Blocks and open-source projects. Proven strategies for building a personal brand, creating effective content, and fostering an engaged community around your work. 🎙️ HOST Darby Blaney, Metaverse Program Manager, Start Lead 🎙️ SPEAKERS Roberto Coviello, Software Engineer Quentin Valembois, Start Mentor Dilmer Valecillos, Developer Advocate ▶️ VIDEO CHAPTERS 👋 Introduction 🕒 00:00 - Welcome & Host Introduction 🕒 00:37 - Meet the Panelists 🚀 Part 1: The Developer Journey 🕒 02:13 - Panelist Origin Stories: How They Got Started in VR ⚙️ Part 2: Tech Trends & Tools 🕒 08:22 - Tech Trend: The Passthrough Camera API & AI 🕒 13:12 - Underutilized Tools: Immersive Debugger & Runtime Optimizer 🕒 17:12 - Best Practices for Performance Optimization 🕒 19:41 - Accelerating Development with Building Blocks & Open-Source Samples 📈 Part 3: Content & Community Growth 🕒 23:20 - Strategies for Content Creation & Building a Personal Brand 🕒 28:18 - The Role of Community Feedback in Development 🕒 32:47 - Inside the Meta Start Mentor Program ✅ Conclusion 🕒 35:06 - Final Thoughts & Thank You 📚 RESOURCES ➡️ Dilmer’s YouTube channel: https://www.youtube.com/@dilmerv ➡️ Valem’s YouTube channel: https://www.youtube.com/@ValemTutorials ➡️ Roberto’s YouTube channel: https://www.youtube.com/@xrdevrob ➡️ Spatial Scanner project available on GitHub: https://github.com/meta-quest/Meta-Spatial-SDK-Samples ➡️ Developers Blog: https://developers.meta.com/resources/blog/ ➡️ Meta Quest Developer Hub: https://developers.meta.com/horizon/documentation/unity/ts-mqdh/ 🔗 CONNECT WITH US ➡️ Sign up to get the latest news from Meta Horizon: https://developers.meta.com/horizon/newsletter 💡 LEARN ABOUT THE META HORIZON START PROGRAM The Meta Horizon Start program provides intermediate and advanced developers with the resources, hands-on support, and expert guidance needed to accelerate their app development. Join a thriving community to get the tools and go-to-market guidance you need to successfully deploy and grow your app on Meta Horizon OS. Apply to Start today: https://developers.meta.com/horizon/discover/programs/startMaster the Meta Developer Dashboard | Boost Engagement & Performance
You’ve launched your app—now what? Join Product Manager Dan Zhao and Partner Engineer Akash Phadtare for a comprehensive tour of the Meta Developer Dashboard, your command center for long-term success. This session provides a practical guide to the dashboard's most powerful tools, showing you how to deepen player engagement while also optimizing app performance. 💡 In this session, you’ll learn: How to use tools like Developer Posts, Notifications, and Destinations to increase player engagement and retention. How to diagnose performance issues and identify growth opportunities using Benchmarks, Funnel Analytics, and Crash Reporting. Best practices for implementing and managing add-on content (IAPs/DLCs) and a guide to reading crash logs to fix bugs faster. 🎙️ SPEAKERS Akash Phadtare, Partner Engineer Dan Zhao, Product Manager ▶️ VIDEO CHAPTERS 👋 Introduction 🕒 00:00 - Welcome & Speaker Introductions 🕒 00:47 - Agenda Overview 📈 Part 1: Deepening Player Engagement 🕒 02:39 - Why Engagement is the Most Important Metric 🕒 03:58 - Using Developer Posts for Updates & Communication 🕒 05:01 - A Guide to User Notifications & Targeting 🕒 07:23 - Using Destinations for Rich Presence & Discovery 🕒 09:07 - Managing User Reviews & Setting Alerts 🕒 11:15 - Technical Deep Dive: Implementing Destinations & Group Presence 🕒 14:25 - Technical Deep Dive: Implementing User Notifications 📊 Part 2: Analytics & Performance Optimization 🕒 17:11 - Using Analytics to Prioritize Your Work 🕒 17:41 - Benchmarks: Compare Your App's Performance 🕒 18:59 - Alerting: Set Custom Thresholds for Key Metrics 🕒 20:02 - Funnel Dashboard: Understanding User Conversion 🕒 21:06 - Crash Reporting: Understanding Real-World Performance 🕒 22:34 - Technical Deep Dive: How to Upload Debug Symbols & Read Stack Traces 💰 Part 3: Add-on Content & Monetization 🕒 27:13 - Overview: Consumables, Durables, and DLCs 🕒 29:19 - How to Test IAPs with Test Users & Credit Cards 🕒 29:55 - Technical Deep Dive: Server-to-Server APIs for Purchases 🕒 31:28 - Conclusion & Final Recommendations 📚 RESOURCES ➡️ Developers Blog: https://developers.meta.com/resources/blog/ ➡️ Meta Quest Developer Hub: https://developers.meta.com/horizon/documentation/unity/ts-mqdh/ 🔗 CONNECT WITH US ➡️ Sign up to get the latest news from Meta Horizon: https://developers.meta.com/horizon/newsletter 💡 LEARN ABOUT THE META HORIZON START PROGRAM The Meta Horizon Start program provides intermediate and advanced developers with the resources, hands-on support, and expert guidance needed to accelerate their app development. Join a thriving community to get the tools and go-to-market guidance you need to successfully deploy and grow your app on Meta Horizon OS. Apply to Start today: https://developers.meta.com/horizon/discover/programs/startVR 103: Preparing Your App for the Meta Horizon Store
Join our team of experts in this Meta Connect 2025 series as they guide you through the fundamentals of VR development. You’ll learn how to start your project in Unity using Meta’s SDKs, explore essential building blocks for creating immersive experiences, and follow step-by-step instructions to deploy your first VR app. Whether you’re new to VR or looking to expand your skills, this series offers practical insights and hands-on demonstrations to help you succeed in building for Meta’s VR platforms. In the final session of this series, Jake Steinerman guides you through all of the steps to getting your app ready to publish on the Meta Horizon Store, and shares tips on finding and building your community. Join him in walking your app through the steps of passing VRCs, beta testing, building out a Product Detail Page, and finally, publishing your app. Your VR app is built—now let’s get it ready for the Meta Horizon Store. This launch session will guide you through everything from passing Virtual Reality Checks (VRCs) and effective beta testing to building a strong community and optimizing your product detail page. Learn proven strategies for a smooth submission, launch, and post-launch, featuring real-world examples and actionable tips to help your app thrive from day one.
Understanding App Requirements & Distribution on the Meta Horizon Store
We’re here to support you every step of the way as you build on our platform. It’s important to us that you have access to the best resources and guides to navigate our platform requirements so your apps can reach distribution and monetization even faster. With the Trusted Developer Essentials Program (TDE), we offer a free collection of resources led by Meta experts and hosted on the Data Protocol Platform. TDE covers topics like the developer journey, the app submission process, VRCs (all of our technical requirements to get your app published on the Horizon Store), privacy policy, Age Group Self-Certification, content guidelines, how to navigate Data Handling, how to submit your Data Use Checkup, and more. We’re always expanding TDE to include more helpful topics to make app publishing as easy as possible. Look out for new resources throughout the year, and please let us know if there are any materials or topics you’d like to see explained by filling out the Data Protocol survey or replying in this post—we’re always looking for more ways to help! An App's Journey Through Meta's Requirements Use this interactive flow-chart to understand the key milestones and requirements your app will encounter on its journey, from development to submission. Understanding Meta's Content Guidelines Understand the principles that determine what content is allowed and what content is prohibited under Meta’s Content Guidelines with this video. How to Pass the Most Commonly Failed VRCs Avoid common pitfalls by reviewing the most frequent VRC failures and how to address them effectively in our How to Pass the Most Commonly Failed VRCs resource guide. Boosting Conversion on the Meta Horizon Store Learn tips for crafting strong descriptions, screenshots, and trailers that help your app stand out and convert users in our course on Boosting Conversion on the Meta Horizon Store and read our guide on Crafting a Product Details Page (PDP) that converts. Driving Discoverability with Metadata Learn how to use metadata to increase your app’s visibility and reach the right audience in this video resource. Meta Horizon TDE Channel For additional educational resources on the Data Protocol platform, please visit our Meta Horizon TDE Channel.
[Performance Clinics] Most Common Bottlenecks
Hi all, angelsin here! Over the past couple months I have been running the Performance and Optimization clinic where I have had a chance to look at projects from the community and I wanted to share a breakdown of common performance bottlenecks I have seen, particularly in Unity, though many of these apply across engines. CPU-Bound Bottlenecks When your application is CPU-limited, the frame time is constrained by tasks that must complete on the main thread before rendering can proceed. Some frequent culprits: 1. Excessive Use of Update() A high volume of Update() calls can lead to significant per-frame overhead. Even empty or lightweight updates add up. Centralizing logic or adopting an event-driven architecture can reduce overhead. 2. Verbose Logging (Debug.Log, print) in Runtime Builds Logging per frame, especially within tight loops or frequent callbacks, adds unnecessary CPU and I/O overhead. Always disable or strip debug output in production builds. 3. Synchronous Operations on the Main Thread Blocking operations such as asset loading, file I/O, or network requests should never run on the main thread. Use asynchronous APIs or offload to worker threads when possible. 4. High Garbage Collection Pressure Frequent allocations (e.g., via new, string concatenations, LINQ) can cause GC spikes that result in frame drops. Profiling tools like Unity’s Memory Profiler can help identify hot allocation paths. Object pooling and reuse patterns are critical in VR. GPU-Bound Bottlenecks GPU limitations often arise from rendering complexity or shader overhead. These can manifest as reduced frame rates, late frames, or motion stutter—particularly problematic in VR where latency is noticeable. 1. Overly Complex Shaders Fragment-heavy shaders, excessive dynamic branching, high instruction count, or unoptimized lighting models can degrade performance rapidly. Use shader variants and fallback techniques, and test on target GPU hardware. Remember that the Quest is just specialized mobile hardware 2. High Polygon Count / Geometry Throughput High vertex counts or excessive draw distances increase vertex shader load. Implement LODs, frustum and occlusion culling where applicable. 3. Excessive Draw Calls State changes (materials, shaders, meshes) are expensive. Use static and dynamic batching, GPU instancing, and texture atlases to reduce draw call count. Tools like Unity’s Frame Debugger or GPU profilers can help diagnose this. 4. Screen-Space Post-Processing Effects Effects like TAA, SSAO, bloom, and depth-of-field can be expensive, especially at VR resolutions. Evaluate the performance cost vs. visual gain, and ensure effects are configured for stereo rendering (some aren’t by default). 5. Overdraw and Transparency Transparent geometry (particles, UI, decals) contributes to overdraw and increased fragment workload. Reduce transparency layers, sort particles efficiently, and consider depth pre-pass strategies. 6. Expensive Particle Systems Particle effects with large numbers of particles, expensive materials, or high update rates can saturate both CPU (emission, update) and GPU (overdraw, shading). Bake or optimize where possible, and avoid full-screen effects relying on particles. Best Practices Profile early and often using tools like Unity Profiler, RenderDoc, Meta Runtime Optimizer, and the MQDH. Always remember to check the timeline view as well as to deep profile if you cannot find the problems Always test on target hardware under worst-case scene conditions. Use GPU and CPU frame timing breakdowns to correctly identify the bottleneck domain before optimizing. Would love to hear what others have run into in real-world VR projects. Are there any less obvious bottlenecks you've encountered, or tools you’ve found indispensable during optimization? Looking forward to hearing your insights, and be sure to keep an eye on the Events on the Discord where we will continue to have Performance and Optimization clinic hours if you want to drop by for help. -SidneyIntroduction to Profiling & Optimization
Hi All, angelsin here. In my first workshop “Introduction to Profiling and Optimization” we did a bit of a live demo. Here's a recording of the session, but if you want a quick summary of the information, keep reading! Profiling in Unity refers to the process of analyzing how your game performs. It helps developers identify bottlenecks, optimize code, and improve overall performance. The key takeaways are: Profile first Profile often Profile on device Why should you profile before optimizing? Identify Bottlenecks: Profiling helps you pinpoint exactly where your game spends most of its time and resources. Avoid Premature Optimization: Without profiling data, it's easy to optimize parts of the code that don't actually contribute significantly to performance issues. Set Clear Goals: Profiling provides concrete metrics to measure against when optimizing. Why should you profile after making changes? Verify Improvements: Profiling allows you to see if the optimizations you made actually improved performance, or if they introduced new issues. Iterative Improvement: By regularly profiling and analyzing results, you can iteratively improve your game's performance over time. Avoid Over-Optimization: Continuous profiling helps prevent developers from getting carried away with optimization efforts that don't provide tangible benefits. Why should you profile your game on the actual device? Real-World Performance: Editor profiling provides a different environment from the real device, which can lead to discrepancies between performance metrics. Device-Specific Issues: Profiling on the device helps identify issues that may only occur on specific hardware or software configurations. Hitting your VRC targets: Meta is going to do their testing on device, and you should too. If you notice that your game's frame rate drops significantly during certain scenes or gameplay modes, using the Profiler Window to analyze CPU and memory usage can help identify whether it’s due to heavy script execution, excessive asset loading, or inefficient rendering techniques. This insight allows developers to make targeted optimizations. To get started with profiling in Unity, open the Profiler Window and begin analyzing your game's performance. Experiment with different scenes and gameplay modes to identify areas for improvement. Utilizing the Timeline tab, as well as the Hierarchy tab is important because each can give you insights that the other does not. Additionally if it seems like its hard to track down where exactly problems are coming from, then enabling deep profiling can really help you dig into exactly what methods are causing the biggest problems After making changes, always profile again to verify if the optimizations were effective or introduced new issues. Finally, ensure you are profiling on the actual device rather than just in the editor to get accurate performance metrics and avoid hardware-specific issues. The editor is great for getting the shape of the problem, but your computer is probably many times more powerful than the device, and you might be using different graphics libraries as well. It often makes sense to start out profiling in the editor and then verify problems on device. For more detailed guidance, consider checking out Unity’s official documentation or online tutorials on best practices for optimization. If you want a more hands on approach I do host a performance clinic on the Start program discord once a week and I am happy to go over these profiles with you. -Sidney
