Runtime Debugger Toolkit

About Runtime Debugger Toolkit – Unity Editor Tool & Plugin

Runtime Debugger Toolkit Unity Asset Overview

As developers, we all know the drill: your game runs smoothly at 60 FPS inside the Unity Editor, but the moment you push a build to an actual mobile device or target console, frame drops and memory spikes magically appear. Connecting Unity’s native Profiler or ADB logs over Wi-Fi can be clunky, slow, and often hides context-specific bugs that only trigger during actual gameplay sessions.

The Runtime Debugger Toolkit addresses this gap by injecting a full-featured, lightweight debugging suite directly into your running game build. Designed around a flexible modular architecture, it acts as an overlay that hooks into Unity's Application.logMessageReceived callbacks, system memory APIs, and scene hierarchy reflection engines. It gives developers, QA testers, and designers instant access to real-time performance metrics, a full interactive command console, an in-game object inspector, and scene object hierarchy trees—all without needing an attached IDE or external profiling tools.

Core Technical Features & Highlights

What makes this tool stand out in daily development is its low overhead and smart memory management. Here is a breakdown of what happens under the hood:

Real-Time Telemetry & Profiling Overlay

The toolkit renders a lightweight overlay tracking critical metrics in real time. Rather than generating garbage collection (GC) allocations on every frame through string concatenations, it utilizes custom string buffers and direct Unity.Profiling.ProfilerRecorder structs to track:

• Frame Rates & Delta Time: Real-time rendering of average, minimum, and maximum FPS counts.
• Memory Footprint: Accurate tracking of Mono Heap size, Allocated Memory, and total System RAM usage.
• Rendering Draw Calls: Quick glance metrics for batches, set-pass calls, and triangle counts.

In-Game Inspector & Hierarchy Browser

Through reflection and cached type descriptors, the asset allows you to traverse your active scene hierarchy tree at runtime. You can select any active GameObject, inspect component properties, modify Vector3 positions, toggle MonoBehaviour scripts on or off, and tweak Material parameters directly within the running build.

Custom Command Console

The asset includes an extensible console system. Developers can register custom debug methods using simple C# attributes. The command parser automatically converts input parameters into primitives, string arrays, and vector types at runtime.

Ideal Use Cases & Game Genres

The utility of an in-game debugger scales across almost every project, but it shines particularly well in specific production scenarios:

• Mobile Games (iOS & Android): Test hardware-specific bugs, device throttling, and touch inputs on target hardware without tethering cables to a workstation.
• Open World & Action RPGs: Debug state machines, spawn parameters, and inventory values directly while moving through large scenes.
• Local & Online Multiplayer: Monitor network state variables, latency markers, and player sync parameters without alt-tabbing to external log windows.
• QA & Playtesting Builds: Equip playtesters with a command terminal so they can execute commands like godmode, noclip, or teleport_zone and export log files immediately after encountering a bug.

Quick-Start Unity Setup & Integration Guide

Integrating the tool takes less than five minutes. Here is the standard workflow I use when dropping it into a fresh or existing project.

1. Adding the Manager Prefab

Drag the RuntimeDebuggerManager prefab into your entry-point scene (usually your Bootstrapper or Main Menu scene). The manager is configured with DontDestroyOnLoad by default, ensuring continuous logging across scene transitions.

2. Configuring Activation Triggers

Under the DebuggerController component in the Inspector, configure your overlay toggle hotkey. For desktop builds, the backquote key (~) is standard. For mobile platforms, you can set a multi-finger tap gesture (such as a 4-finger tap hold).

3. Registering Custom Commands

To expose your game systems to the runtime console, add the [ConsoleCommand] attribute to your public static methods. Here is a short practical script demonstrating how to register player cheat codes and teleportation commands:

using UnityEngine;
using RuntimeDebugger;

public class PlayerDebugController : MonoBehaviour
{
    private static PlayerDebugController _instance;

    private void Awake()
    {
        _instance = this;
    }

    [ConsoleCommand("player_heal", "Restores player health to maximum capacity.")]
    public static void HealPlayer()
    {
        if (_instance != null)
        {
            // Implementation logic for your health system
            Debug.Log("[DEBUG] Player health restored to 100%.");
        }
    }

    [ConsoleCommand("teleport", "Teleports player to specified XYZ coordinates.")]
    public static void TeleportPlayer(float x, float y, float z)
    {
        if (_instance != null)
        {
            _instance.transform.position = new Vector3(x, y, z);
            Debug.Log($"[DEBUG] Player moved to location: {x}, {y}, {z}");
        }
    }
}

Pros & Cons Assessment

• Pro: Zero non-essential GC allocation during runtime telemetry tracking, preventing artificial micro-stutters.
• Pro: Fully functional across standard Unity Render Pipelines, including Built-in, URP, and HDRP.
• Pro: Highly responsive UI built on modern Unity UI toolkit/Canvas systems with customizable scaling for high-DPI mobile screens.
• Con: Reflection-heavy inspector functionality can cause minor UI hitches when expanding complex objects with thousands of nested child fields.
• Con: Requires manual stripping setup or preprocessor directives (e.g., #if DEVELOPMENT_BUILD) if you want to ensure total exclusion from final user release builds.

Developers Who Downloaded This Also Downloaded

Related Unity Tools Assets