CLI tool
yasirkula/UnityIngameDebugConsole avatar
yasirkula/UnityIngameDebugConsole

UnityIngameDebugConsole: five install routes, four Unity version traps, and a parser with its own grammar

A uGUI based console to see debug messages and execute commands during gameplay in Unity

2,754 stars269 forksC#MIT

At a glance

What is it?
A uGUI console that shows logs, warnings, errors and exceptions inside a running build and executes commands typed into it. Its README carries four failure modes with version numbers attached, and its command parser accepts booleans as 1 or 0 and an empty pair of brackets for a zero vector.
Who is it for?
Adopt it if you ship builds that need a log window and a command line without a remote debugger attached, and expect the install decision to matter more than usual: the Package Manager and OpenUPM routes keep updates flowing, while moving the Plugins folder into Assets leaves you to re-import every release by hand.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 8 days ago.
What is it written in?
Mainly C#, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • yasirkula/UnityIngameDebugConsole2,754 ★ · +13
Star history
Repository2026-10-042026-11-15
yasirkula/UnityIngameDebugConsole2.7k2.8k

13 Stars in the last 42 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Five install routes, and only two of them track releases

The installation section lists five ways in, and they are not equivalent. The first imports IngameDebugConsole.unitypackage from the releases page through Assets then Import Package. The second clones or downloads the repository and moves the whole Plugins folder into the project's Assets folder, which means the source tree is copied into the project rather than referenced, and its download link points at an archive of the master branch rather than at a tagged release, so what lands in the project is whatever master currently holds. The third imports the asset from the Unity Asset Store. The fourth goes through Package Manager, where the + button takes a git URL, https://github.com/yasirkula/UnityIngameDebugConsole.git. The fifth goes through OpenUPM, which needs openupm-cli installed first and then one command:

bash
openupm add com.yasirkula.ingamedebugconsole

What separates them is version tracking. A package identifier, whether from Package Manager or OpenUPM, is what lets an editor fetch a newer release; a copied Plugins folder is not, because the copy becomes the project's own copy. The project also has a forum thread on the Unity forum, a Discord invite and a GitHub Sponsors link, so the same asset is reachable from the store, from a git URL and from a package registry.

Version 1.9.0 sits in package.json and on the tag

The repository root holds a Unity package manifest, and it is where the version number lives for anyone installing through a package manager. It names the package com.yasirkula.ingamedebugconsole with the display name In-game Debug Console and the version 1.9.0, which matches the newest release tag v1.9.0 published on 2026-09-06, the same day as the last commit. The two previous tags are v1.8.9 on 2026-08-09 and v1.8.8 on 2026-06-27, so the numbering moves at the patch level and lands a release every few weeks. The manifest also carries the author's name and email, points documentationUrl at the repository, changelogUrl at the releases page and licensesUrl at the LICENSE.txt file, and repeats the description sentence used in the overview. Note where the changelog lives: changelogUrl points at the releases page rather than at a file, so the tag list is the changelog and nothing in the repository restates it. One field is worth knowing about: hideInEditor is false, so the package is not hidden from the editor it is installed into, and its author block carries an email address and a profile URL alongside the name.

Seven entries at the top, three of them Unity meta files

The top-level tree is unusually short: .github/, LICENSE.txt, LICENSE.txt.meta, Plugins.meta, Plugins/, package.json and package.json.meta. Three of those seven are Unity meta files, and they cover the licence and the package manifest as well as the Plugins folder, so the MIT licence text and the version manifest are tracked as Unity assets rather than as plain files. That layout explains the second installation route: the actual plugin lives under Plugins/, and copying that one folder into a project's Assets folder brings the whole thing across, which is exactly what a project without package manager support needs. Nothing else sits at the root, so there is no scene, no sample project and no build script to inspect; a reader has to open the Plugins directory before seeing any C# at all, and the only other directory in the tree is .github/.

One SetPass call, a recycled list, and a popup that counts logs

