# Unity Editor Toolbox takes over your Inspector, and tells you so

> Unity Editor Toolbox is an MIT licensed Unity package of PropertyDrawer attributes, custom inspectors, serialized types and Project window extensions that require Unity 2018.x or newer. The author states plainly that it is fully IMGUI based and overwrites the base custom Editor for all UnityEngine.Objects, so it cannot coexist with another Inspector plugin.

**arimger/Unity-Editor-Toolbox** — Tools, custom attributes, drawers, hierarchy overlay, and other extensions for the Unity Editor.

- Repository: https://github.com/arimger/Unity-Editor-Toolbox
- Stars: 1,980 · Forks: 147
- Language: C#
- License: MIT
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/arimger-unity-editor-toolbox

## The stated trade: IMGUI everywhere, and one base Editor you no longer own

The README does not bury this. A flagged note says the package is fully IMGUI-based, which means it may conflict with pure UI Toolkit features in your project, and that Toolbox overwrites the base custom Editor for all UnityEngine.Objects, which the author calls a common solution while noting it means you cannot combine other Inspector extensions or plugins.

That second clause decides whether the package fits your project. An Inspector plugin ecosystem exists in Unity, and a package that claims the base custom Editor for every object takes the slot another plugin may want. There is no partial mode described and no list of alternative drawers you can substitute.

The upside of going fully IMGUI is consistency. Regular drawers are built on the built-in PropertyDrawer and DecoratorDrawer classes with their PropertyAttribute, so they render through the same path as the rest of your inspector and behave predictably next to stock controls.

Requirements are modest: Unity 2018.x or newer, and one dependency, EditorCoroutines, which the README links to the Unity documentation for com.unity.editorcoroutines@0.0.

## Three install routes, and the settings file you have to create by hand

The package installs through Unity Package Manager using a git URL with the upm branch:

```bash
https://github.com/arimger/Unity-Editor-Toolbox.git#upm
```

Open Window/Package Manager and add that URL. The second route is to copy and paste the `Assets/Editor Toolbox` directory into your project and add the dependencies yourself. The third route uses the OpenUPM registry:

```bash
openupm add com.browar.editor-toolbox
```

After any of the three, open Edit/Project Settings/Editor Toolbox. If the settings file is not found, press the Refresh button or create a new one.

That settings file is the control surface for everything else. It is reachable from the Project Settings window and from inside the Project window directly, and the README insists there must be one valid settings file per project. Features are divided into four groups: Hierarchy, Project, Inspector and SceneView. Within them you enable or disable the Hierarchy overlay and choose what information it shows, enable or disable Project icons or assign your own directories, enable Toolbox drawers or assign custom ones, and enable the Scene View module and assign hotkeys.

If warnings appear about the current settings state, the README attributes that to features absent from your Unity version, and recommends creating your own settings file instead of living with the default:

## Regular drawers: attributes on fields instead of hand written OnInspectorGUI

The regular drawers are the part you will touch on day one. Each is a PropertyAttribute plus a drawer, and each declares the field types it accepts. Regular drawers take priority over Toolbox drawers and the README says the two cannot be mixed.

TagSelector works on string and turns it into a tag picker. ProgressBar takes int, float or double and takes a name, minValue, maxValue, a HexColor and an IsInteractable flag:

```csharp
[ProgressBar("Name", minValue: 0.0f, maxValue: 100.0f, HexColor = "#EB7D34", IsInteractable = true)]
public float var1 = 80.0f;
```

MinMaxSlider works on Vector2 and Vector2Int and takes the two bounds directly:

```csharp
[MinMaxSlider(0.5f, 71.7f)]
public Vector2 var1;
```

AssetPreview accepts any UnityEngine.Object and draws a preview; it has a named argument that drops the label:

```csharp
[AssetPreview(useLabel: false)]
public Component var2;
```

Suffix works on all types and appends a unit:

```csharp
[Suffix("cm")]
public string var1;
```

NotNull accepts a UnityEngine.Object and marks an empty reference, and Directory accepts a string and turns it into a folder field. SceneName accepts a string and offers the scenes in the project. EnumToggles is the one with a real constraint: it only works on enums marked with System.Flags, so the field type has to be a bitmask before the attribute means anything.

## EnumToggles and SerializeReference: the two places type shape decides everything

EnumToggles draws each flag as its own toggle, which is far more usable than a single dropdown for a permissions or layer mask field. The catch is that the enum must declare flag values, so the shape of the type is part of the contract:

```csharp
[System.Flags]
public enum FlagExample
{
	Nothing = 0,
	Flag1 = 1,
	Flag2 = 2,
	Flag3 = 4,
	Flag4 = 8,
	Flag5 = 16,
	Flag6 = 32,
	Flag7 = 64,
	Flag8 = 128,
	Flag9 = 256,
	Everything = ~0
}

[EnumToggles]
public FlagExample enumFlag = FlagExample.Flag1 | FlagExample.Flag2 | FlagExample.Flag6;
```

