# UnityRuntimeInspector: a canvas inspector whose cost is boxing on every refresh

> UnityRuntimeInspector drops a canvas inspector and a scene hierarchy into a running Unity build, so object state can be read and changed on device. What it costs is a reflection driven panel that re-reads every exposed field 4 times a second, boxing value types while it works.

**yasirkula/UnityRuntimeInspector** — Runtime Inspector and Hierarchy solution for Unity for debugging and runtime editing purposes

- Repository: https://github.com/yasirkula/UnityRuntimeInspector
- Stars: 2,175 · Forks: 154
- Language: C#
- License: MIT
- Published: 2026-10-14 · Updated: 2026-10-14 · Language: en
- Canonical page: https://hysenlabs.com/projects/yasirkula-unityruntimeinspector

## Every refresh boxes value types and the interval is the throttle

An inspector panel re-reads the values of all exposed fields and properties on a fixed cadence, and that cadence defaults to 4 times a second for both the inspector and the hierarchy. The cost sits in how reflection hands values back: an int, a bool or a struct variable is boxed when the panel reads it, so each refresh leaves garbage behind for the collector. The README treats that boxing as unavoidable rather than as a defect.

Because the garbage scales with the number of exposed value-type variables multiplied by the refresh rate, the Refresh Interval is the throttle on it. The documentation is blunt that raising that value even slightly helps with GC a lot, and the price is paid in latency, since a field edited in code stops showing up the instant it changes. UI elements are pooled so that scrolling a long list does not call Instantiate and Destroy over and over, and the Pool Capacity value sets how many of those elements the pool keeps. The README sentence that defines Pool Capacity stops mid-word, so it gives no guidance on how to size it.

## Five install routes leave five different footprints in a project

Five routes are documented and they do not put the same files in the same place. Importing RuntimeInspector.unitypackage through the Assets-Import Package menu copies the whole asset. Cloning or downloading the archive and moving the Plugins folder into Assets copies a subset: the repository root also carries a `package.json` manifest and a `.meta` sibling beside each of its top-level entries, and the archive route leaves all of that behind.

The two package-manager routes read that manifest instead. One adds the git URL through the + button in Package Manager:

```
https://github.com/yasirkula/UnityRuntimeInspector.git
```

The other goes through openupm-cli:

```bash
openupm add com.yasirkula.runtimeinspector
```

Licence terms follow the route rather than the code: the repository copy sits under the MIT License in LICENSE.txt, the Asset Store copy falls under the Asset Store EULA, and the bundled colour picker is an external asset under the BSD 3-Clause License, which is also why the README's licence bullet links to a file named LICENSE while the repository actually ships LICENSE.txt.

The manifest that both package-manager routes resolve is short, and the fields that identify the package are these:

```json
{
  "name": "com.yasirkula.runtimeinspector",
  "displayName": "Runtime Inspector & Hierarchy",
  "version": "1.7.5",
  "documentationUrl": "https://github.com/yasirkula/UnityRuntimeInspector",
  "hideInEditor": false
}
```

`hideInEditor` is set to false, which is the opposite of a build-only tool: the package stays resolvable in the editor as well as in players, so a play mode session and a device build see the same component set. The last push was on 2026-08-30, and that manifest still reads version 1.7.5.

## The two input fixes cover overlapping Unity ranges, not adjacent ones

Two support answers name Unity versions, and they do not partition the range cleanly. New Input System support is off on Unity 2019.2.5 or earlier, and the fix is to add the `ENABLE_INPUT_SYSTEM` compiler directive to Player Settings/Scripting Define Symbols. Those symbols are platform specific, so changing the active platform later means adding the directive again for that platform.

A separate answer covers Unity 2018.4 or earlier, where the `Unity.InputSystem` assembly cannot be resolved at all. Its fix is not a define but a file edit: remove `Unity.InputSystem` from the Assembly Definition References of the RuntimeInspector.Runtime Assembly Definition File.

