> For the complete documentation index, see [llms.txt](https://fast-studios.gitbook.io/bindables/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://fast-studios.gitbook.io/bindables/manual/getting-started.md).
# Getting Started
Install Bindables, convert your first field, and create your first binding.
## Installation
{% stepper %}
{% step %}
### Open the Package Manager
In the **Unity Editor**, go to **`Window > Package Manager`**.
{% endstep %}
{% step %}
### Show your assets
In the **Package Manager**, click **Packages** and select **My Assets** on the left side of the screen.
{% endstep %}
{% step %}
### Find Bindables
From the list, choose **Bindables System - A Visual Variable Binding System for Unity**.
{% endstep %}
{% step %}
### Download
In the bottom right corner, click **Download**.
{% endstep %}
{% step %}
### Import
And finally, click **Import**.
{% endstep %}
{% endstepper %}
## First Look at Settings
{% hint style="success" %}
**Bindables** works out of the box. You don't need to change anything to get started.
{% endhint %}
When you want to fit Bindables to your workflow, open **`Tools > Fast Studios > Bindables > Settings`** in Unity's top menu bar. The settings let you tweak how Bindables works inside the Editor, with options like interaction preferences and binding behavior. For a tour of every option, see [Settings](/bindables/manual/settings.md).
## Conversion
**Conversion** lets you start using Bindables with fields that already exist in your components, without having to rewrite them first. A Bindable is a field that can read its value from any other component in your scene. The [Bindable](/bindables/manual/bindable.md) page covers it in detail.
Right-click a supported field in the Inspector and open the **Bindables** menu. From there, you can pick **Convert to Bindable (Local)** or **Convert to Bindable (Global)**, depending on whether you want to convert only that particular instance or change the field directly in its script.
{% hint style="info" %}
Conversion currently supports `float`, `int`, `bool`, `string`, enums, `Vector2/3/4`, `Color`, and object references. If the Bindables menu doesn't appear for a field, its type isn't supported yet.
{% endhint %}
### Local Conversion
**Local Conversion** turns a field into a Bindable only for the selected component instance.
Your original script is left unchanged, so a field declared as a `float`, `bool`, `int`, or another supported type remains exactly that in code. Bindables creates and manages the Bindable separately, while the field looks and behaves like a regular Bindable in the Inspector and at runtime.
Because the conversion belongs to that specific component instance, other GameObjects using the same component are not affected. And since Local Conversion never touches the script, it also works on built-in Unity components and third-party components whose code you can't edit.
Local Conversion is usually the quickest way to start working with an existing field, and is especially useful when you only need the Bindable behavior on a particular object.
{% hint style="info" %}
Since the original field and its Bindable counterpart have to stay in sync, Local Conversion adds a small runtime overhead: one shared per-frame check that covers every converted field in the scene. It runs early in `LateUpdate`, so the synced value is ready before your own `LateUpdate` code. A field declared directly as `Bindable` skips this entirely.
{% endhint %}
### Global Conversion
**Global Conversion** changes the field at its source, converting its declaration in the script itself into a `Bindable`.
For example:
```csharp
public float speed = 5f;
```
becomes a Bindable field equivalent to:
```csharp
public Bindable speed = new Bindable(5f);
```
Because the script itself is modified, the change applies to every instance of that component rather than only the currently selected GameObject.
{% hint style="warning" %}
Global Conversion edits your `.cs` file directly, and Unity recompiles the scripts afterwards. Make sure the script is saved (and ideally under version control) before converting.
{% endhint %}
Global Conversion is only offered for fields in your own scripts (MonoBehaviours). For built-in Unity components, use Local Conversion instead.
### Which One Should I Use?
| | Local | Global |
| ----------------------------------- | -------------------------- | ------------------------- |
| Scope | Only the selected instance | Every instance |
| Script modified? | No | Yes |
| Works on built-in Unity components? | Yes | No |
| Runtime overhead | Small sync cost | None beyond `Bindable` |
In short: go **Global** when the field should permanently become a Bindable, and go **Local** for a quick, instance-specific conversion without touching your code. Both can be undone from the same right-click menu via **Bindables > Revert to normal**.
## Your First Binding
You now have everything you need. Take any Bindable field in your project (one you just converted, or one declared in a script as `Bindable`) and connect it:
{% stepper %}
{% step %}
### OBJ
Select the GameObject that has the value you want to use.
{% endstep %}
{% step %}
### COMP
Select one of its components.
{% endstep %}
{% step %}
### VAR
Select the variable that should feed the Bindable.
{% endstep %}
{% endstepper %}
That's it! The field now follows the value you picked, and you can watch it live right in the Inspector.
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://fast-studios.gitbook.io/bindables/manual/getting-started.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
