Runtime Inspector & Commands

Inspect runtime GameObjects and Components, edit supported fields and properties, explore nested objects, and execute project-defined commands through an in-game UI Toolkit interface.

Unity version

• Minimum supported version: 6000.0.79f1 (Every Unity 6 versions)
• Developed and tested with: 6000.0.79f1, 6000.5.4f1

UI

• UI Toolkit

Inspection limitation

• Supported public field inspection
• Supported public property inspection
• Private fields or properties are ignored.
• Non accessible fields and properties are ignored.

Default editable value types

• Strings
• Numeric types
• Booleans
• Enums
• Vectors
• Colors
• Quaternions

Extensibility

New value types can be added easily by adding a new UXML template and a binder.

Custom parser can also be added to perform string value parsing to match the value type.

Everything is detailed in the documentation.

Debug commands

• Commands are registered by project code before building
• Limited to 3 parameters maximum

Input

• No mandatory input package
• Optional Legacy Input Manager integration
• Optional Unity Input System integration

Build behavior

• Development-build-only mode included
• Fast Enter Play Mode supported with Domain Reload disabled

Render pipelines

• Runtime toolkit: render-pipeline independent
• Included demo scene: Universal Render Pipeline

Documentation

• Offline PDF included

Inspect, edit, and execute directly at runtime.

Runtime Inspector & Commands provides an in-game interface for inspecting and controlling runtime state directly inside Unity Player builds.

Browse live GameObjects and Components, inspect and edit supported public fields and properties, explore nested data, and execute commands defined by your own project code.

The toolkit is designed for Unity developers and testers who need direct access to runtime state without creating a dedicated debug interface for every project or system.

Inspect runtime objects

Browse the live GameObject hierarchy and select Components directly from the in-game interface.

Inspect supported public fields and properties, including objects created while the game is running.

Nested objects can be opened on demand, allowing complex data to remain readable without displaying an entire object graph at once. Built-in cycle protection prevents recursive references from causing infinite navigation.

Edit supported values

Edit supported runtime values directly through the interface and see the result immediately in the running game.

Built-in value handling includes:

• Strings

• Numeric types

• Booleans

• Enums

• Vectors

• Colors

• Quaternions

Support for project-specific C# types can be added through custom binders, parsers, and UXML templates.

Execute project-defined commands

Register commands from your own project code and expose them through a searchable runtime interface.

Commands execute locally inside the Player build and call the code defined by your project. The toolkit does not impose a predefined set of operations or limit commands to specific use cases.

Commands can accept zero to three parameters. Supported parameters receive an appropriate runtime editor before execution, while parameterless commands can run immediately.

Designed for runtime testing

• Inspect the current state of GameObjects and Components

• Adjust supported values while the game is running

• Access state that is not normally exposed through the game UI

• Execute repeatable project-specific commands

• Provide developers and testers with a shared runtime interface

• Reduce the need for temporary project-specific debug screens

UI Toolkit interface

The runtime interface is implemented with UI Toolkit and UI Document.

Its presentation can be customized or rearranged through UXML, USS, and UI Builder. The runtime toolkit itself is render-pipeline independent.

The included demonstration scene and its materials are configured for URP.

Input integration

No input package is required.

The interface can be controlled through its direct API or through the included optional integrations for:

• Legacy Input Manager

• Unity Input System

The Unity Input System package is only required when its integration is used.

Extensibility

The package provides extension points for adapting value handling and presentation to project-specific requirements:

• Custom value binders

• Custom value parsers

• Custom UXML templates

• Custom field type mappings

• Custom USS presentation

Build behavior

A development-build-only mode is included and enabled on the configured prefab.

When enabled, the toolkit removes itself automatically from non-development builds. It can be disabled when runtime access in another build configuration is intentional.

Fast Enter Play Mode with Domain Reload disabled is supported.

Documentation and support

Complete offline PDF documentation is included.

The documentation covers installation, activation, runtime inspection, value editing, command registration, extensibility, interface customization, input integration, build configuration, and troubleshooting.

Technical support is available through the publisher support email and website.