Read together, the two ranges nest rather than abut. A project on any Unity version between 2018.4 and 2019.2.5 sits inside both windows, and on 2018.4 the first answer cannot help, because the assembly that the plugin's own definition file points at does not exist in that editor in the first place. No order is given between the two answers, so the workable sequence on those versions is to remove the assembly reference first and only then decide whether the new input package earns a define symbol. Neither answer covers managed code stripping, IL2CPP or AOT, and neither says what happens to that edit in RuntimeInspector.Runtime when the package is updated.

## Prefab links run one way and the panels are not singletons

Neither panel is a singleton, and that is the unusual part. Dragging the RuntimeHierarchy prefab onto a canvas adds a hierarchy, dragging the RuntimeInspector prefab adds an inspector, and a scene may hold several of each with different configurations. Whatever selection state a panel keeps therefore lives on that instance rather than on shared state, and the documentation describes no mechanism that keeps two hierarchies on the same canvas in agreement.

Wiring between the two is deliberately partial. Assign an inspector to the Connected Inspector property of a hierarchy and a change of selection in that hierarchy moves what the inspector inspects. Assign a hierarchy to the Connected Hierarchy property of an inspector and highlighting an object reference field there moves the hierarchy selection. Each direction is its own property, and neither assignment fills the other, because the documented rule is that these connections are one-directional. A pair that behaves as one panel takes two property assignments instead of one, and forgetting the second leaves you with a hierarchy that highlights objects an inspector never follows.

## Expose Fields and Nest Limit decide how deep the walk goes

The inspector behaves like the editor window: it exposes common Unity types out of the box, plus custom classes and structs marked with the System.Serializable attribute, and it handles 1-dimensional arrays and generic Lists. That qualifier is the boundary worth noticing. The README names one-dimensional arrays and lists and stops there, so a jagged or two-dimensional array falls outside anything documented.

Expose Fields has three settings that decide how much of an inspected object appears: None, Serializable Only and All. Expose Properties is a separate switch, which means a type can be fully exposed for its fields while its properties stay hidden, a split that matters for classes whose getters do real work. Nest Limit is the guard against graphs that never end. Given a linked list exposed from its head node, it caps how many nodes the panel walks before it stops descending, so a self-referential structure costs a fixed number of rows instead of a frozen frame.

When Show Inspect Reference Button is on, an ObjectReferenceField grows an arrow, and clicking it makes the inspector inspect that referenced object. A built-in colour picker and a reference picker ship with the tool, so changing a value does not mean navigating back to the editor.

## Add Component and Remove Component turn a viewer into an editor

Two toggles are about mutation rather than observation. Show Add Component Button puts an Add Component button on screen while a GameObject is inspected, and Show Remove Component Button adds a Remove Component button under each inspected component. With those enabled and Expose Fields set to All, a build running on a phone can gain components and lose them while you watch. That is deliberate runtime editing, and it is the part of the feature set most easily left switched on in a build you hand to someone else.

The remaining switches are cosmetic but not trivial. Use Title Case Naming rewrites `m_myVariable` as My Variable in the label, which matters when the name is long and the field column is narrow. Array Indices Start At One shifts array and list numbering from 0 to 1, and the README calls that a visual change only, so any index read off the panel is offset by one from what your code expects. Show Tooltips reveals the full variable name once the cursor rests on it, and Tooltip Delay sets that rest time, with no effect at all when tooltips are off. Inspected Object Header Visibility controls whether a collapsible header on the inspected object is shown, collapsed or expanded.

## Skins ship in a directory, new ones start from the Assets menu

Appearance is a serialised choice on each panel rather than a global setting. Two skins, LightSkin and DarkSkin, are included in the Skins directory that ships with the package, and the Skin property on the inspector or the hierarchy switches between them.

A third skin starts from an editor context menu rather than from a file format:

```text
Assets-Create-yasirkula-RuntimeInspector-UI Skin
```

