UI Toolkit: Data Binding

Unity 6 ships a powerful runtime binding system — and 6 to 10 lines of boilerplate to use it. Every property binding needs a path object, a binding object, a converter, and a setter call. Buttons need separate click and enabled wiring. Lists need manual refresh plumbing. Async commands aren't supported. There's no auto-cleanup, no async command pattern, no computed values, no inspector to see what's bound.

This asset is the missing convenience layer. Drop-in extension methods collapse the boilerplate to a single line, reactive properties plug straight into Unity's binding system, and every binding cleans itself up when its element leaves the panel. Compose with Unity's system; don't replace it.

One-line bindings.

```

label.BindText(vm, vm => vm.Score);

button.BindCommand(vm.SaveCommand);

listView.BindItems(vm.Items, BuildRow);

field.BindValue(vm, vm => vm.Email);

```

Each line replaces 6 to 10 lines of raw setup. Strongly-typed lambdas mean renaming a property updates the binding automatically — no magic strings, no runtime "path not found" surprises.

Reactive properties that drive your UI.

Wrap any value in a reactive property and bindings update automatically when it changes. Reactive collections drop straight into UI Toolkit list views and refresh on every Add, Remove, or Clear without a single manual refresh call. Computed values derive from other reactive sources and re-evaluate only when their inputs actually change.

Async commands with auto-disable.

Wire a button to an async operation in one call. The button automatically disables while the work runs and re-enables on completion — no more double-submit bugs, no manual enable/disable plumbing. Built-in cancellation token support so long-running operations can be aborted cleanly.

MVVM helpers when you want them.

An optional view-model base class cuts typical view-model code in half: a one-line setter helper, automatic change notifications, and lifecycle hooks for screen-aware view-models. None of it is required — anything compatible with Unity's binding system works as a data source — but the helpers are there when you'd rather not write them yourself.

Auto-cleanup on element detach.

Every binding silently disposes itself when its element leaves the panel. Stop your scene, swap panels, destroy a UIDocument — the bindings tear down, no leaked observers, and you didn't write a single cleanup line. Need explicit control over a binding's lifetime? Hold the returned handle and dispose it yourself.

Auto type conversion.

Bind a number to a label, a bool to a visibility style, or a float to a pixel length — the conversion is automatic. Per-binding format strings handle currency, padding, and decimal places when you need them, without writing a converter class.

Live diagnostics window.

`Tools > KrookedLilly > Data Binding Diagnostics` opens an editor window listing every live binding with its source, target, and binding path. Use it to track down leaks, debug bindings that aren't firing, and watch the auto-cleanup happen in real time as you tear down panels.

Four demo scenes included.

**One-Liner Comparison** — side-by-side panels with the raw Unity 6 API on the left (6 lines per binding) and Data Binding on the right (1 line). Both bind to the same counter and increment in sync, so you can see exactly what the convenience layer does. 

**MVVM Showcase** — a view-model with lifecycle hooks, one-line setters, and a computed property that updates when its source changes. 

**Collection ListView** — a reactive todo list with Add, Remove, Clear, and Reset buttons plus a live total counter; the list view updates automatically on every change. 

**Two-Way Form** — a text field, toggle, and slider editing a view-model, with a live preview panel that reflects every change as you type or drag. All four scenes ship with controller scripts, UXML, USS, and configured panel settings.

Plays well with the rest of the UI Toolkit Components suite.

If you own other assets from the suite, open Tools > KrookedLilly > Data Binding Setup to see the integration directory. Each sibling owns its own Setup panel — one click takes you there to enable the integration.

**With UI Toolkit: Screen Manager** — when you navigate between screens, your view-models automatically activate and deactivate in lockstep with the screen lifecycle. The screen's data source is set on enter and the activation/deactivation hooks fire at the right moments — no manual subscription wiring, no leaked observers when screens get destroyed. Adapters self-clean when screens are destroyed.

Works on every platform.

Verified on Mac Standalone IL2CPP. Uses the standard Unity AOT path that runs on iOS, Android, WebGL, and consoles. The included troubleshooting guide covers the rare `link.xml` adjustment some AOT projects need.

Full C# source, no DLLs.

XML documentation on every public API. Zero external dependencies.