Office Hours Recap – Developing for Handheld with AMD

Game dev can be hard. There’s a lot to learn, social networks to build, and always new problems to solve. Microsoft wants as many game developers to succeed as possible, and we want to help you on your journey. By creating an open and welcoming community space, one where you can make connections with real industry professionals and ask questions about the issues that are most important to you, we’re making more resources accessible to developers of all sizes from across the globe.

Each week, we invite an experienced game developer to join us, tell their story, and answer any questions you might have about their work. If you’d like to keep up with who will be joining us and what topic we’ll be covering, join our Discord server and keep an eye on the #announcements channel for calendar updates!

A few weeks ago, we welcomed a few of our friends over from AMD to join us and share their insights on handheld development, the challenges it can bring, and to share some tips and tricks about how to best optimize for the platform. They shared some excellent insights we’ve recapped below.

Our panel of guests included:

Terry Chen, a Developer Technology Engineer at AMD working on APUs and gaming handhelds, with a background in real-time rendering research.

Cristian Cutocheras, a Gaming Technology Engineer at AMD who works with game developers to help them get the most out of AMD GPUs. Cristian started his career as a video game developer, at that time on platforms like the original Xbox.

Alex Pecoraro, a GPU Dev Tech at AMD who has been with AMD for about 5 years. Before AMD Alex worked across various different graphics and gaming related fields such as video game streaming, mobile, and simulation.

Handheld Development Challenges

Q: What makes development for handheld devices different from PC or console?

A: The biggest difference comes down to battery-powered usage. Unlike traditional PCs or consoles, handheld users may not be connected to AC power while playing. This introduces several considerations:

- Uncapped frame rates can significantly drain battery life.

- Developers should consider capping frame rates in non-interactive scenarios like menus or loading screens.

- Handhelds typically use APUs (CPU + GPU on the same chip) with shared memory. Because the GPU and CPU are drawing from the same physical memory pool, the total amount of memory available may be lower than expected, since a dedicated video memory carveout is allocated to the GPU. This is also different from consoles, where most of the physical memory pool is available to both the CPU and the GPU. Additionally, the memory bandwidth of a handheld is likely to already be reduced compared to a desktop or console setup.

Q: How should developers approach power efficiency on handheld?

A: Prioritize stability first and power optimization second.

You should always make sure that the game runs reliably without crashes or visual corruption. Once stable, you can then explore optimization methods like reducing the polling frequency for network/device state checks, capping your FPS in non-interactive states, and adjusting graphical presets based on your device type.

Remember to do your QA testing on battery power instead of AC. AC power may trigger higher boost policies that mask performance or efficiency issues. Windows APIs can be used to detect when devices are plugged in versus running on battery.

Xbox handhelds may also support user-selectable power modes (e.g., Silent, Performance, Turbo), which developers can monitor—though reacting dynamically to these changes introduces added QA complexity.

AMD Tools and Techniques for Developers

Q: What tools should developers use to analyze GPU performance or debug crashes on AMD hardware?

A: Developer should start with the Radeon Developer Tools Suite (RDTS), which includes:

• - Radeon GPU Profiler (RGP) – for performance analysis
• - Radeon GPU Detective (RGD) – for crash analysis (e.g., TDRs)
• - Radeon Memory Visualizer (RMV) – for tracking memory allocation and usage

These tools can help identify whether textures are being stored in the GPU instead of system memory, find unused memory allocations, and check whether shader lines or rendering passes are responsible for GPU crashes.

We also recommend pairing RTDS with Microsoft tools such as PIX or GPUView. For custom engines, integrating the AGS library can allow developers to tag rendering passes with debug names, improving profiling in RGP and crash diagnostics in RGD.

Q: What are TDRs and why is it important to resolve them?

A: A TDR (Timeout Detection and Recovery) typically occurs when the GPU becomes stuck processing a workload and fails to respond.

Common causes include:

• - Resource misconfiguration
• - Improper descriptor setup
• - Engine-level rendering issues
• - Shader bugs (e.g., infinite loops)

TDRs are considered fatal issues because they will crash the game for end users. Rendering engineers are the most likely to encounter these when implementing new visual effects or working at the engine level.

Tips & Tricks

Q: Are there common optimization pitfalls developers should avoid?

A: Yes, particularly around memory allocation. Some developers attempt to create entirely separate resource pipelines for handheld devices. However, in practice, this doubles your code paths, expands your QA surface area, and introduces device-specific failures.

Instead, we recommend maintaining your standard desktop allocation pipeline unless extensive testing supports a handheld-specific implementation.

Q: Is there a recommended shader model for handheld?

A: No specific shader model is universally recommended. You should target whatever shader model is supported by your platform and development stack.

Q: What’s a high-impact optimization that improves battery life without frustrating players?

A: There are two key approaches. First, use reasonable graphical presets for handheld devices. Your goal should be to get your game running smooth over being visually impressive.

Q: Any common misconceptions when working with handhelds?

A: Memory allocation is the most often misunderstood. Unlike laptops using integrated GPUs, handhelds typically allocate multiple gigabytes of dedicated GPU memory by design (e.g., ~8GB on Xbox Ally X). You should avoid treating handheld GPU memory as extremely constrained in the same way you might on traditional integrated laptop GPUs, and treat them more like desktops with discrete GPUs.

Q: Any additional tips for handheld compatibility?

A: Built-in Xbox handheld controllers typically report as standard Xbox controllers, so making sure Xbox controller support is implemented can save valuable development time. GameInput API is also a consistent interface for input devices.

Also keep in mind that handhelds often feature High-DPI displays (e.g. 7” at 1080p+) and touchscreens. This makes UI scaling especially important. Consider increasing your button sizes where appropriate and always ensure your touch targets remain accessible. Be sure not to exclude other input sources when you detect a controller, since some users may prefer to play with keyboard and mouse.

Q: Where can developers get support from AMD?

A: Developers can find us on the AMD Developer Community or check out more tools and SDKs on GPUOpen.

Thanks to Ken Mitchell and Jonas Gustavsson for their assistance.