Sasquatch Inspector

Stop writing editor code. Start designing inspectors.

Sasquatch Inspector is a visual designer for Unity inspectors.

You open a window, drag widgets onto a canvas, and your inspector looks how YOU want it to.

No CustomEditor classes. No property drawers. No attributes sprinkled through your scripts. No recompile between changes.

Your MonoBehaviours and ScriptableObjects are never touched. Nothing to inherit from. Nothing added to your GameObjects. One click puts any type back to Unity's normal inspector, and uninstalling leaves nothing behind.

**THE LAYOUT DESIGNER**

A real design surface, not a list of checkboxes. Drag your fields in and arrange them in rows,
columns, grids, cards, foldouts, tabs and shaped frames. Reorder by dragging. Watch the result build as you go since this is a true WYSIWYG (what you see is what you get) experience.

Your layout keeps up with your code. Add a field and it shows up. Rename one and it keeps its styling and its place. Delete one and the layout closes the gap. The Unity attributes you already use come across too: Header, Range, Tooltip, Space, TextArea, Min, FormerlySerializedAs and more.

Set your house style once with a Layout Preset, and every field you add after that arrives already styled. There's a format painter for one-offs, and multi-select so you can restyle multiple fields at once.

**23 DISPLAY TYPES**

Every field can become something you'd actually want to use.

- Slider — styled track, 5 knob shapes, colored bar, unit suffix

- Min-Max Slider — two handles for a range, stored in a Vector2
- Progress Bar — value, percent or max text, and you can drag it to set the value
- Toggle — checkbox, rounded, square, slim or modern switch styles
- Enum Badges — enums as clickable chips, multi-select for [Flags]
- Dropdown — searchable, filled from enums, Tags, Layers, LayerMasks, or your own method
- Animation Curve — a real keyframe editor with tangents and presets, right in the inspector
- Gradient — inline gradient strip with draggable color and alpha pins
- Audio Preview — play clips in the inspector, with a waveform you can scrub
- Particle & VFX Preview — live preview, click to play
- Asset Preview — thumbnails you can orbit and zoom
- In-Line Editor — edit a referenced asset's fields without leaving the inspector
- Polymorphic — pick a concrete type for SerializeReference fields and edit it in place
- Unity Event — a friendlier event drawer with a searchable method picker, your scripts first
- Color Palette — pick from your own swatches instead of the OS color picker
- Dictionary Table — Unity 6.6's native Dictionary, drawn as a proper table

Plus XY Pad, Vector Sliders, Rating, Tag Chips, Text with a rich-text preview, Spring, and Unity's own drawer any time you want it.

**RULES, WITHOUT WRITING CODE**

Conditions — show, hide, enable, disable or highlight anything based on other values. You build the rule visually. Combine several with all/any. There's a debugger that shows you why something is hidden too.

Validation — mark a field required, warn when a number leaves a range, or point at a bool method on your class.

Buttons — point one at any method on your class. Methods with parameters get a prompt. Async ones show "Running…" until they finish. Destructive ones ask first. Rename the method in code and the button follows it.

**LIVE DEBUG — WATCH YOUR VALUES WHILE YOU PLAY** 🐛

Click the bug icon in a script header, press Play, and every field grows a small graph underneath it with its current value beside it. Then scrub back and read any frame you like.

It's for the bug you can't pause on. The value that flickers for one or two frames. The field that's already wrong by the time you look at it.

- Jump straight to the next time a value changed

- Click any point on a graph and get a card: what else changed on that frame, what the console said, and where in your script that field gets written
- Set it to stop on a warning or an error and leave it running, dashcam style. You keep the twenty seconds before things went wrong
- Copy the whole trace out as CSV
- No Debug.Log, nothing added to your scripts, nothing in your build

**COLLECTIONS THAT HANDLE REAL PROJECTS**

A list of 500 items stops being a scroll nightmare. Show any collection as a Table with a column per field, or as a List where you design one row and every element follows it.

Search, sorting, pagination and drag-to-reorder are all there. Drop twenty prefabs onto a list at once and get twenty rows. Or arm the eyedropper and click objects straight out of the Project window. Sorting and searching are view-only, so your saved order is never touched.

Need key/value pairs? On Unity 6.6 your native Dictionary gets drag-to-reorder, a right-click row menu, and real value editors — a column of Colors shows swatches, a column of object references shows pickers. On older versions the bonus SerializedDictionary does the same job.

**EXPORT TO STANDALONE C# — YOU'RE NEVER LOCKED IN**

Any layout can be exported as one self-contained C# file. It's a real CustomEditor class, and it compiles and runs (even with Sasquatch Inspector completely uninstalled.)

That means you can:

- Hand a layout to a teammate who doesn't own the package
- Ship an inspector in a project that can't take another dependency
- Keep everything you built if you ever stop using this

Almost all of it travels: the field search, Live Debug, collections, dictionaries, and the curve,
gradient and audio editors. The audio player actually makes sound with no package installed.
Anything that couldn't come across is listed in a comment at the top of the file, and most layouts have nothing there. An automated test compiles an exported editor with the package removed, on every build.

**WORKS WITH WHAT YOU ALREADY HAVE**

Already have hand-written CustomEditor classes? Sasquatch defers to them by default. Click Force Takeover to draw your layout instead, and Release to hand it back. Nothing is overwritten, and nothing is generated behind your back.

Want to keep one piece of your own editor — a graph, some control you're proud of? Mark the method that builds it with [SasquatchEmbed] and drop it into your layout as an Embedded Editor. You get your hand-built control with designed fields around it.

Another inspector framework installed? One setting decides who draws the body. It's on by default, and switching it off hands everything straight back.

**SMALL THINGS YOU'LL USE EVERY DAY**

- Right-click any field in the live inspector to retune it on the spot. No trip to the designer.
- A magnifier in the script header filters a big inspector down to what you're after. It matches
labels, real field names and tooltips, so moveSpeed still turns up after you relabel it Velocity.
- Prefix and suffix text: $ before a price, kg after a weight, m/s after a speed.
- Style a base class once and every subclass inherits the layout.
- Prefab override bars still work,even on hand-drawn widgets that would otherwise show nothing.
- Multi-object editing works exactly like it does in a stock inspector.

**ALSO INCLUDED, USABLE ON THEIR OWN**

- SerializedDictionary — a serializable dictionary that works (especially useful if you're not using Unity 6.6+)
- SceneReference — reference scenes safely instead of by name string or build index. Will automatically detect if that scene isn't in your build settings (preventing build errors.)
- SasquatchSpring — a runtime spring motion library, with a sandbox window and a live response graph. There's a Spring Tween component too if you'd rather not write code.
- SasquatchString — a string type where {fieldName} resolves to the live value at runtime

**SUPPORT**

Email sasquatchbstudios@gmail.com. There's a bug reporter built into the editor too @ Tools > Sasquatch Inspector > Report a Bug.

I make games in Unity and teach game development on YouTube at @sasquatchbgames. I built Sasquatch Inspector because I needed it for my own projects, and I like making cool stuff and going on long side quests.