Build an In-Game Console for Unity Debugging

Posted by Gemma Ellison

July 15, 2025

It’s frustrating, isn’t it? You’re deep in development, chasing down a particularly nasty bug, and the standard Unity debugging tools just aren’t cutting it. You need more direct control, more visibility into the inner workings of your game while it’s running. That’s where an in-game console comes in. Forget relying solely on Debug.Log; let’s build a proper, functional console to supercharge your debugging and testing.

Why Build an In-Game Console?

Sure, the Unity editor provides a console, but it’s limited. It’s not available in builds, and interacting with it during gameplay is clunky at best. An in-game console allows you to:

Modify variables on the fly: Tweak values to test different scenarios without recompiling.
Trigger events directly: Force specific game states for testing edge cases.
Execute custom commands: Implement shortcuts for common debugging tasks.
Access console in builds: Essential for debugging on target platforms.

Setting up the Basic UI

First, you’ll need a simple UI element to display the console. Create a Canvas in your scene. Inside the Canvas, create a Panel that serves as the background for the console. Add a TextMeshPro - Text object to display the console output and an InputField for entering commands.

Don’t use Unity’s legacy UI. TextMeshPro is far superior for rendering text cleanly and efficiently. It will save you headaches down the line.

Now, create a new C# script called InGameConsole.cs and attach it to an empty GameObject in your scene. This script will handle input, command parsing, and output.

Handling Input and Displaying Output

Here’s the basic structure for capturing input and displaying it in the TextMeshPro text field:

using UnityEngine;
using TMPro;

public class InGameConsole : MonoBehaviour
{
    public TMP_InputField inputField;
    public TMP_Text outputText;

    private string consoleOutput = "";

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.BackQuote)) // Toggle console with ` key
        {
            ToggleConsole();
        }

        if (inputField.isFocused && Input.GetKeyDown(KeyCode.Return))
        {
            ProcessCommand(inputField.text);
            inputField.text = ""; // Clear the input field
        }
    }

    void ToggleConsole()
    {
        // Implement logic to show/hide the console panel
        gameObject.SetActive(!gameObject.activeSelf); //Simple Activation/Deactivation
        if(gameObject.activeSelf) inputField.ActivateInputField(); //Focus when opened
    }

    void AppendOutput(string newText)
    {
        consoleOutput += newText + "\n";
        outputText.text = consoleOutput;
    }

    void ProcessCommand(string command)
    {
        AppendOutput("> " + command); //Echo the command
        // Command parsing logic will go here
        AppendOutput("Command not recognized.");
    }
}

Make sure to link the inputField and outputText variables in the Inspector to the corresponding UI elements.

Common Pitfall: Forgetting to ActivateInputField() when the console is opened. This forces the user to click in the text field before typing, ruining the user experience.

Command Parsing: The Core of the Console

The ProcessCommand function is where the magic happens. This is where you take the raw text from the input field and turn it into an actionable instruction. A simple approach is to use a Dictionary to store available commands and their corresponding actions.

using System;
using System.Collections.Generic;
using UnityEngine;
using TMPro;

public class InGameConsole : MonoBehaviour
{
    // (Previous code from above)

    private Dictionary<string, Action<string[]>> commands = new Dictionary<string, Action<string[]>>();

    void Start()
    {
        RegisterCommands();
    }

    void RegisterCommands()
    {
        commands.Add("help", HelpCommand);
        commands.Add("set_timescale", SetTimeScaleCommand);
        // Add more commands here
    }

    void ProcessCommand(string command)
    {
        AppendOutput("> " + command);

        string[] parts = command.Split(' ');
        string commandName = parts[0];
        string[] args = new string[parts.Length - 1];
        Array.Copy(parts, 1, args, 0, args.Length);

        if (commands.ContainsKey(commandName))
        {
            commands[commandName](args);
        }
        else
        {
            AppendOutput("Command not recognized.");
        }
    }

    void HelpCommand(string[] args)
    {
        AppendOutput("Available commands:");
        foreach (var cmd in commands.Keys)
        {
            AppendOutput("- " + cmd);
        }
    }

    void SetTimeScaleCommand(string[] args)
    {
        if (args.Length == 1 && float.TryParse(args[0], out float timescale))
        {
            Time.timeScale = timescale;
            AppendOutput("Time scale set to " + timescale);
        }
        else
        {
            AppendOutput("Usage: set_timescale <value>");
        }
    }
}

Explanation:

commands: A dictionary that maps command names (strings) to Action<string[]> delegates. This allows you to associate each command with a function that takes an array of string arguments.
RegisterCommands(): This function populates the commands dictionary with your desired commands and their corresponding functions.
ProcessCommand(): This function splits the input string into command name and arguments. It then checks if the command exists in the dictionary and executes the corresponding function.
HelpCommand(): A simple example command that lists all available commands.
SetTimeScaleCommand(): An example command that modifies Time.timeScale. Notice the error handling; good practice is to include comprehensive error messages!

The Challenge: Robust argument parsing. string.Split is very basic. For more complex commands, consider a more sophisticated parser that handles quoted strings and optional arguments. Libraries like CommandLineParser are a good option for complex scenarios.

Expanding Functionality and Real-World Uses

This is just a starting point. You can expand the console to:

Expose game variables: Allow modifying variables directly from the console using reflection.
Implement cheat codes: Add fun commands that grant the player advantages.
Create debugging shortcuts: Implement commands that trigger specific events or load specific scenes.
Logging: Capture Debug.Log messages and display them in the console.

Case Study: I once used an in-game console to debug a complex animation system. By exposing the animation state variables and triggering state transitions from the console, I was able to quickly identify and fix a subtle bug that would have taken hours to track down using traditional methods.

Building an in-game console is an investment that pays off handsomely during development. It provides unparalleled control and visibility into your game, allowing you to debug and test more efficiently. Stop wrestling with limited tools; empower yourself with a custom console tailored to your specific needs. You’ll thank yourself later.