The performance claims in the overview are specific and testable by reading the UI code rather than by running it. The interface is built with uGUI and costs 1 SetPass call, plus 6 to 10 batches, when Sprite Packing is enabled. The console window is built on a customised recycled list view that calls the Instantiate function sparingly, which is how a growing log list avoids creating a new row object per entry. Interaction has two states: the window can be resized or hidden during play, and hiding it leaves a small popup in its place that can be dragged around. That popup displays the number of logs that arrived since it appeared, so a hidden console still tells you whether something happened, and clicking it brings the window back. The messages it captures are the runtime ones: logs, warnings, errors and exceptions, with assertions added in the editor. Editor-only extras sit alongside this: right clicking a log entry there opens the corresponding line in the external script editor, the way double clicking a log opens Unity's own console entry.

The command parser has a grammar of its own

Typing help at the input field lists every available command, and each command is a function reachable from that field. A function can be static or an instance method, in which case a living instance has to exist for the console to call it. The return type can be anything including void, and an object returned is printed to the console. Parameters are unrestricted in number but restricted in type: primitives, enums, string, Vector2, Vector3, Vector4, Color, Color32, Vector2Int, Vector3Int, Quaternion, Rect, RectInt, RectOffset, Bounds, BoundsInt, GameObject, any Component type, and arrays or Lists of those. GameObject and Component arguments are resolved through GameObject.Find rather than passed by handle. The syntax is a small grammar of its own: strings must be wrapped in quotation marks, vectors in brackets or parentheses, an empty pair of brackets stands for a zero vector, 1 can be typed instead of true and 0 instead of false, and null is accepted for a null GameObject or Component. A call therefore looks like cube [0 2.5 0], and the help line echoes the mapping back as cube: Creates a cube at specified position -> TestScript.CreateCubeAt(Vector3 position), which is where a reader learns both the argument syntax and the function it lands in. Registration names also accept optional trailing strings for custom display names, so a command listed as cube can be shown to a tester under a different label than its method name.

Four registration routes, one of them unavailable on UWP

Once the parameter types are supported, a function can be registered with the console in four ways, and each takes optional trailing strings for custom display names of the parameters. The first is the attribute: mark the function with IngameDebugConsole.ConsoleMethod, keep it public and static inside a public class, and the console picks it up.

csharp
using UnityEngine;
using IngameDebugConsole;

public class TestScript : MonoBehaviour
{
	[ConsoleMethod( "cube", "Creates a cube at specified position" )]
	public static void CreateCubeAt( Vector3 position )
	{
		GameObject.CreatePrimitive( PrimitiveType.Cube ).transform.position = position;
	}
}

The public static and public class constraints are specific to this route and do not apply to the other three. The attribute is also not supported on the UWP platform, which is the case to check before choosing it. The second route registers typed functions through DebugLogConsole.AddCommand overloads, one per arity, with generics supplying the parameter types: a parameterless System.Action bound to a method named destroy, a Vector3 overload named cube, and a two type overload named child that takes a string and a GameObject. The descriptions there are built by string concatenation with the object's name, so the same registration produces per object labels rather than one fixed description. That route is what lets a non static instance method be exposed, since the console calls through the instance you hand it, and the sample does exactly that with a method named Destroy that shadows the engine method of the same name while still calling it with the game object. Two further registration approaches follow the attribute and the typed overloads in the same section.

Four failure modes with Unity versions attached

The FAQ is the most useful part of this README because every entry names a version boundary instead of a preference. New Input System is not supported on Unity 2019.2.5 or earlier, and the fix is to add the ENABLE_INPUT_SYSTEM compiler directive to Player Settings under Scripting Define Symbols, with the warning that those symbols are platform specific, so switching the active platform later means adding the directive again. On Unity 2018.4 or earlier the Unity.InputSystem assembly cannot be resolved, and the fix is to remove it from the Assembly Definition References list of the IngameDebugConsole.Runtime Assembly Definition File. An Android build failing with D8: java.lang.NullPointerException Failed to transform IngameDebugConsole-.aar comes down to build tooling: the plugin uses Gradle version 7.5.1 and Android Gradle plug-in version 7.4.2, so the Unity version has to be compatible. And logcat logging dying with java.lang.ClassNotFoundException for com.yasirkula.unity.DebugConsoleLogcatLogger is a stripping problem, which the entry assumes away first by asking you to confirm the plugin is up to date, then fixed by enabling the Custom Proguard File option and adding -keep class com.yasirkula.unity.* { *; } to it.