Read what that menu path says. It begins with Assets, so a skin you create lands in the project's Assets folder, while the two bundled skins sit in the package's own Skins directory. The documentation does not say how the Skin property resolves a reference across those two locations, so an original skin may need dragging onto the property by hand. It is also silent on copying a skin between projects and on what a skin asset contains beyond images.

## What the README leaves unanswered about removal and shipping

The gaps cluster around shipping rather than around using the tool. The only Unity versions named anywhere are 2019.2.5 and 2018.4, and both are input-system cutoffs, so no minimum or maximum Unity version for the plugin itself is stated. No uninstall procedure is given, and on the OpenUPM and Package Manager routes a leftover manifest reference outlives the files you deleted from Assets.

Nothing is said about managed code stripping, IL2CPP or platform builds beyond the claim that it should work on pretty much any platform Unity supports, including mobile. Nothing quantifies frame cost beyond the garbage-collection discussion, and nothing says whether the panels may be touched from a background thread, so calling them off the main thread is undefined by the documentation. Nor is there rollback guidance: for an install from the git URL, no version pinning is described, which leaves a broken update with no documented way back short of editing the manifest yourself.

## Conclusion

Adopt it when your team needs a screen on a device build rather than a remote debugger session; the two prefabs, the one-directional links and the built-in pickers cover that in an afternoon. Skip it when a log line would do, and verify three things first: your Unity version against the two input-system answers, whether a shipped build should still carry the Add Component button, and how a custom skin resolves on your platform. Read Refresh Interval before tuning anything else in it, and open RuntimeInspector.Runtime in your own checkout before you add ENABLE_INPUT_SYSTEM.

## FAQ

### How do I install UnityRuntimeInspector into a Unity project?

Five routes are given: import RuntimeInspector.unitypackage via the Assets-Import Package menu, clone or download the archive and move the Plugins folder into Assets, import it from the Asset Store, add the git URL through the + button in Package Manager, or run openupm add com.yasirkula.runtimeinspector after installing openupm-cli. Each route lands a slightly different set of files.

### Does UnityRuntimeInspector support the New Input System on Unity 2019.2.5 or earlier?

Support is stated as absent on those versions, and the fix given is adding the ENABLE_INPUT_SYSTEM compiler directive to Player Settings/Scripting Define Symbols. Those symbols are platform specific, so a later platform switch requires adding the directive again.

### Why does the Unity.InputSystem assembly fail to resolve on Unity 2018.4 or earlier?

The answer given is to remove Unity.InputSystem from the Assembly Definition References list of the RuntimeInspector.Runtime Assembly Definition File. That is a file edit rather than a compiler define, and it is separate from the ENABLE_INPUT_SYSTEM fix.

### Can I put more than one inspector or hierarchy in the same scene?

Yes. Neither panel is a singleton, so several instances with different configurations can coexist. The Connected Inspector and Connected Hierarchy links are one-directional, so linking a pair means making both assignments yourself.

### Why does the UnityRuntimeInspector panel generate garbage, and how do I reduce it?

Variables of value types are boxed when read through reflection, which produces garbage on every refresh, and both panels refresh 4 times a second by default. Raising Refresh Interval cuts that garbage, since the rate scales with how often the values are re-read.

### Which version of UnityRuntimeInspector does the Package Manager install?

The repository's package.json names the package com.yasirkula.runtimeinspector at version 1.7.5. Tagged entries include v1.7.5 on 2026-04-04, v1.7.4 on 2025-03-29 and v1.7.3 on 2025-02-23, and the Asset Store copy is distributed separately under the Asset Store EULA.

## Sources

- [Issues](https://github.com/yasirkula/UnityRuntimeInspector/issues)
- [License: MIT](https://github.com/yasirkula/UnityRuntimeInspector/blob/master/LICENSE)
- [README](https://github.com/yasirkula/UnityRuntimeInspector/blob/master/README.md)
- [Releases](https://github.com/yasirkula/UnityRuntimeInspector/releases)
- [yasirkula/UnityRuntimeInspector on GitHub](https://github.com/yasirkula/UnityRuntimeInspector)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/yasirkula-unityruntimeinspector