> For the complete documentation index, see [llms.txt](https://postica.gitbook.io/binding-system-3/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://postica.gitbook.io/binding-system-3/project-tools/diagnostics/scene-visualizer.md). # Scene Visualizer Every binding in the scene, drawn as an arrow, in the Scene view. **Window ▸ Binding System ▸ Bind Scene Visualizer**, or the **Bind Visualizer** entry in the Scene view's own overlay menu. The other diagnostics answer questions about a binding you have already found. This one answers a different question: *what is connected to what, in the scene in front of me?* It draws an arrow for every binding of the loaded scenes, straight in the Scene view, pointing the way the data travels.

The Scene Visualizer with arrows and badges on

It is off until you turn it on, editor only, and nothing about it reaches a build. {% hint style="success" %} **Somewhere to try it:** the [Cozy Nook](/binding-system-3/tutorials/samples.md#cozy-nook) sample scene ships in the package folder and needs no import. Its **Sunlight** variable feeds three objects, its **Breeze** variable two, and its water level reads `UnityEngine.Time`, so all three kinds of [shared point](#shared-source-points) below are on screen the moment you turn the visualizer on. {% endhint %} {% hint style="info" %} This is a per-user setting, kept with your editor rather than in the project. Turning it on does not turn it on for the rest of the team, and it is not a change to commit. {% endhint %} ## The arrows One arrow per binding. **The arrowhead is the bind mode**, so direction is readable without touching anything:

Mode	How it is drawn
Read	One head, at the object being written into. Data flows away from the source.
Write	One head, at the source. Data flows back into it.
Read Write	A head at each end.

Colour carries the same information, matching the hues the Inspector uses:

Colour	What it means
Cyan	Read.
Amber	Write.
Violet	Read Write.
Red	The binding cannot reach what it was pointed at: no source and no way to look one up, a variable id that no longer resolves, or a static class that is gone. The first of those is what Needs attention counts; the other two are named on the point the arrows meet at.

With **Flow** on, dots travel along each arrow in the direction the data goes, which makes a Read Write binding obvious at a glance. An arrow attaches to the middle of the object's body, and to its **transform** where there is no body to speak of. A particle system is the case that matters: its renderer bounds are the particles currently alive, which drift away from the emitter, grow and shrink as the effect runs, and describe nothing at all while it is stopped. Its arrows go to the emitter itself, whether or not anything is simulating. ### Shapes that mean something

What you see	What it means
A fan of arrows between two objects	Several bindings connect the same pair. Each one bows a little further out so they stay countable. Bow in the panel controls how far.
A small loop above one object	Both ends of the binding are on the same object.
Several arrows meeting at one point in mid air	They all read the same source. See Shared source points.
A dashed arrow	The source is not an object anywhere: a bind variable, or a static member of a class. The lighter tint and the broken line say so before you read the label.
A short stub ending in a square	Nothing in the scene sits at the far end, and nothing identifies the source either: a reference that is missing, or a lookup with no key to group it by. The arrow still says where the value lands.

## Shared source points A [variable](/binding-system-3/overview/bind-variables.md), a [static class](/binding-system-3/overview/sources.md#static), an asset and a [runtime lookup](/binding-system-3/overview/sources.md) have no place in the hierarchy, so the visualizer gives each one a place of its own: a single point in space that every binding reading it starts from. Two objects on the same variable draw two arrows that meet. Two objects on different variables never do. The same holds for two objects reading `Time`, or `Mathf`, or your own static settings class. That is the whole idea, and it is what turns *these are variable bindings* into *these are the same variable*.

Three bindings meeting at the point that stands for one variable

What you see	What it means
A diamond	A bind variable.
A triangle	A class read through its static members. No instance exists anywhere, so the class itself is what the point stands for.
A square	An asset, or a source looked up at runtime by tag, name or pattern.
The label above it	The source's name, and how many bindings read it.
Red	A variable whose id no longer resolves, or a class that has been renamed or deleted. Every binding on such a point is set up and reaching nothing.

The colour is the mode of the bindings that read it, the same hues the arrows use, and the read write hue when they disagree, since the point then carries traffic in both directions. ### Where the point goes The point is placed rather than authored, so the rules are worth knowing: * **Above the objects it feeds**, in the middle of them, so its arrows stay short and local. Never inside one of them. * **Out along a ring**, by an angle taken from the source's own identity. Two sources feeding the same objects would otherwise land on the same spot, so any pair that comes out too close is stepped around the ring until it is clear. * **The same point on every repaint**, and the same again after a domain reload. Nothing in the placement depends on the camera, on the order the scene was read, or on which filters are on: narrowing the [scope](#scope) hides arrows without moving the point they left from. * **In the ground plane** for a scene laid out on the ground, and in the view plane for one built flat, the way a 2D game is. * **In the space it is read from**, which matters as soon as a screen space canvas is involved. See below. ### Points and screen space canvases A screen space canvas is a world of its own. Its rect transform is measured in pixels, so a full screen one is a thousand units across and sits that far from the scene it draws over. A source read by three objects in a room **and** by one label on the HUD would have its point placed in the middle of the two: hundreds of metres above the room, with every arrow crossing the whole view to reach it. So a canvas counts as a space, and a source read from two spaces gets **a point in each**: one above the objects in the room, one in the canvas beside the label. Nothing is drawn between the two.

What follows from that	What it means
Two labels, one name	Where a source has a point in more than one space, the canvas is named on the label: Sunlight in the world, Sunlight in HUD on the canvas. With one point there is nothing to name, so nothing is added.
Each space keeps its own scale	A point is placed in the units of its own space. The canvas cannot lift the points in the world with it, and the world cannot flatten the points in the canvas onto their elements.
A canvas is sized by its rect	Not by whichever of its elements hold a binding. One bound label in a full screen canvas is still a space a thousand units across.
The plane comes from the canvas	A Screen Space Camera canvas can sit at any angle, so its points are placed on the canvas plane rather than in the ground plane, and stay on the surface its elements are drawn on.
A world space canvas is not a space	It is in the world already, at world scale, so it groups with everything else there.

{% hint style="info" %} A binding whose **two ends** are a world object and a UI element still draws one long arrow between them, and it should: both ends are real objects in real places. Only the invented points are placed per space. {% endhint %} ### Hovering a point The point behaves like an arrow, one level up. Hover the marker **or its label** and every binding reading that source lights at once while the rest dim, and a card opens on the source itself. The label is the easier target of the two, and it is the part that names what you are pointing at.

Row	What it shows
Source	Bind Variable, Static Value, the asset's type, or the source mode doing the lookup.
Type, Scope, Value	On a variable: what it holds, where it is scoped, and what is in it right now. The value is live in play mode.
Namespace, Assembly	On a static class: which one it is, when two classes share a name. A class that no longer resolves shows not found and what was recorded for it instead.
Key	On a lookup: the tag, name or pattern being searched for.
Space	The canvas this point belongs to, when it is in one, and how that canvas is rendered. It is also a reminder that the same source may have another point out in the world.
Bindings	How many read this source, in this space.
Direction	How many of them read and how many write. A variable written by one object and read by five is the shape worth spotting.
Every Update	How many of them are not on Optimized Update. Absent when they all are.
Members	On a static class: which statics are actually read, by name. Five bindings on one class are usually five different members, and this saves hovering all five arrows.
Objects	The objects themselves, by name.

**Left click** the point to select every object reading that source. **Right click** it for the rest, on release, the same way an arrow does:

Item	What it does
Select N Objects	The same as a left click.
Frame Them	Moves the camera so the point and everything reading it are on screen.
Select Variables Container	Selects the object that declares the variable, when a loaded scene declares it.
Open Bind Variables	Opens the Bind Variables window at the containers of the project.
Select Script	On a static class: selects the script it is declared in. Absent for a class with no script asset of its own, an engine type above all.
Copy Class Name	On a static class: puts its full name on the clipboard, ready to paste into code.
Select Source Asset	On an asset source: selects the asset.
Optimize N Bindings	Turns Optimized Update on for every binding on this source that lacks it, in one undo step.
Isolate These Objects	Selects them and switches Scope to Selection, leaving only this source's bindings on screen.
Group Shared Sources	The switch for all of this. See Shape.

## Hovering an arrow Put the pointer on an arrow. It thickens, the rest dim, and a card opens with the whole binding in one place.

Row	What it shows
Source Path	What the binding reads. A variable shows its name, a constant shows Default Value, and a path owned by an accessor provider is expanded into the provider's own form.
Target	The field it delivers into, or the proxied path.
Mode	Read, Write or Read Write.
Variable, Scope, Variable Type	On a variable source. The name turns red when the id no longer resolves to a variable.
Class, Namespace	On a static source: the class the member is read from. Red, with not found, when that class is gone.
Source	On any other source that is not a direct reference: the source mode that will resolve it, or missing.
Modifiers, Pre Modifiers	How many modifiers are in the pipeline, on each side of the conversion.
Read Converter, Write Converter	The converter in use, by name.
Parameters	How many parameters the path takes.
Updates On, Interval	On a proxy binding: its update points in words, and its interval when one is set. Nothing else reads them, so nothing else shows them.
Optimized	on change or every update, on the bindings that read the flag. See Optimized Update.
Kind	Field Binding, Proxy Binding or UI Element Binding: a `Bind<T>` field, a proxy, or a UI Toolkit binding on a document. It is what decides which of the rows above apply.
Live Debug	Whether Live Debug is on for this binding.
Object Cost	In play mode with the Bindings Monitor open. See Cost in play mode.

The card keeps clear of the Scene view's overlays, including this tool's own panel, so it moves to whichever corner of the pointer is free. **Left click** an arrow to select and ping the object that owns the binding. **Right click** it for the rest, which opens when the button comes back up: a right drag that happens to start on an arrow still orbits the camera, and no menu appears for it.

Item	What it does
Select Source / Select Target / Select Owner	Jump to either end, or to the object holding the binding when that is a third object.
Optimize Update	Toggles Optimized Update on this one binding.
Live Debug	Toggles Live Debug on this one binding.
Isolate This Object	Selects the owner and switches Scope to Selection, which is the fastest way to read one object's bindings in a crowded scene.

## Badges **Badges** sit next to each object that holds a bound field and carry the things worth acting on.

A badge with its count, its optimization state and a cost meter

Chip	What it shows
Bind mark and a count	How many bindings this object holds. Click it to select and ping the object.
Red mark and a count	How many of them cannot reach a source. Click to select the object.
Speed mark	The Optimized Update state, and the control for it. Green means every binding on the object updates only when its value changes. Dim, with a count, means that many still run on every update point. Click it to bring all of them to the same state, in one undo step. Absent on an object whose bindings are all `Bind<T>` fields, since the flag does nothing for those.
A meter with a figure in ms	Play mode only. See below.

{% hint style="success" %} The speed chip is the quickest bulk fix in the package. Turn on **Optimize** in the panel, look for the dim chips, and click them. [Optimized Update](/binding-system-3/overview/modes-and-updates.md#optimized-update) explains what it changes and when to leave it off. {% endhint %} ## Cost in play mode Enter play mode with the [Bindings Monitor](/binding-system-3/project-tools/diagnostics/bindings-monitor.md) open and every badge gains a meter: a bar and a figure in milliseconds, coloured on a green to red ramp. The ramp is relative to the heaviest object in the scene, with a floor, so a scene of cheap bindings still shows you where its hot spots are without painting everything red. {% hint style="info" %} The Monitor has to be **open**. It is the window that switches profiling on, and the visualizer only reports measurements it did not have to take itself. With the Monitor closed the panel says so and the meters stay away, rather than showing a number that is no longer being measured. {% endhint %} The measurements cover both kinds of binding the engine drives: [proxy bindings](/binding-system-3/overview/proxy-bindings.md) with an update point, and `Bind` fields refreshed each frame. A binding resolved lazily when your code reads it is not measured, because the engine is not doing anything for it. The panel's **Binding Cost** section adds the total, the peak, and the three heaviest objects, each clickable. ## The panel

The switch at the top left turns the whole thing on and off. Beside it is a live count of what is drawn. Every section folds, and remembers whether you left it open. A closed section still reports its state on the right of its header, so nothing is hidden by folding it away. ### Show

Chip	What it shows
Arrows	The arrows themselves.
Badges	The badges and their controls.
Optimize	Adds the optimization chip to each badge.
Cost	Adds the cost meter, when there is one to add.
Paths	Labels every arrow with its source path, instead of only the hovered one.
Flow	The travelling dots.

### Direction **Read**, **Write** and **Read Write**, each coloured like the arrows it controls. Turn two off to read one kind of flow in isolation, which is the quickest way to answer "what writes back into this object?" ### Scope

Scope	What it covers
Whole Scene	Every binding of the loaded scenes.
Selection	Only bindings with one end on the selection.
Selection And Children	The same, plus anything below the selection in the hierarchy.

### Shape

Control	What it does
Group	On, which is the default, every binding reading the same variable, static class, asset or lookup key starts from one shared point. Off, each of them gets a short stub of its own next to the object it feeds, which is worth a look when a source is read right across a large scene and its arrows are long.
Bow	How far the arrows bow away from the straight line between their two ends. More bow keeps a fan of bindings between the same pair readable; less keeps a sparse scene tidy.
Range	Hides the arrows of objects further than this from the camera. Zero draws them all.

### Shared sources Every source that lives outside the hierarchy, the most read first, with the number of bindings on each: variables, static classes, assets and keyed lookups together. Click a row to select the objects reading it. A name in red no longer resolves, whether that is a renamed variable or a deleted class. It is the way in when the point you are after is behind the camera, or off in a part of the scene you are not looking at. Appears only when there is something in it. ### Needs attention Appears only when there is something in it.

Row	What it shows
N without a source	Bindings that are set up but have nothing to read from and no way to find it. Select selects every object holding one.
N update every frame	Bindings that run on every update point instead of only when their value changes. Optimize turns Optimized Update on for all of them, in one undo step. Only proxy bindings and UI Toolkit bindings are counted: a `Bind<T>` field is refreshed only when its value changes already, so there is nothing there to switch.

{% hint style="warning" %} **Optimize** is a bulk edit across the loaded scenes. It is one undo step, so it is easy to take back, but read [Optimized Update](/binding-system-3/overview/modes-and-updates.md#optimized-update) first: a binding whose target is written by something else as well is the one case where you want it off. {% endhint %} ### Actions

Button	What it does
Rescan	Reads the loaded scenes again. Rarely needed; the visualizer notices changes on its own.
Frame All	Moves the camera so every object taking part in a binding is on screen. The elements of a screen space canvas are left out whenever the world has objects of its own, since framing both at once leaves the scene a speck beside the canvas.
Monitor	Opens the Bindings Monitor, which is what feeds the cost meters.

## As a strip of buttons The panel is a Unity overlay, so it takes the same three layouts the Scene view's own tool overlays do. Right click its header, or use its overlay menu, and pick **Horizontal** or **Vertical**.

The same overlay in its Horizontal layout

In either strip layout it collapses to the master switch, **Arrows**, **Badges** and **Cost**, with a **More** dropdown carrying the direction filters, the scope, the remaining switches and the actions. Nothing is lost, and the Scene view gets its space back. Unity's own overlay controls apply too: drag it to a dock zone, collapse it to its icon, or hide it from the overlay menu. ## What it costs Editor only, and off by default. While it is on:

Cost	What it involves
Reading the scenes	The visualizer reads the serialized data of components that can hold a binding. It rescans when the hierarchy changes, on undo, and when a serialized value changes, ignoring Transform edits because the arrows already follow the objects. Each scan schedules the next one in proportion to how long it took, so a heavy scene slows the refresh rate rather than the editor.
Repainting	The Scene view repaints about thirty times a second so the flow animation runs and hovering responds. Turning Flow off drops that.
Drawing	Capped at four hundred arrows. Past that the view is unreadable anyway; the panel reports how many were left out, and narrowing the scope brings them back.

Turn the master switch off, or hide the overlay, and all of it stops. ## Related pages * [Bindings Monitor](/binding-system-3/project-tools/diagnostics/bindings-monitor.md): the numbers behind the cost meters, per binding rather than per object. * [Bind Variables](/binding-system-3/overview/bind-variables.md): what a shared point stands for, and where variables are declared. * [Sources](/binding-system-3/overview/sources.md#static): the Static mode, and the seven other ways a source is found. * [Dependency Graph](/binding-system-3/project-tools/diagnostics/dependency-graph.md): the same connections as a graph, project wide, including what is not in the open scene. * [Bind Modes and Update Points](/binding-system-3/overview/modes-and-updates.md): what the arrowheads and the optimization chip mean. * [Bind Variables](/binding-system-3/overview/bind-variables.md): why some arrows are dashed. * [Settings](/binding-system-3/reference/settings.md#visualization): the switch, in the Visualization panel.