How do I know if my game has a device-specific bug?

Look at the device breakdown of your crashes and watch for problems you can't reproduce. The defining sign is clustering: crashes or problems concentrated on a particular device model, GPU family, or OS version while other players are fine, a device-specific bug by definition hits specific hardware or software, so clustering on one configuration and not others indicates one. An indirect sign is complaints or reports about a problem you can't reproduce on your own devices, because the bug is on hardware or software you don't have. And the confirming sign is the pattern in the device breakdown itself, when you look at a crash's device distribution, the reports concentrate on a specific configuration. To see all this, capture crashes with device, GPU, and OS context from the field, which is what makes device-specific bugs visible, without it, a crash hitting only one GPU family looks like random scattered reports, but with it, the clustering on a specific configuration is obvious. So if your crashes cluster on a particular device, GPU, or OS version, or you're getting complaints you can't reproduce, you have a device-specific bug, and the device pattern not only confirms it but usually points at the cause (a GPU issue for GPU clustering, an OS issue for OS-version clustering, a memory issue for low-RAM clustering), which is why capturing rich device context is essential for finding and diagnosing device-specific bugs.

Why does my game crash on some devices but not others?

Because those devices differ from yours, and from each other, in a way that triggers a crash your hardware doesn't. Common causes are GPU and graphics-driver differences (a rendering path that fails on one GPU family), memory limits (low-memory devices crash where yours has headroom), OS-version differences (an API behaves differently or is missing), and other hardware quirks. Your dev machine is just one configuration, so any crash specific to a different configuration is invisible to you, and across the huge range of devices your players use, some configuration will hit a problem your hardware and OS don't exhibit. This is why crashes can hit some devices but not others (or not yours): the crash is triggered by a specific hardware or software condition present on some devices and absent on others. The way to see and prevent these device-specific crashes is capturing crashes with device context from the field: when crashes cluster on a specific device type, GPU, or OS version, the pattern both confirms it's device-specific and usually points at the cause, so you can fix it for the affected hardware. The device context (model, GPU, OS, memory) is often the key clue, a crash concentrated on one GPU family suggests a graphics or driver issue, on low-memory devices an out-of-memory problem, on a specific OS version an API or platform-behavior change. So your game crashes on some devices but not others because device-specific conditions (GPU, driver, memory, OS) trigger the crash on some configurations and not others, and the way to find and fix these is to capture crashes with device context (revealing the clustering and the cause) rather than trying to reproduce them on your machine, which won't show the crash since it's a different configuration. Testing on a range of real devices (especially low-end and varied) catches some before launch, but since you can't own every device, field capture with device context is what reveals the device-specific crashes across the full range of hardware your players use.

How do I fix a bug that only happens on certain devices?

Use the device pattern to find and fix the cause, since on device-specific bugs the device pattern is often the diagnosis. First, capture crashes with rich device context (model, GPU, OS, memory) from the field, since the bug is on hardware you may not have, field capture is how you see it at all. Then read the clustering pattern, which usually narrows the cause: crashes concentrated on one GPU family point toward a graphics or driver-interaction issue, on low-memory devices toward an out-of-memory problem, on a specific OS version toward an API or platform-behavior change, on a device family toward a hardware-specific quirk. This turns a baffling 'why does it crash on that device' into a specific hypothesis about a specific subsystem on specific hardware, focusing your investigation enormously rather than searching your whole codebase blind. Fix the cause for the affected configuration, e.g. handle the GPU's rendering difference, reduce footprint for low-memory devices, handle the OS version's API difference. Then verify in the field: watch whether the crash stops on those devices on the fixed version (per-version, device-filtered tracking confirms it), since you often can't reproduce the bug yourself to confirm locally. If you can get access to a device matching the affected configuration (or a similar one), reproducing the bug there helps, but for many device-specific bugs you fix from the captured evidence and device pattern and verify in the field. So you fix a device-specific bug by capturing it with device context (to see it), using the device pattern to identify the cause (the clustering points at what kind of problem and where), fixing the cause for the affected configuration, and verifying in the field (watching the crash stop on those devices), rather than trying to reproduce it on your own machine (which won't show it, since it's a different configuration). The device context is the key, it's what makes a device-specific bug, invisible and baffling on your machine, into a findable, diagnosable, fixable problem by revealing both that it's device-specific and what configuration and cause are involved.

Signs Your Game Has a Device-Specific Bug

Quick answer: Watch for crashes clustering on a particular device, GPU, or OS version while others are fine, complaints you can't reproduce, and a clear pattern in the device breakdown. Device-specific bugs are invisible on your machine but obvious in device data.

A device-specific bug, one that hits a particular device, GPU, or OS version while everything else is fine, is baffling without device data and obvious with it. Here are the signs your game has a device-specific bug.

Crashes or Problems Clustering on a Particular Device, GPU, or OS Version

The defining sign is clustering: crashes or problems concentrated on a particular device model, GPU family, or OS version while other players are fine. A device-specific bug, by definition, hits specific hardware or software, so if your crashes cluster on one configuration and not others, you have a device-specific bug.

Bugnet captures device, GPU, and OS context with crashes, so clustering on a specific configuration is visible. Crashes clustering on a particular device, GPU, or OS version is the defining sign of a device-specific bug, and capturing device context is what makes it visible, since without it, a crash hitting only one GPU family looks like random scattered reports.

Complaints You Can't Reproduce on Your Own Devices

An indirect sign is complaints or reports about a problem you can't reproduce on your own devices, because the bug is specific to hardware or software you don't have. If players report a crash or bug that never happens for you, it's likely device-specific, occurring on a configuration outside your test set.

Bugnet captures crashes with device context from the field, so the configurations you can't test still report their problems. Complaints you can't reproduce are a sign of a device-specific bug (on hardware you don't have), and field capture with device context is how you see and diagnose them, since the device pattern reveals the configuration the bug is specific to.

A Clear Pattern in the Device Breakdown

The confirming sign is the pattern itself: when you look at the device breakdown of a crash, the reports concentrate on a specific configuration. A device-specific bug shows a clear pattern, one GPU family, one OS version, one device model, that points both to its device-specificity and often to its cause.

Bugnet shows the device breakdown of grouped crashes, so the pattern is visible at a glance. A clear pattern in the device breakdown confirms a device-specific bug and points at the cause (a GPU issue for GPU clustering, an OS issue for OS-version clustering, a memory issue for low-RAM clustering), turning a baffling crash into a specific, diagnosable problem.

Watch for crashes clustering on a particular device, GPU, or OS version while others are fine, complaints you can't reproduce, and a clear pattern in the device breakdown. Device-specific bugs are invisible on your machine but obvious in device data.