How to Collect Player Device Info with Bug Reports

Learning how to collect player device info with bug reports is a common challenge for game developers. A player reports that the game crashes during the loading screen. You ask what hardware they are running. They say "a pretty good PC." That exchange wastes hours and produces nothing useful. The fix is to collect device information automatically with every bug report so you never have to ask. GPU model, driver version, OS, RAM, resolution, and game settings should arrive alongside the bug description without the player lifting a finger.

Why Device Info Matters

Many bugs are hardware-dependent. A shader that compiles correctly on NVIDIA may fail on AMD. A performance issue that never appears on your development machine with 32 GB of RAM crashes on a player's 8 GB laptop. A UI layout that works at 1920x1080 breaks at ultrawide resolutions.

Without device info, you cannot reproduce these bugs. You test on your hardware, it works, and you close the report. The player hits it again. This cycle repeats until someone figures out that the crash only happens on Intel Arc GPUs with driver version 31.0.101.4255.

Device info also enables pattern detection. When 20 crash reports come in and 18 of them are on the same GPU model, you have a lead. Without that data, those 20 reports look unrelated and each one requires individual investigation.

Collecting Device Info in Unity

Unity's SystemInfo class provides comprehensive hardware and software information. Here is how to collect everything useful and serialize it for a bug report.

using UnityEngine;
using System.Collections.Generic;

public static class DeviceInfoCollector
{
    public static Dictionary<string, string> Collect()
    {
        var info = new Dictionary<string, string>
        {
            // Operating system
            ["os"] = SystemInfo.operatingSystem,
            ["os_family"] = SystemInfo.operatingSystemFamily.ToString(),

            // CPU
            ["cpu"] = SystemInfo.processorType,
            ["cpu_cores"] = SystemInfo.processorCount.ToString(),
            ["cpu_freq"] = SystemInfo.processorFrequency + " MHz",

            // Memory
            ["ram_mb"] = SystemInfo.systemMemorySize.ToString(),

            // GPU
            ["gpu"] = SystemInfo.graphicsDeviceName,
            ["gpu_vendor"] = SystemInfo.graphicsDeviceVendor,
            ["gpu_version"] = SystemInfo.graphicsDeviceVersion,
            ["gpu_memory_mb"] = SystemInfo.graphicsMemorySize.ToString(),
            ["gpu_api"] = SystemInfo.graphicsDeviceType.ToString(),

            // Display
            ["screen_resolution"] = $"{Screen.width}x{Screen.height}",
            ["screen_fullscreen"] = Screen.fullScreen.ToString(),
            ["screen_dpi"] = Screen.dpi.ToString("F0"),

            // Game
            ["game_version"] = Application.version,
            ["unity_version"] = Application.unityVersion,
            ["quality_level"] = QualitySettings.names[QualitySettings.GetQualityLevel()],
            ["target_fps"] = Application.targetFrameRate.ToString(),
            ["platform"] = Application.platform.ToString(),
        };

        return info;
    }

    public static string ToJson()
    {
        var info = Collect();
        return JsonUtility.ToJson(new Serializable(info), true);
    }
}

Call DeviceInfoCollector.Collect() when the player opens the bug reporter or when a crash is captured. Attach the resulting dictionary as metadata on the report. This takes less than a millisecond and adds no perceptible overhead.

Collecting Device Info in Godot

Godot provides device information through the OS class and the RenderingServer. The API is different from Unity but the data you need is the same.

extends Node

static func collect_device_info() -> Dictionary:
    var info = {
        # Operating system
        "os_name": OS.get_name(),
        "os_version": OS.get_version(),
        "os_locale": OS.get_locale(),

        # CPU
        "cpu_name": OS.get_processor_name(),
        "cpu_cores": OS.get_processor_count(),

        # Memory
        "memory_static": OS.get_static_memory_usage(),
        "memory_peak": OS.get_static_memory_peak_usage(),

        # GPU
        "gpu_name": RenderingServer.get_video_adapter_name(),
        "gpu_vendor": RenderingServer.get_video_adapter_vendor(),
        "gpu_api": RenderingServer.get_video_adapter_api_version(),

        # Display
        "screen_size": str(DisplayServer.screen_get_size()),
        "window_size": str(get_viewport().get_visible_rect().size),

        # Engine
        "godot_version": Engine.get_version_info()["string"],
        "debug_build": OS.is_debug_build(),
    }
    return info