What works only in the editor or only on Android

Three capabilities in this console are narrower than the overview first suggests. Assertions are visible in the editor rather than in a build, so an assertion that fires on device is not something this window will show you. Logcat messages can be pulled into the console on the Android platform only, and that path is the one with the Proguard failure above, since the logger class is stripped unless a keep rule is added. Opening a log entry in an external script editor by right clicking it is likewise an editor behaviour, with no build time equivalent described. Set up therefore means dropping the IngameDebugConsole prefab into a scene and reading the Inspector tooltips that appear when hovering its properties, and there is no further wiring described beyond that. For a plugin that is one prefab and one command line, the bulk of the documentation is about the platforms around Unity rather than about the console itself.

Editorial conclusion

Adopt it if you ship builds that need a log window and a command line without a remote debugger attached, and expect the install decision to matter more than usual: the Package Manager and OpenUPM routes keep updates flowing, while moving the Plugins folder into Assets leaves you to re-import every release by hand. Before you commit, check the Unity version against the four documented traps, since New Input System support stops at 2019.2.5, the Unity.InputSystem assembly has to be dropped on 2018.4 or earlier, the Android build expects Gradle 7.5.1 with plug-in 7.4.2, and logcat logging needs a Proguard keep rule. Also decide early whether commands are registered by attribute or by typed function, because the attribute route is unavailable on UWP.

Frequently asked questions

What are the ways to install the In-game Debug Console in a Unity project?

Five: import IngameDebugConsole.unitypackage from the releases page via Assets then Import Package, clone or download the repository and move the Plugins folder into Assets, import it from the Asset Store, add the git URL through the Package Manager plus button, or install openupm-cli and run openupm add com.yasirkula.ingamedebugconsole.

Why does the Unity.InputSystem assembly fail to resolve in UnityIngameDebugConsole?

On Unity 2018.4 or earlier, remove the Unity.InputSystem assembly from the Assembly Definition References list of the IngameDebugConsole.Runtime Assembly Definition File. Separately, New Input System is not supported on Unity 2019.2.5 or earlier unless the ENABLE_INPUT_SYSTEM compiler directive is added to Scripting Define Symbols.

Why does an Android build fail with Failed to transform IngameDebugConsole-.aar?

The error appears as D8: java.lang.NullPointerException. The plugin is built against Gradle version 7.5.1 and Android Gradle plug-in version 7.4.2, so the Unity version in use has to be compatible with those versions.

Why does logcat logging fail with ClassNotFoundException for DebugConsoleLogcatLogger?

The logger class is being stripped on Android. Enable the Custom Proguard File option in Player Settings and add the line -keep class com.yasirkula.unity.* { *; } to that file.

How many draw calls does the In-game Debug Console UI cost?

The interface is built with uGUI and costs 1 SetPass call, plus 6 to 10 batches when Sprite Packing is enabled. The log list uses a recycled list view that calls Instantiate sparingly, and hiding the window leaves a draggable popup showing how many logs arrived since it appeared.

Which parameter types can an In-game Debug Console command accept?

Primitives, enums, string, Vector2, Vector3, Vector4, Color, Color32, Vector2Int, Vector3Int, Quaternion, Rect, RectInt, RectOffset, Bounds, BoundsInt, GameObject, any Component type, and arrays or Lists of those supported types. GameObject and Component arguments are assigned through GameObject.Find.

Official sources

  1. Issues
  2. License: MIT
  3. README
  4. Releases
  5. yasirkula/UnityIngameDebugConsole on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/yasirkula-unityingamedebugconsole.svg)](https://hysenlabs.com/projects/yasirkula-unityingamedebugconsole)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/yasirkula-unityingamedebugconsole.svg)](https://hysenlabs.com/projects/yasirkula-unityingamedebugconsole)

Was this useful?