The example runs to nine single bit flags plus an Everything value of ~0, so a real one should be defined with the same bit progression rather than with arbitrary ordinals.

The other type driven feature is the SerializeReference picker, listed in the README's table of contents as a decorator area. SerializeReference fields hold a polymorphic reference inside Unity's serialized data, and Unity's stock inspector makes choosing a concrete type awkward. A reference picker is a reference management tool attached to your serialized fields.

The README also lists SerializedType, SerializedScene, SerializedDictionary, SerializedDateTime and SerializedDirectory as serialized types the package provides. Those are wrapper types that serialize cleanly into Unity assets, which is the practical reason the package exposes them rather than relying on the standard fields alone.

## Hierarchy overlay, Project icons and Scene View hotkeys, outside the Inspector

Three of the four feature groups sit outside the component editor. The Hierarchy module adds an overlay to the scene hierarchy, and the README describes the setting as enabling or disabling it and choosing the information it is allowed to show. For a scene with many objects, an overlay carrying extra per-object data could remove a click loop.

The Project module changes the Project window. You can enable or disable Toolbox icons, or assign your own directories to them. The right click operations on those rows were reworked in the repository history, and the list includes copy whole row and copy whole column, so the intent is bulk handling of asset metadata rather than decoration. Exports validate that the target directory exists, which is a detail worth knowing if you script around it.

The SceneView module is enabled separately and hotkeys are assigned in the same settings window. That is the tab that acts on what is currently selected in the scene view rather than on what is selected in the hierarchy.

The README also offers something separate from the four groups: a set of useful scripts, classes and functions to help with Editor extension development, so the package doubles as a small reference library if you only need one helper.

## Version 0.14.x, MIT, and a settings format the author plans to replace

The project is MIT licensed, in `LICENSE.md` at the repository root, with no attribution or copyleft obligation beyond keeping the notice. Vendor it in a proprietary studio project without a separate commercial discussion.

The recent release cadence is slow and regular: v0.14.5 on 2026-08-12, v0.14.4 on 2026-04-11, and v0.14.3 on 2025-12-29. The last push was on 2026-08-25. Versions below 1.0 and a feature list that still grows suggests the API surface is not frozen, so expect attribute renames and setting migrations across upgrades.

One upgrade risk is stated outright. The README says the ScriptableObject-based settings solution is planned to be replaced, so the settings asset format is not permanent. That matters if you version control that file, which you probably should, since it holds the enable and disable state for all four feature groups.

The mitigation the author gives is to create your own settings file rather than rely on the default one:

## Where plain PropertyAttributes, Odin Inspector or a custom Editor fit instead

If your only need is a progress bar or a min-max slider, Unity's built-in PropertyAttribute and PropertyDrawer are the alternative to consider.

The reason to reach for this package instead is the breadth plus the non Inspector modules. The Hierarchy overlay, the Project icon and right click handling, and the Scene View hotkeys have no equivalent in the built-in attribute system, and they are covered by the same settings asset. A project using Unity Editor Toolbox is buying one settings file that governs four editor surfaces.

Toolbox is fully IMGUI-based, so it may conflict with pure UI Toolkit features in a project.

## Conclusion

Adopt Unity Editor Toolbox if your studio wants readable inspectors built from attributes such as ProgressBar, MinMaxSlider and EnumToggles, and you are willing to give up coexistence with other Inspector extensions. Do not adopt it in a project that already uses a competing custom Editor or any pure UI Toolkit tooling, because the package overwrites the base custom Editor for all UnityEngine.Objects. Verify first on a scratch project that `Edit/Project Settings/Editor Toolbox` opens on your exact Unity version, since the README attributes settings warnings to features missing from your Unity version, and create your own settings file with `Create/Editor Toolbox/Settings` before you rely on any of the four feature groups.

## FAQ

### What Unity version does Unity Editor Toolbox require?

The README lists Unity 2018.x or newer as the system requirement, with EditorCoroutines as the only dependency.

### Can I use Unity Editor Toolbox with another Inspector plugin?

Generally no. The README states that Toolbox overwrites the base custom Editor for all UnityEngine.Objects, which means you cannot combine other Inspector extensions or plugins.

### How do I install Unity Editor Toolbox?

Add the git URL `https://github.com/arimger/Unity-Editor-Toolbox.git#upm` in Unity Package Manager, copy the `Assets/Editor Toolbox` directory into the project, or run `openupm add com.browar.editor-toolbox`. Then open Edit/Project Settings/Editor Toolbox.

### Why do I get warnings about the Editor Toolbox settings file?

The README says those warnings usually mean a feature is not present in your Unity version. The suggested fix is to create your own settings file and adjust the affected entries.

### Which attributes does Unity Editor Toolbox add?

TagSelector, ProgressBar, MinMaxSlider, AssetPreview, Suffix, EnumToggles, NotNull, Directory and SceneName among the regular drawers, each restricted to specific field types such as string, int, float, Vector2 or UnityEngine.Object.

### What licence is Unity Editor Toolbox released under?

MIT, with the licence text in LICENSE.md at the repository root.

## Sources

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

---

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