Godot's memory reporting is less detailed than Unity's at the engine level, but you can supplement it with Performance.get_monitor() calls for real-time metrics like FPS, draw calls, and object count at the moment the bug is reported.

Collecting Device Info in Unreal

Unreal Engine provides hardware information through FPlatformMisc, FPlatformMemory, and the RHI (Rendering Hardware Interface).

// C++ example for Unreal Engine device info collection
#include "GenericPlatform/GenericPlatformMisc.h"
#include "RHI.h"

void CollectDeviceInfo(TMap<FString, FString>& OutInfo)
{
    // OS
    OutInfo.Add("os", FPlatformMisc::GetOSVersion());
    OutInfo.Add("cpu_brand", FPlatformMisc::GetCPUBrand());
    OutInfo.Add("cpu_vendor", FPlatformMisc::GetCPUVendor());
    OutInfo.Add("cpu_cores",
        FString::FromInt(FPlatformMisc::NumberOfCores()));

    // GPU
    OutInfo.Add("gpu", GRHIAdapterName);
    OutInfo.Add("gpu_driver",
        GDynamicRHI ? GDynamicRHI->GetName() : "Unknown");

    // Memory
    FPlatformMemoryStats MemStats =
        FPlatformMemory::GetStats();
    OutInfo.Add("ram_total_gb",
        FString::SanitizeFloat(
            MemStats.TotalPhysical / (1024.0 * 1024.0 * 1024.0)));
}

Unreal also provides the FGenericCrashContext system which automatically captures extensive device information with crash reports. If you are using Unreal's built-in crash reporter, much of this data is already collected. The code above is for supplementing bug reports submitted through your own in-game reporter.

Privacy Considerations

Hardware specifications are generally not personal data. A GPU model or OS version does not identify a specific person. However, there are boundaries to respect.

Do not collect hardware serial numbers or unique device IDs. These can be used to fingerprint users and are considered personal data in many jurisdictions.

Do not collect IP addresses without disclosure. If your bug reports are submitted over HTTP and your server logs IP addresses, mention this in your privacy policy.

Disclose what you collect. Your privacy policy should list the categories of technical data you gather: OS version, hardware specs, game settings, crash logs. Players should not be surprised by what you collect.

Offer an opt-out. Some players are privacy-conscious and will want to disable telemetry. Respect that choice. You can still allow manual bug reports without automatic device info collection.

The goal is to automate what players would have to type manually. Nobody wants to look up their GPU driver version to report a visual bug. Collect it silently, include it automatically, and display it for your developers. Everyone saves time.

Displaying Device Info in Your Tracker

Collecting the data is only half the value. The other half is making it visible and filterable in your bug tracking dashboard. When a developer opens a bug report, device info should be immediately visible without clicking through to raw JSON.

Key display features: group by GPU vendor to find driver-specific issues, filter by OS to see platform-specific bugs, sort by RAM to find memory-related crashes, and flag reports from unusual configurations (very low RAM, integrated GPUs, uncommon resolutions) that might explain hard-to-reproduce issues.

If you are using Bugnet, device metadata is automatically parsed and displayed on each bug report card. You can filter the bug list by GPU vendor, OS, or any custom field to quickly identify hardware-correlated patterns.

Related Issues

For deciding what to do with the bugs once you have the device context, see prioritizing bugs during early access. For which crash metrics to build dashboards around, read crash analytics metrics that matter. To get notified instantly when critical device-specific bugs come in, check Discord webhooks for bug notifications.

If a player says "it crashes on my PC," that tells you nothing. If the report says "GTX 1060, 8 GB RAM, Windows 10 21H2, driver 512.95," that tells you everything.