| Phased Bindings | Only re-run what changed | Phased Bindings | cover-pipeline.svg |
| Optimized Accessors | The path walk removed at build time | Build-Time Optimized Accessors | Screenshot 2026-09-29 at 13.58.41.png |
| IL2CPP Specializations | Compile the generic pipeline for the types your project uses. | IL2CPP Specializations | cover-reference.svg |
| Performance Mode | A leaner Inspector | Performance Mode | Screenshot 2026-09-28 at 18.19.11.png |
| Benchmarks | Numbers, and how to get your own | Benchmarks | cover-diagnostics.svg |
| Path segment | What it costs |
|---|---|
| A field | Direct access. The field's location within the object is resolved once into a byte offset, and reads and writes go straight to it. No FieldInfo.GetValue, no boxing, no dispatch. A run of consecutive value-type fields collapses into a single offset, so a.b.c is one addition and one read rather than three hops. This is close enough to native field access that the difference is hard to measure. |
| A property | A strongly typed delegate bound to the getter or setter, created with MethodInfo.CreateDelegate. One virtual call, the same as calling the property through an interface. |
| A method or indexer | The same: a typed delegate over the real method, with the arguments passed as typed parameters rather than an object[]. |
| Mechanism | What it does |
|---|---|
| Accessor caching | That one-off resolution is cached per (type, path) and shared by every binding using the same pair, so the second binding to position.x does no work at all to be built. |
| Phased bindings | The pipeline is split into stages that only re-run when their input changed. On an unchanged source the cached stages are skipped entirely, so the longer the chain the larger the share saved. On by default. |
| Generated accessors | At build time, deterministic paths are replaced by a single generated static method, so even the per-segment delegate calls disappear and the path is not resolved at runtime at all. Off by default. |
| IL2CPP specializations | The pipeline instantiates its generic types at runtime, over the types it finds in a scene, which IL2CPP compiles as shared code with a runtime adapter on every value-type call. This names those instantiations at build time so IL2CPP compiles them specialised. Measured at 1.6x to 3.3x on multi-hop paths, and on Transform.localScale.x it closes the gap against Mono entirely; single-member paths do not change. Off by default: more code and memory is the price. |
| No boxing | Modifiers use ModifyDelegate<T>, which takes its value by in. A float going through five modifiers allocates nothing. |
| Optimized update | A binding with nothing to do does nothing, and an inactive source stops the work upstream. |
| Cost | When it is paid |
|---|---|
| Building the accessor | Once, on first use, and cached for every binding after it. This is the only place reflection appears. Amortised to nothing. |
| Resolving the source | Free for a direct reference. See the source mode table for the rest. A source that cannot be found is the expensive case. |
| Walking the path | One delegate call per segment, and direct access for field segments. One call in total with generated accessors. |
| The pipeline | One call per non-empty stage. Empty stages are never built. |
| Scheduling | Only for proxy bindings with an update point, and bind fields with Auto Update. A lazily read Bind<T> costs nothing when nobody reads it. See Two Ways to Bind. |
| Symptom | Where to look |
|---|---|
| The game runs slowly | This page, and the monitor. |
| Inspectors are slow to draw or open | Performance Mode and the Visualization panel. Nothing here affects the build. |
| The bind path menu is slow to open | Lower Max Bind Path Depth, or turn off methods in the bind path menu. |