What are the best practices for crash reporting in Unity?

Capture both managed exceptions (C# errors) and native crashes (engine or plugin level) automatically from the field, since a Unity game can fail at either layer and a setup catching only one misses a whole class of failures, and field capture sees the crashes on players' hardware that the editor can't. Include device, OS, and build version with every report, since Unity crashes are often device-specific and the context (especially device information) is what makes them diagnosable, frequently pointing at the cause, and lets you verify fixes per version. Group crashes by signature so many reports of the same crash collapse into one ranked issue (making the volume manageable and prioritized), and track per version so regressions are caught (a new build crashing more) and fixes verified (a crash stopping on the build that fixed it). Unity games run across a huge range of devices and the crashes that matter happen on players' hardware, not in your editor, so the practices serve capturing the full crash picture (both layers, from the field), with the context to act on it (device, version), organized for action (grouped, ranked, per-version), which is what makes Unity crash reporting effective given the fragmentation and the editor-versus-build gap.

Why does my Unity game crash on players' devices but not in the editor?

Because the editor is one consistent, high-end environment, while your players run a vast range of real hardware the editor can't replicate, and the release build differs from the editor. Unity crashes are frequently device-specific, triggered by particular GPUs and drivers, tight memory on low-end phones, or specific OS versions, none of which appear on your development machine. There are also crashes that only manifest in built players, especially IL2CPP/native builds, rather than the editor's more forgiving, instrumented environment, so a crash in the actual build can be invisible in the editor, and the editor's safety nets can mask issues that crash in the field. This is exactly why field crash reporting matters for Unity: capturing crashes from real devices with hardware, OS, and version context surfaces the device-specific and build-specific crashes that editor testing structurally cannot reach, so you see them as data instead of unexplained churn and bad reviews. The practice of capturing both managed and native crashes from the field, with device and version context, addresses this gap directly, it sees the crashes that happen on the real hardware and in the real build that your editor doesn't, which is the majority of the crashes that actually affect your players. Testing the actual build on real varied devices (not just the editor) also helps catch them before launch, but field crash capture is what reveals the device- and build-specific Unity crashes that the editor can't show you.

What context should a Unity crash report capture?

Enough to diagnose and reproduce without guessing: the stack trace (symbolicated so it points to real code locations), the device model and OS version (since Unity crashes are often device-specific and this context frequently points at the cause), the build version the crash occurred on (so you can distinguish regressions from old issues and verify fixes per version), and breadcrumbs showing what the player did leading up to the crash. For Unity specifically, it's important to capture crashes at both layers, managed C# exceptions and native engine/plugin crashes, with appropriate context for each, since a setup that only catches managed exceptions misses native crashes (and vice versa). The device context is especially valuable for Unity because the audience is so fragmented and crashes cluster on specific hardware, GPUs, and OS versions, so knowing which device a crash occurred on (and seeing when crashes concentrate on particular hardware) is often the key to diagnosing it. A bare stack trace alone leaves you puzzling over which device and build and what triggered it, so the surrounding context, device, OS, version, breadcrumbs, is what turns a Unity crash report into an actionable issue. Capturing all of this automatically with every crash (so you don't depend on players reporting, which they mostly don't), and grouping by signature so duplicates collapse into one ranked issue with an affected-player count, is what makes Unity crash reports genuinely fixable and prioritizable, which is the goal of good Unity crash reporting.

Best Practices for Crash Reporting in Unity

Quick answer: Capture both managed exceptions and native crashes from the field, include device and version context, group by signature, and track per version. Unity games crash on hardware your editor never exercises.

Unity games run across a huge range of devices, and the crashes that matter happen on players' hardware, not in your editor. Here are the best practices for crash reporting in Unity.

Capture Both Managed Exceptions and Native Crashes From the Field

A Unity game can fail at the managed layer (C# exceptions) or the native layer (engine or plugin crashes), so capture both from the field automatically. Covering both layers ensures you see the full picture, since a crash reporting setup that catches only one misses a whole class of failures.

Bugnet captures crashes and errors from real Unity players automatically with full context. Capturing both managed and native crashes from the field is foundational for Unity, since the game crashes at both layers and field capture sees what the editor can't.

Include Device and Version Context

Unity crashes are often device-specific, so include device, OS, and build version with every report. The context is what makes a Unity crash actionable, especially the device information that frequently points at the cause for the device-specific crashes that dominate a fragmented Unity audience.

Bugnet captures device, OS, and version with every crash, plus breadcrumbs. Including device and version context is what turns a Unity crash report into an actionable issue, since the context is often the key clue and lets you verify fixes per version.

Group by Signature and Track Per Version

Group crashes by signature so duplicates collapse into ranked issues, and track per version so regressions and fixes are visible. Grouping makes the volume manageable and prioritized, and per-version tracking catches regressions and verifies fixes on the builds that shipped them.

Bugnet groups crashes by signature, ranks by affected players, and tracks per version. So practice Unity crash reporting by capturing both managed and native crashes from the field, including device and version context, and grouping by signature while tracking per version, seeing the full crash picture the editor can't.

Capture both managed exceptions and native crashes from the field, include device and version context, group by signature, and track per version. Unity games crash on hardware your editor never exercises.