diff --git a/.rive_head b/.rive_head
index 080a680..518b856 100644
--- a/.rive_head
+++ b/.rive_head
@@ -1 +1 @@
-f55ebd34f3938bfe1e36ebf83bbc92c0e5d34a62
+b5f342002be71c61608ad6c37835349eb4e7c719
diff --git a/dev/defs/data_bind/bindable_property.json b/dev/defs/data_bind/bindable_property.json
new file mode 100644
index 0000000..dbc57e5
--- /dev/null
+++ b/dev/defs/data_bind/bindable_property.json
@@ -0,0 +1,20 @@
+{
+  "name": "BindableProperty",
+  "key": {
+    "int": 9,
+    "string": "bindableproperty"
+  },
+  "abstract": true,
+  "properties": {
+    "dataBindId": {
+      "type": "Id",
+      "initialValue": "Core.missingId",
+      "key": {
+        "int": 633,
+        "string": "databindid"
+      },
+      "description": "Id of the data bind binded to this property",
+      "runtime": false
+    }
+  }
+}
\ No newline at end of file
diff --git a/dev/defs/data_bind/bindable_property_boolean.json b/dev/defs/data_bind/bindable_property_boolean.json
new file mode 100644
index 0000000..78c24f2
--- /dev/null
+++ b/dev/defs/data_bind/bindable_property_boolean.json
@@ -0,0 +1,19 @@
+{
+  "name": "BindablePropertyBoolean",
+  "key": {
+    "int": 472,
+    "string": "bindablepropertyboolean"
+  },
+  "extends": "data_bind/bindable_property.json",
+  "properties": {
+    "propertyValue": {
+      "type": "bool",
+      "initialValue": "false",
+      "key": {
+        "int": 634,
+        "string": "propertyvalue"
+      },
+      "description": "A property of type bool that can be used for data binding."
+    }
+  }
+}
\ No newline at end of file
diff --git a/dev/defs/data_bind/bindable_property_color.json b/dev/defs/data_bind/bindable_property_color.json
new file mode 100644
index 0000000..1dd5134
--- /dev/null
+++ b/dev/defs/data_bind/bindable_property_color.json
@@ -0,0 +1,19 @@
+{
+  "name": "BindablePropertyColor",
+  "key": {
+    "int": 475,
+    "string": "bindablepropertycolor"
+  },
+  "extends": "data_bind/bindable_property.json",
+  "properties": {
+    "propertyValue": {
+      "type": "Color",
+      "initialValue": "0xFF1D1D1D",
+      "key": {
+        "int": 638,
+        "string": "propertyvalue"
+      },
+      "description": "A property of type int that can be used for data binding."
+    }
+  }
+}
\ No newline at end of file
diff --git a/dev/defs/data_bind/bindable_property_enum.json b/dev/defs/data_bind/bindable_property_enum.json
new file mode 100644
index 0000000..b3faf03
--- /dev/null
+++ b/dev/defs/data_bind/bindable_property_enum.json
@@ -0,0 +1,21 @@
+{
+  "name": "BindablePropertyEnum",
+  "key": {
+    "int": 474,
+    "string": "bindablepropertyenum"
+  },
+  "extends": "data_bind/bindable_property.json",
+  "properties": {
+    "propertyValue": {
+      "type": "Id",
+      "typeRuntime": "uint",
+      "initialValue": "Core.missingId",
+      "initialValueRuntime": "-1",
+      "key": {
+        "int": 637,
+        "string": "propertyvalue"
+      },
+      "description": "The id of the enum that can be used for data binding."
+    }
+  }
+}
\ No newline at end of file
diff --git a/dev/defs/data_bind/bindable_property_number.json b/dev/defs/data_bind/bindable_property_number.json
new file mode 100644
index 0000000..a2ab667
--- /dev/null
+++ b/dev/defs/data_bind/bindable_property_number.json
@@ -0,0 +1,19 @@
+{
+  "name": "BindablePropertyNumber",
+  "key": {
+    "int": 473,
+    "string": "bindablepropertynumber"
+  },
+  "extends": "data_bind/bindable_property.json",
+  "properties": {
+    "propertyValue": {
+      "type": "double",
+      "initialValue": "0",
+      "key": {
+        "int": 636,
+        "string": "propertyvalue"
+      },
+      "description": "A property of type double that can be used for data binding."
+    }
+  }
+}
\ No newline at end of file
diff --git a/dev/defs/data_bind/bindable_property_string.json b/dev/defs/data_bind/bindable_property_string.json
new file mode 100644
index 0000000..aac63df
--- /dev/null
+++ b/dev/defs/data_bind/bindable_property_string.json
@@ -0,0 +1,19 @@
+{
+  "name": "BindablePropertyString",
+  "key": {
+    "int": 471,
+    "string": "bindablepropertystring"
+  },
+  "extends": "data_bind/bindable_property.json",
+  "properties": {
+    "propertyValue": {
+      "type": "String",
+      "initialValue": "''",
+      "key": {
+        "int": 635,
+        "string": "propertyvalue"
+      },
+      "description": "A property of type String that can be used for data binding."
+    }
+  }
+}
\ No newline at end of file
diff --git a/dev/defs/data_bind/data_bind.json b/dev/defs/data_bind/data_bind.json
index c93b559..3e3124d 100644
--- a/dev/defs/data_bind/data_bind.json
+++ b/dev/defs/data_bind/data_bind.json
@@ -4,18 +4,16 @@
     "int": 446,
     "string": "databind"
   },
-  "extends": "component.json",
   "properties": {
     "targetId": {
       "type": "Id",
-      "typeRuntime": "uint",
       "initialValue": "Core.missingId",
-      "initialValueRuntime": "-1",
       "key": {
         "int": 585,
         "string": "targetid"
       },
-      "description": "Identifier used to track the object that is targetted."
+      "description": "Identifier used to track the object that is targetted.",
+      "runtime": false
     },
     "propertyKey": {
       "type": "uint",
diff --git a/include/rive/animation/nested_state_machine.hpp b/include/rive/animation/nested_state_machine.hpp
index 8c0476b..f3e557c 100644
--- a/include/rive/animation/nested_state_machine.hpp
+++ b/include/rive/animation/nested_state_machine.hpp
@@ -36,6 +36,8 @@
     size_t inputCount() { return m_nestedInputs.size(); }
     NestedInput* input(size_t index);
     NestedInput* input(std::string name);
+    void dataContextFromInstance(ViewModelInstance* viewModelInstance);
+    void dataContext(DataContext* dataContext);
 };
 } // namespace rive
 
diff --git a/include/rive/animation/state_machine.hpp b/include/rive/animation/state_machine.hpp
index 9899893..258fe61 100644
--- a/include/rive/animation/state_machine.hpp
+++ b/include/rive/animation/state_machine.hpp
@@ -10,6 +10,7 @@
 class StateMachineInput;
 class StateMachineListener;
 class StateMachineImporter;
+class DataBind;
 class StateMachine : public StateMachineBase
 {
     friend class StateMachineImporter;
@@ -18,10 +19,12 @@
     std::vector<std::unique_ptr<StateMachineLayer>> m_Layers;
     std::vector<std::unique_ptr<StateMachineInput>> m_Inputs;
     std::vector<std::unique_ptr<StateMachineListener>> m_Listeners;
+    std::vector<std::unique_ptr<DataBind>> m_dataBinds;
 
     void addLayer(std::unique_ptr<StateMachineLayer>);
     void addInput(std::unique_ptr<StateMachineInput>);
     void addListener(std::unique_ptr<StateMachineListener>);
+    void addDataBind(std::unique_ptr<DataBind>);
 
 public:
     StateMachine();
@@ -32,11 +35,13 @@
     size_t layerCount() const { return m_Layers.size(); }
     size_t inputCount() const { return m_Inputs.size(); }
     size_t listenerCount() const { return m_Listeners.size(); }
+    size_t dataBindCount() const { return m_dataBinds.size(); }
 
     const StateMachineInput* input(std::string name) const;
     const StateMachineInput* input(size_t index) const;
     const StateMachineLayer* layer(std::string name) const;
     const StateMachineLayer* layer(size_t index) const;
+    const DataBind* dataBind(size_t index) const;
     const StateMachineListener* listener(size_t index) const;
 
     StatusCode onAddedDirty(CoreContext* context) override;
diff --git a/include/rive/animation/state_machine_instance.hpp b/include/rive/animation/state_machine_instance.hpp
index c59ee17..679ade0 100644
--- a/include/rive/animation/state_machine_instance.hpp
+++ b/include/rive/animation/state_machine_instance.hpp
@@ -4,6 +4,7 @@
 #include <string>
 #include <stddef.h>
 #include <vector>
+#include <unordered_map>
 #include "rive/animation/linear_animation_instance.hpp"
 #include "rive/animation/state_instance.hpp"
 #include "rive/animation/state_transition.hpp"
@@ -31,6 +32,8 @@
 class Event;
 class KeyedProperty;
 class EventReport;
+class DataBind;
+class BindableProperty;
 
 #ifdef WITH_RIVE_TOOLS
 class StateMachineInstance;
@@ -56,6 +59,7 @@
     double randomValue();
     StateTransition* findRandomTransition(StateInstance* stateFromInstance, bool ignoreTriggers);
     StateTransition* findAllowedTransition(StateInstance* stateFromInstance, bool ignoreTriggers);
+    DataContext* m_DataContext;
 
 public:
     StateMachineInstance(const StateMachine* machine, ArtboardInstance* instance);
@@ -78,6 +82,8 @@
     SMIBool* getBool(const std::string& name) const override;
     SMINumber* getNumber(const std::string& name) const override;
     SMITrigger* getTrigger(const std::string& name) const override;
+    void dataContextFromInstance(ViewModelInstance* viewModelInstance) override;
+    void dataContext(DataContext* dataContext);
 
     size_t currentAnimationCount() const;
     const LinearAnimationInstance* currentAnimationByIndex(size_t index) const;
@@ -128,6 +134,7 @@
     /// Gets a reported event at an index < reportedEventCount().
     const EventReport reportedEventAt(std::size_t index) const;
     bool playsAudio() override { return true; }
+    BindableProperty* bindablePropertyInstance(BindableProperty* bindableProperty);
 
 private:
     std::vector<EventReport> m_reportedEvents;
@@ -139,6 +146,8 @@
     std::vector<std::unique_ptr<HitComponent>> m_hitComponents;
     StateMachineInstance* m_parentStateMachineInstance = nullptr;
     NestedArtboard* m_parentNestedArtboard = nullptr;
+    std::vector<DataBind*> m_dataBinds;
+    std::unordered_map<BindableProperty*, BindableProperty*> m_bindablePropertyInstances;
 #ifdef WITH_RIVE_TOOLS
 public:
     void onInputChanged(InputChanged callback) { m_inputChangedCallback = callback; }
diff --git a/include/rive/artboard.hpp b/include/rive/artboard.hpp
index 85353c1..9411ceb 100644
--- a/include/rive/artboard.hpp
+++ b/include/rive/artboard.hpp
@@ -182,9 +182,9 @@
                                  DataContext* parent,
                                  bool isRoot);
     void dataContextFromInstance(ViewModelInstance* viewModelInstance);
-    void populateDataBinds(std::vector<Component*>* dataBinds);
-    void buildDataBindDependencies(std::vector<Component*>* dataBinds);
-    void sortDataBinds(std::vector<Component*> dataBinds);
+    void addDataBind(DataBind* dataBind);
+    void populateDataBinds(std::vector<DataBind*>* dataBinds);
+    void sortDataBinds(std::vector<DataBind*> dataBinds);
     bool hasAudio() const;
 
     template <typename T = Component> T* find(const std::string& name)
@@ -284,6 +284,16 @@
             {
                 auto object = *itr;
                 cloneObjects.push_back(object == nullptr ? nullptr : object->clone());
+                // For each object, clone its data bind objects and target their clones
+                for (auto dataBind : m_DataBinds)
+                {
+                    if (dataBind->target() == object)
+                    {
+                        auto dataBindClone = static_cast<DataBind*>(dataBind->clone());
+                        dataBindClone->target(cloneObjects.back());
+                        artboardClone->m_DataBinds.push_back(dataBindClone);
+                    }
+                }
             }
         }
 
diff --git a/include/rive/data_bind/bindable_property.hpp b/include/rive/data_bind/bindable_property.hpp
new file mode 100644
index 0000000..3294401
--- /dev/null
+++ b/include/rive/data_bind/bindable_property.hpp
@@ -0,0 +1,19 @@
+#ifndef _RIVE_BINDABLE_PROPERTY_HPP_
+#define _RIVE_BINDABLE_PROPERTY_HPP_
+#include "rive/generated/data_bind/bindable_property_base.hpp"
+#include "rive/data_bind/data_bind.hpp"
+#include <stdio.h>
+namespace rive
+{
+class BindableProperty : public BindablePropertyBase
+{
+public:
+    void dataBind(DataBind* value) { m_dataBind = value; };
+    DataBind* dataBind() { return m_dataBind; };
+
+private:
+    DataBind* m_dataBind;
+};
+} // namespace rive
+
+#endif
\ No newline at end of file
diff --git a/include/rive/data_bind/bindable_property_boolean.hpp b/include/rive/data_bind/bindable_property_boolean.hpp
new file mode 100644
index 0000000..18037b6
--- /dev/null
+++ b/include/rive/data_bind/bindable_property_boolean.hpp
@@ -0,0 +1,13 @@
+#ifndef _RIVE_BINDABLE_PROPERTY_BOOLEAN_HPP_
+#define _RIVE_BINDABLE_PROPERTY_BOOLEAN_HPP_
+#include "rive/generated/data_bind/bindable_property_boolean_base.hpp"
+#include <stdio.h>
+namespace rive
+{
+class BindablePropertyBoolean : public BindablePropertyBooleanBase
+{
+public:
+};
+} // namespace rive
+
+#endif
\ No newline at end of file
diff --git a/include/rive/data_bind/bindable_property_color.hpp b/include/rive/data_bind/bindable_property_color.hpp
new file mode 100644
index 0000000..dd128ca
--- /dev/null
+++ b/include/rive/data_bind/bindable_property_color.hpp
@@ -0,0 +1,13 @@
+#ifndef _RIVE_BINDABLE_PROPERTY_COLOR_HPP_
+#define _RIVE_BINDABLE_PROPERTY_COLOR_HPP_
+#include "rive/generated/data_bind/bindable_property_color_base.hpp"
+#include <stdio.h>
+namespace rive
+{
+class BindablePropertyColor : public BindablePropertyColorBase
+{
+public:
+};
+} // namespace rive
+
+#endif
\ No newline at end of file
diff --git a/include/rive/data_bind/bindable_property_enum.hpp b/include/rive/data_bind/bindable_property_enum.hpp
new file mode 100644
index 0000000..48692c2
--- /dev/null
+++ b/include/rive/data_bind/bindable_property_enum.hpp
@@ -0,0 +1,13 @@
+#ifndef _RIVE_BINDABLE_PROPERTY_ENUM_HPP_
+#define _RIVE_BINDABLE_PROPERTY_ENUM_HPP_
+#include "rive/generated/data_bind/bindable_property_enum_base.hpp"
+#include <stdio.h>
+namespace rive
+{
+class BindablePropertyEnum : public BindablePropertyEnumBase
+{
+public:
+};
+} // namespace rive
+
+#endif
\ No newline at end of file
diff --git a/include/rive/data_bind/bindable_property_number.hpp b/include/rive/data_bind/bindable_property_number.hpp
new file mode 100644
index 0000000..38a72fd
--- /dev/null
+++ b/include/rive/data_bind/bindable_property_number.hpp
@@ -0,0 +1,13 @@
+#ifndef _RIVE_BINDABLE_PROPERTY_NUMBER_HPP_
+#define _RIVE_BINDABLE_PROPERTY_NUMBER_HPP_
+#include "rive/generated/data_bind/bindable_property_number_base.hpp"
+#include <stdio.h>
+namespace rive
+{
+class BindablePropertyNumber : public BindablePropertyNumberBase
+{
+public:
+};
+} // namespace rive
+
+#endif
\ No newline at end of file
diff --git a/include/rive/data_bind/bindable_property_string.hpp b/include/rive/data_bind/bindable_property_string.hpp
new file mode 100644
index 0000000..302caf0
--- /dev/null
+++ b/include/rive/data_bind/bindable_property_string.hpp
@@ -0,0 +1,13 @@
+#ifndef _RIVE_BINDABLE_PROPERTY_STRING_HPP_
+#define _RIVE_BINDABLE_PROPERTY_STRING_HPP_
+#include "rive/generated/data_bind/bindable_property_string_base.hpp"
+#include <stdio.h>
+namespace rive
+{
+class BindablePropertyString : public BindablePropertyStringBase
+{
+public:
+};
+} // namespace rive
+
+#endif
\ No newline at end of file
diff --git a/include/rive/data_bind/context/context_value.hpp b/include/rive/data_bind/context/context_value.hpp
index 1f08e45..370f46f 100644
--- a/include/rive/data_bind/context/context_value.hpp
+++ b/include/rive/data_bind/context/context_value.hpp
@@ -13,9 +13,9 @@
 public:
     DataBindContextValue(){};
     virtual ~DataBindContextValue(){};
-    virtual void applyToSource(Component* component, uint32_t propertyKey){};
-    virtual void apply(Component* component, uint32_t propertyKey){};
-    virtual void update(Component* component){};
+    virtual void applyToSource(Core* component, uint32_t propertyKey){};
+    virtual void apply(Core* component, uint32_t propertyKey){};
+    virtual void update(Core* component){};
 };
 } // namespace rive
 
diff --git a/include/rive/data_bind/context/context_value_boolean.hpp b/include/rive/data_bind/context/context_value_boolean.hpp
index b7a963b..82e9a7f 100644
--- a/include/rive/data_bind/context/context_value_boolean.hpp
+++ b/include/rive/data_bind/context/context_value_boolean.hpp
@@ -8,8 +8,8 @@
 
 public:
     DataBindContextValueBoolean(ViewModelInstanceValue* value);
-    void apply(Component* component, uint32_t propertyKey) override;
-    virtual void applyToSource(Component* component, uint32_t propertyKey) override;
+    void apply(Core* component, uint32_t propertyKey) override;
+    virtual void applyToSource(Core* component, uint32_t propertyKey) override;
 
 private:
     bool m_Value;
diff --git a/include/rive/data_bind/context/context_value_color.hpp b/include/rive/data_bind/context/context_value_color.hpp
index c1c7f48..22fe8f8 100644
--- a/include/rive/data_bind/context/context_value_color.hpp
+++ b/include/rive/data_bind/context/context_value_color.hpp
@@ -8,8 +8,8 @@
 
 public:
     DataBindContextValueColor(ViewModelInstanceValue* value);
-    void apply(Component* component, uint32_t propertyKey) override;
-    virtual void applyToSource(Component* component, uint32_t propertyKey) override;
+    void apply(Core* component, uint32_t propertyKey) override;
+    virtual void applyToSource(Core* component, uint32_t propertyKey) override;
 
 private:
     double m_Value;
diff --git a/include/rive/data_bind/context/context_value_enum.hpp b/include/rive/data_bind/context/context_value_enum.hpp
index e78a1b5..98c21c4 100644
--- a/include/rive/data_bind/context/context_value_enum.hpp
+++ b/include/rive/data_bind/context/context_value_enum.hpp
@@ -8,8 +8,8 @@
 
 public:
     DataBindContextValueEnum(ViewModelInstanceValue* value);
-    void apply(Component* component, uint32_t propertyKey) override;
-    virtual void applyToSource(Component* component, uint32_t propertyKey) override;
+    void apply(Core* component, uint32_t propertyKey) override;
+    virtual void applyToSource(Core* component, uint32_t propertyKey) override;
 
 private:
     int m_Value;
diff --git a/include/rive/data_bind/context/context_value_list.hpp b/include/rive/data_bind/context/context_value_list.hpp
index 3ee4f2d..0c12f91 100644
--- a/include/rive/data_bind/context/context_value_list.hpp
+++ b/include/rive/data_bind/context/context_value_list.hpp
@@ -12,17 +12,15 @@
 
 public:
     DataBindContextValueList(ViewModelInstanceValue* value);
-    void apply(Component* component, uint32_t propertyKey) override;
-    void update(Component* target) override;
-    virtual void applyToSource(Component* component, uint32_t propertyKey) override;
+    void apply(Core* component, uint32_t propertyKey) override;
+    void update(Core* target) override;
+    virtual void applyToSource(Core* component, uint32_t propertyKey) override;
 
 private:
     std::vector<std::unique_ptr<DataBindContextValueListItem>> m_ListItemsCache;
-    void insertItem(Component* target,
-                    ViewModelInstanceListItem* viewModelInstanceListItem,
-                    int index);
-    void swapItems(Component* target, int index1, int index2);
-    void popItem(Component* target);
+    void insertItem(Core* target, ViewModelInstanceListItem* viewModelInstanceListItem, int index);
+    void swapItems(Core* target, int index1, int index2);
+    void popItem(Core* target);
     std::unique_ptr<ArtboardInstance> createArtboard(Component* target,
                                                      Artboard* artboard,
                                                      ViewModelInstanceListItem* listItem) const;
diff --git a/include/rive/data_bind/context/context_value_number.hpp b/include/rive/data_bind/context/context_value_number.hpp
index da866d3..b2d850a 100644
--- a/include/rive/data_bind/context/context_value_number.hpp
+++ b/include/rive/data_bind/context/context_value_number.hpp
@@ -8,8 +8,8 @@
 
 public:
     DataBindContextValueNumber(ViewModelInstanceValue* value);
-    void apply(Component* component, uint32_t propertyKey) override;
-    virtual void applyToSource(Component* component, uint32_t propertyKey) override;
+    void apply(Core* component, uint32_t propertyKey) override;
+    virtual void applyToSource(Core* component, uint32_t propertyKey) override;
 
 private:
     double m_Value;
diff --git a/include/rive/data_bind/context/context_value_string.hpp b/include/rive/data_bind/context/context_value_string.hpp
index 52f2ac3..0b32528 100644
--- a/include/rive/data_bind/context/context_value_string.hpp
+++ b/include/rive/data_bind/context/context_value_string.hpp
@@ -8,8 +8,8 @@
 
 public:
     DataBindContextValueString(ViewModelInstanceValue* value);
-    void apply(Component* component, uint32_t propertyKey) override;
-    virtual void applyToSource(Component* component, uint32_t propertyKey) override;
+    void apply(Core* component, uint32_t propertyKey) override;
+    virtual void applyToSource(Core* component, uint32_t propertyKey) override;
 
 private:
     std::string m_Value;
diff --git a/include/rive/data_bind/data_bind.hpp b/include/rive/data_bind/data_bind.hpp
index 7efbcc8..0ccccb3 100644
--- a/include/rive/data_bind/data_bind.hpp
+++ b/include/rive/data_bind/data_bind.hpp
@@ -1,8 +1,10 @@
 #ifndef _RIVE_DATA_BIND_HPP_
 #define _RIVE_DATA_BIND_HPP_
+#include "rive/component_dirt.hpp"
 #include "rive/generated/data_bind/data_bind_base.hpp"
 #include "rive/viewmodel/viewmodel_instance_value.hpp"
 #include "rive/data_bind/context/context_value.hpp"
+#include "rive/data_bind/data_context.hpp"
 #include <stdio.h>
 namespace rive
 {
@@ -11,14 +13,18 @@
 public:
     StatusCode onAddedDirty(CoreContext* context) override;
     StatusCode import(ImportStack& importStack) override;
-    void buildDependencies() override;
     virtual void updateSourceBinding();
-    void update(ComponentDirt value) override;
-    Component* target() { return m_target; };
+    virtual void update(ComponentDirt value);
+    Core* target() const { return m_target; };
+    void target(Core* value) { m_target = value; };
     virtual void bind();
+    ComponentDirt dirt() { return m_Dirt; };
+    void dirt(ComponentDirt value) { m_Dirt = value; };
+    bool addDirt(ComponentDirt value, bool recurse);
 
 protected:
-    Component* m_target;
+    ComponentDirt m_Dirt = ComponentDirt::Filthy;
+    Core* m_target;
     ViewModelInstanceValue* m_Source;
     std::unique_ptr<DataBindContextValue> m_ContextValue;
 };
diff --git a/include/rive/data_bind/data_bind_context.hpp b/include/rive/data_bind/data_bind_context.hpp
index a6bdd46..b7e2ad4 100644
--- a/include/rive/data_bind/data_bind_context.hpp
+++ b/include/rive/data_bind/data_bind_context.hpp
@@ -3,6 +3,7 @@
 #include "rive/generated/data_bind/data_bind_context_base.hpp"
 #include "rive/viewmodel/viewmodel_instance_value.hpp"
 #include "rive/data_bind/context/context_value.hpp"
+#include "rive/data_bind/data_context.hpp"
 #include "rive/refcnt.hpp"
 #include <stdio.h>
 namespace rive
@@ -15,7 +16,7 @@
 public:
     void decodeSourcePathIds(Span<const uint8_t> value) override;
     void copySourcePathIds(const DataBindContextBase& object) override;
-    void bind() override;
+    void bindFromContext(DataContext* dataContext);
     ViewModelInstanceValue* source() { return m_Source; };
 };
 } // namespace rive
diff --git a/include/rive/generated/core_registry.hpp b/include/rive/generated/core_registry.hpp
index eb3a240..3096b79 100644
--- a/include/rive/generated/core_registry.hpp
+++ b/include/rive/generated/core_registry.hpp
@@ -100,6 +100,12 @@
 #include "rive/custom_property_boolean.hpp"
 #include "rive/custom_property_number.hpp"
 #include "rive/custom_property_string.hpp"
+#include "rive/data_bind/bindable_property.hpp"
+#include "rive/data_bind/bindable_property_boolean.hpp"
+#include "rive/data_bind/bindable_property_color.hpp"
+#include "rive/data_bind/bindable_property_enum.hpp"
+#include "rive/data_bind/bindable_property_number.hpp"
+#include "rive/data_bind/bindable_property_string.hpp"
 #include "rive/data_bind/data_bind.hpp"
 #include "rive/data_bind/data_bind_context.hpp"
 #include "rive/draw_rules.hpp"
@@ -408,10 +414,20 @@
                 return new Backboard();
             case OpenUrlEventBase::typeKey:
                 return new OpenUrlEvent();
+            case BindablePropertyBooleanBase::typeKey:
+                return new BindablePropertyBoolean();
             case DataBindBase::typeKey:
                 return new DataBind();
             case DataBindContextBase::typeKey:
                 return new DataBindContext();
+            case BindablePropertyStringBase::typeKey:
+                return new BindablePropertyString();
+            case BindablePropertyNumberBase::typeKey:
+                return new BindablePropertyNumber();
+            case BindablePropertyEnumBase::typeKey:
+                return new BindablePropertyEnum();
+            case BindablePropertyColorBase::typeKey:
+                return new BindablePropertyColor();
             case WeightBase::typeKey:
                 return new Weight();
             case BoneBase::typeKey:
@@ -542,6 +558,9 @@
             case LayoutComponentBase::clipPropertyKey:
                 object->as<LayoutComponentBase>()->clip(value);
                 break;
+            case BindablePropertyBooleanBase::propertyValuePropertyKey:
+                object->as<BindablePropertyBooleanBase>()->propertyValue(value);
+                break;
             case TextModifierRangeBase::clampPropertyKey:
                 object->as<TextModifierRangeBase>()->clamp(value);
                 break;
@@ -920,15 +939,15 @@
             case OpenUrlEventBase::targetValuePropertyKey:
                 object->as<OpenUrlEventBase>()->targetValue(value);
                 break;
-            case DataBindBase::targetIdPropertyKey:
-                object->as<DataBindBase>()->targetId(value);
-                break;
             case DataBindBase::propertyKeyPropertyKey:
                 object->as<DataBindBase>()->propertyKey(value);
                 break;
             case DataBindBase::flagsPropertyKey:
                 object->as<DataBindBase>()->flags(value);
                 break;
+            case BindablePropertyEnumBase::propertyValuePropertyKey:
+                object->as<BindablePropertyEnumBase>()->propertyValue(value);
+                break;
             case WeightBase::valuesPropertyKey:
                 object->as<WeightBase>()->values(value);
                 break;
@@ -1019,6 +1038,9 @@
             case GradientStopBase::colorValuePropertyKey:
                 object->as<GradientStopBase>()->colorValue(value);
                 break;
+            case BindablePropertyColorBase::propertyValuePropertyKey:
+                object->as<BindablePropertyColorBase>()->propertyValue(value);
+                break;
         }
     }
     static void setString(Core* object, int propertyKey, std::string value)
@@ -1052,6 +1074,9 @@
             case OpenUrlEventBase::urlPropertyKey:
                 object->as<OpenUrlEventBase>()->url(value);
                 break;
+            case BindablePropertyStringBase::propertyValuePropertyKey:
+                object->as<BindablePropertyStringBase>()->propertyValue(value);
+                break;
             case TextValueRunBase::textPropertyKey:
                 object->as<TextValueRunBase>()->text(value);
                 break;
@@ -1427,6 +1452,9 @@
             case JoystickBase::heightPropertyKey:
                 object->as<JoystickBase>()->height(value);
                 break;
+            case BindablePropertyNumberBase::propertyValuePropertyKey:
+                object->as<BindablePropertyNumberBase>()->propertyValue(value);
+                break;
             case BoneBase::lengthPropertyKey:
                 object->as<BoneBase>()->length(value);
                 break;
@@ -1625,6 +1653,8 @@
                 return object->as<CustomPropertyBooleanBase>()->propertyValue();
             case LayoutComponentBase::clipPropertyKey:
                 return object->as<LayoutComponentBase>()->clip();
+            case BindablePropertyBooleanBase::propertyValuePropertyKey:
+                return object->as<BindablePropertyBooleanBase>()->propertyValue();
             case TextModifierRangeBase::clampPropertyKey:
                 return object->as<TextModifierRangeBase>()->clamp();
         }
@@ -1880,12 +1910,12 @@
                 return object->as<JoystickBase>()->handleSourceId();
             case OpenUrlEventBase::targetValuePropertyKey:
                 return object->as<OpenUrlEventBase>()->targetValue();
-            case DataBindBase::targetIdPropertyKey:
-                return object->as<DataBindBase>()->targetId();
             case DataBindBase::propertyKeyPropertyKey:
                 return object->as<DataBindBase>()->propertyKey();
             case DataBindBase::flagsPropertyKey:
                 return object->as<DataBindBase>()->flags();
+            case BindablePropertyEnumBase::propertyValuePropertyKey:
+                return object->as<BindablePropertyEnumBase>()->propertyValue();
             case WeightBase::valuesPropertyKey:
                 return object->as<WeightBase>()->values();
             case WeightBase::indicesPropertyKey:
@@ -1949,6 +1979,8 @@
                 return object->as<SolidColorBase>()->colorValue();
             case GradientStopBase::colorValuePropertyKey:
                 return object->as<GradientStopBase>()->colorValue();
+            case BindablePropertyColorBase::propertyValuePropertyKey:
+                return object->as<BindablePropertyColorBase>()->propertyValue();
         }
         return 0;
     }
@@ -1974,6 +2006,8 @@
                 return object->as<KeyFrameStringBase>()->value();
             case OpenUrlEventBase::urlPropertyKey:
                 return object->as<OpenUrlEventBase>()->url();
+            case BindablePropertyStringBase::propertyValuePropertyKey:
+                return object->as<BindablePropertyStringBase>()->propertyValue();
             case TextValueRunBase::textPropertyKey:
                 return object->as<TextValueRunBase>()->text();
             case CustomPropertyStringBase::propertyValuePropertyKey:
@@ -2227,6 +2261,8 @@
                 return object->as<JoystickBase>()->width();
             case JoystickBase::heightPropertyKey:
                 return object->as<JoystickBase>()->height();
+            case BindablePropertyNumberBase::propertyValuePropertyKey:
+                return object->as<BindablePropertyNumberBase>()->propertyValue();
             case BoneBase::lengthPropertyKey:
                 return object->as<BoneBase>()->length();
             case RootBoneBase::xPropertyKey:
@@ -2345,6 +2381,7 @@
             case ClippingShapeBase::isVisiblePropertyKey:
             case CustomPropertyBooleanBase::propertyValuePropertyKey:
             case LayoutComponentBase::clipPropertyKey:
+            case BindablePropertyBooleanBase::propertyValuePropertyKey:
             case TextModifierRangeBase::clampPropertyKey:
                 return CoreBoolType::id;
             case ViewModelInstanceListItemBase::viewModelIdPropertyKey:
@@ -2470,9 +2507,9 @@
             case JoystickBase::joystickFlagsPropertyKey:
             case JoystickBase::handleSourceIdPropertyKey:
             case OpenUrlEventBase::targetValuePropertyKey:
-            case DataBindBase::targetIdPropertyKey:
             case DataBindBase::propertyKeyPropertyKey:
             case DataBindBase::flagsPropertyKey:
+            case BindablePropertyEnumBase::propertyValuePropertyKey:
             case WeightBase::valuesPropertyKey:
             case WeightBase::indicesPropertyKey:
             case TendonBase::boneIdPropertyKey:
@@ -2502,6 +2539,7 @@
             case KeyFrameColorBase::valuePropertyKey:
             case SolidColorBase::colorValuePropertyKey:
             case GradientStopBase::colorValuePropertyKey:
+            case BindablePropertyColorBase::propertyValuePropertyKey:
                 return CoreColorType::id;
             case ViewModelComponentBase::namePropertyKey:
             case ViewModelInstanceStringBase::propertyValuePropertyKey:
@@ -2512,6 +2550,7 @@
             case StateMachineComponentBase::namePropertyKey:
             case KeyFrameStringBase::valuePropertyKey:
             case OpenUrlEventBase::urlPropertyKey:
+            case BindablePropertyStringBase::propertyValuePropertyKey:
             case TextValueRunBase::textPropertyKey:
             case CustomPropertyStringBase::propertyValuePropertyKey:
             case AssetBase::namePropertyKey:
@@ -2636,6 +2675,7 @@
             case JoystickBase::originYPropertyKey:
             case JoystickBase::widthPropertyKey:
             case JoystickBase::heightPropertyKey:
+            case BindablePropertyNumberBase::propertyValuePropertyKey:
             case BoneBase::lengthPropertyKey:
             case RootBoneBase::xPropertyKey:
             case RootBoneBase::yPropertyKey:
@@ -2758,6 +2798,8 @@
                 return object->is<CustomPropertyBooleanBase>();
             case LayoutComponentBase::clipPropertyKey:
                 return object->is<LayoutComponentBase>();
+            case BindablePropertyBooleanBase::propertyValuePropertyKey:
+                return object->is<BindablePropertyBooleanBase>();
             case TextModifierRangeBase::clampPropertyKey:
                 return object->is<TextModifierRangeBase>();
             case ViewModelInstanceListItemBase::viewModelIdPropertyKey:
@@ -3006,12 +3048,12 @@
                 return object->is<JoystickBase>();
             case OpenUrlEventBase::targetValuePropertyKey:
                 return object->is<OpenUrlEventBase>();
-            case DataBindBase::targetIdPropertyKey:
-                return object->is<DataBindBase>();
             case DataBindBase::propertyKeyPropertyKey:
                 return object->is<DataBindBase>();
             case DataBindBase::flagsPropertyKey:
                 return object->is<DataBindBase>();
+            case BindablePropertyEnumBase::propertyValuePropertyKey:
+                return object->is<BindablePropertyEnumBase>();
             case WeightBase::valuesPropertyKey:
                 return object->is<WeightBase>();
             case WeightBase::indicesPropertyKey:
@@ -3068,6 +3110,8 @@
                 return object->is<SolidColorBase>();
             case GradientStopBase::colorValuePropertyKey:
                 return object->is<GradientStopBase>();
+            case BindablePropertyColorBase::propertyValuePropertyKey:
+                return object->is<BindablePropertyColorBase>();
             case ViewModelComponentBase::namePropertyKey:
                 return object->is<ViewModelComponentBase>();
             case ViewModelInstanceStringBase::propertyValuePropertyKey:
@@ -3086,6 +3130,8 @@
                 return object->is<KeyFrameStringBase>();
             case OpenUrlEventBase::urlPropertyKey:
                 return object->is<OpenUrlEventBase>();
+            case BindablePropertyStringBase::propertyValuePropertyKey:
+                return object->is<BindablePropertyStringBase>();
             case TextValueRunBase::textPropertyKey:
                 return object->is<TextValueRunBase>();
             case CustomPropertyStringBase::propertyValuePropertyKey:
@@ -3332,6 +3378,8 @@
                 return object->is<JoystickBase>();
             case JoystickBase::heightPropertyKey:
                 return object->is<JoystickBase>();
+            case BindablePropertyNumberBase::propertyValuePropertyKey:
+                return object->is<BindablePropertyNumberBase>();
             case BoneBase::lengthPropertyKey:
                 return object->is<BoneBase>();
             case RootBoneBase::xPropertyKey:
diff --git a/include/rive/generated/data_bind/bindable_property_base.hpp b/include/rive/generated/data_bind/bindable_property_base.hpp
new file mode 100644
index 0000000..b5d5f14
--- /dev/null
+++ b/include/rive/generated/data_bind/bindable_property_base.hpp
@@ -0,0 +1,37 @@
+#ifndef _RIVE_BINDABLE_PROPERTY_BASE_HPP_
+#define _RIVE_BINDABLE_PROPERTY_BASE_HPP_
+#include "rive/core.hpp"
+namespace rive
+{
+class BindablePropertyBase : public Core
+{
+protected:
+    typedef Core Super;
+
+public:
+    static const uint16_t typeKey = 9;
+
+    /// Helper to quickly determine if a core object extends another without RTTI
+    /// at runtime.
+    bool isTypeOf(uint16_t typeKey) const override
+    {
+        switch (typeKey)
+        {
+            case BindablePropertyBase::typeKey:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    uint16_t coreType() const override { return typeKey; }
+
+    void copy(const BindablePropertyBase& object) {}
+
+    bool deserialize(uint16_t propertyKey, BinaryReader& reader) override { return false; }
+
+protected:
+};
+} // namespace rive
+
+#endif
\ No newline at end of file
diff --git a/include/rive/generated/data_bind/bindable_property_boolean_base.hpp b/include/rive/generated/data_bind/bindable_property_boolean_base.hpp
new file mode 100644
index 0000000..366b551
--- /dev/null
+++ b/include/rive/generated/data_bind/bindable_property_boolean_base.hpp
@@ -0,0 +1,71 @@
+#ifndef _RIVE_BINDABLE_PROPERTY_BOOLEAN_BASE_HPP_
+#define _RIVE_BINDABLE_PROPERTY_BOOLEAN_BASE_HPP_
+#include "rive/core/field_types/core_bool_type.hpp"
+#include "rive/data_bind/bindable_property.hpp"
+namespace rive
+{
+class BindablePropertyBooleanBase : public BindableProperty
+{
+protected:
+    typedef BindableProperty Super;
+
+public:
+    static const uint16_t typeKey = 472;
+
+    /// Helper to quickly determine if a core object extends another without RTTI
+    /// at runtime.
+    bool isTypeOf(uint16_t typeKey) const override
+    {
+        switch (typeKey)
+        {
+            case BindablePropertyBooleanBase::typeKey:
+            case BindablePropertyBase::typeKey:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    uint16_t coreType() const override { return typeKey; }
+
+    static const uint16_t propertyValuePropertyKey = 634;
+
+private:
+    bool m_PropertyValue = false;
+
+public:
+    inline bool propertyValue() const { return m_PropertyValue; }
+    void propertyValue(bool value)
+    {
+        if (m_PropertyValue == value)
+        {
+            return;
+        }
+        m_PropertyValue = value;
+        propertyValueChanged();
+    }
+
+    Core* clone() const override;
+    void copy(const BindablePropertyBooleanBase& object)
+    {
+        m_PropertyValue = object.m_PropertyValue;
+        BindableProperty::copy(object);
+    }
+
+    bool deserialize(uint16_t propertyKey, BinaryReader& reader) override
+    {
+        switch (propertyKey)
+        {
+            case propertyValuePropertyKey:
+                m_PropertyValue = CoreBoolType::deserialize(reader);
+                return true;
+        }
+        return BindableProperty::deserialize(propertyKey, reader);
+    }
+
+protected:
+    virtual void propertyValueChanged() {}
+};
+} // namespace rive
+
+#endif
\ No newline at end of file
diff --git a/include/rive/generated/data_bind/bindable_property_color_base.hpp b/include/rive/generated/data_bind/bindable_property_color_base.hpp
new file mode 100644
index 0000000..a14617d
--- /dev/null
+++ b/include/rive/generated/data_bind/bindable_property_color_base.hpp
@@ -0,0 +1,71 @@
+#ifndef _RIVE_BINDABLE_PROPERTY_COLOR_BASE_HPP_
+#define _RIVE_BINDABLE_PROPERTY_COLOR_BASE_HPP_
+#include "rive/core/field_types/core_color_type.hpp"
+#include "rive/data_bind/bindable_property.hpp"
+namespace rive
+{
+class BindablePropertyColorBase : public BindableProperty
+{
+protected:
+    typedef BindableProperty Super;
+
+public:
+    static const uint16_t typeKey = 475;
+
+    /// Helper to quickly determine if a core object extends another without RTTI
+    /// at runtime.
+    bool isTypeOf(uint16_t typeKey) const override
+    {
+        switch (typeKey)
+        {
+            case BindablePropertyColorBase::typeKey:
+            case BindablePropertyBase::typeKey:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    uint16_t coreType() const override { return typeKey; }
+
+    static const uint16_t propertyValuePropertyKey = 638;
+
+private:
+    int m_PropertyValue = 0xFF1D1D1D;
+
+public:
+    inline int propertyValue() const { return m_PropertyValue; }
+    void propertyValue(int value)
+    {
+        if (m_PropertyValue == value)
+        {
+            return;
+        }
+        m_PropertyValue = value;
+        propertyValueChanged();
+    }
+
+    Core* clone() const override;
+    void copy(const BindablePropertyColorBase& object)
+    {
+        m_PropertyValue = object.m_PropertyValue;
+        BindableProperty::copy(object);
+    }
+
+    bool deserialize(uint16_t propertyKey, BinaryReader& reader) override
+    {
+        switch (propertyKey)
+        {
+            case propertyValuePropertyKey:
+                m_PropertyValue = CoreColorType::deserialize(reader);
+                return true;
+        }
+        return BindableProperty::deserialize(propertyKey, reader);
+    }
+
+protected:
+    virtual void propertyValueChanged() {}
+};
+} // namespace rive
+
+#endif
\ No newline at end of file
diff --git a/include/rive/generated/data_bind/bindable_property_enum_base.hpp b/include/rive/generated/data_bind/bindable_property_enum_base.hpp
new file mode 100644
index 0000000..30c6f44
--- /dev/null
+++ b/include/rive/generated/data_bind/bindable_property_enum_base.hpp
@@ -0,0 +1,71 @@
+#ifndef _RIVE_BINDABLE_PROPERTY_ENUM_BASE_HPP_
+#define _RIVE_BINDABLE_PROPERTY_ENUM_BASE_HPP_
+#include "rive/core/field_types/core_uint_type.hpp"
+#include "rive/data_bind/bindable_property.hpp"
+namespace rive
+{
+class BindablePropertyEnumBase : public BindableProperty
+{
+protected:
+    typedef BindableProperty Super;
+
+public:
+    static const uint16_t typeKey = 474;
+
+    /// Helper to quickly determine if a core object extends another without RTTI
+    /// at runtime.
+    bool isTypeOf(uint16_t typeKey) const override
+    {
+        switch (typeKey)
+        {
+            case BindablePropertyEnumBase::typeKey:
+            case BindablePropertyBase::typeKey:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    uint16_t coreType() const override { return typeKey; }
+
+    static const uint16_t propertyValuePropertyKey = 637;
+
+private:
+    uint32_t m_PropertyValue = -1;
+
+public:
+    inline uint32_t propertyValue() const { return m_PropertyValue; }
+    void propertyValue(uint32_t value)
+    {
+        if (m_PropertyValue == value)
+        {
+            return;
+        }
+        m_PropertyValue = value;
+        propertyValueChanged();
+    }
+
+    Core* clone() const override;
+    void copy(const BindablePropertyEnumBase& object)
+    {
+        m_PropertyValue = object.m_PropertyValue;
+        BindableProperty::copy(object);
+    }
+
+    bool deserialize(uint16_t propertyKey, BinaryReader& reader) override
+    {
+        switch (propertyKey)
+        {
+            case propertyValuePropertyKey:
+                m_PropertyValue = CoreUintType::deserialize(reader);
+                return true;
+        }
+        return BindableProperty::deserialize(propertyKey, reader);
+    }
+
+protected:
+    virtual void propertyValueChanged() {}
+};
+} // namespace rive
+
+#endif
\ No newline at end of file
diff --git a/include/rive/generated/data_bind/bindable_property_number_base.hpp b/include/rive/generated/data_bind/bindable_property_number_base.hpp
new file mode 100644
index 0000000..72596c1
--- /dev/null
+++ b/include/rive/generated/data_bind/bindable_property_number_base.hpp
@@ -0,0 +1,71 @@
+#ifndef _RIVE_BINDABLE_PROPERTY_NUMBER_BASE_HPP_
+#define _RIVE_BINDABLE_PROPERTY_NUMBER_BASE_HPP_
+#include "rive/core/field_types/core_double_type.hpp"
+#include "rive/data_bind/bindable_property.hpp"
+namespace rive
+{
+class BindablePropertyNumberBase : public BindableProperty
+{
+protected:
+    typedef BindableProperty Super;
+
+public:
+    static const uint16_t typeKey = 473;
+
+    /// Helper to quickly determine if a core object extends another without RTTI
+    /// at runtime.
+    bool isTypeOf(uint16_t typeKey) const override
+    {
+        switch (typeKey)
+        {
+            case BindablePropertyNumberBase::typeKey:
+            case BindablePropertyBase::typeKey:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    uint16_t coreType() const override { return typeKey; }
+
+    static const uint16_t propertyValuePropertyKey = 636;
+
+private:
+    float m_PropertyValue = 0.0f;
+
+public:
+    inline float propertyValue() const { return m_PropertyValue; }
+    void propertyValue(float value)
+    {
+        if (m_PropertyValue == value)
+        {
+            return;
+        }
+        m_PropertyValue = value;
+        propertyValueChanged();
+    }
+
+    Core* clone() const override;
+    void copy(const BindablePropertyNumberBase& object)
+    {
+        m_PropertyValue = object.m_PropertyValue;
+        BindableProperty::copy(object);
+    }
+
+    bool deserialize(uint16_t propertyKey, BinaryReader& reader) override
+    {
+        switch (propertyKey)
+        {
+            case propertyValuePropertyKey:
+                m_PropertyValue = CoreDoubleType::deserialize(reader);
+                return true;
+        }
+        return BindableProperty::deserialize(propertyKey, reader);
+    }
+
+protected:
+    virtual void propertyValueChanged() {}
+};
+} // namespace rive
+
+#endif
\ No newline at end of file
diff --git a/include/rive/generated/data_bind/bindable_property_string_base.hpp b/include/rive/generated/data_bind/bindable_property_string_base.hpp
new file mode 100644
index 0000000..88d5121
--- /dev/null
+++ b/include/rive/generated/data_bind/bindable_property_string_base.hpp
@@ -0,0 +1,72 @@
+#ifndef _RIVE_BINDABLE_PROPERTY_STRING_BASE_HPP_
+#define _RIVE_BINDABLE_PROPERTY_STRING_BASE_HPP_
+#include <string>
+#include "rive/core/field_types/core_string_type.hpp"
+#include "rive/data_bind/bindable_property.hpp"
+namespace rive
+{
+class BindablePropertyStringBase : public BindableProperty
+{
+protected:
+    typedef BindableProperty Super;
+
+public:
+    static const uint16_t typeKey = 471;
+
+    /// Helper to quickly determine if a core object extends another without RTTI
+    /// at runtime.
+    bool isTypeOf(uint16_t typeKey) const override
+    {
+        switch (typeKey)
+        {
+            case BindablePropertyStringBase::typeKey:
+            case BindablePropertyBase::typeKey:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    uint16_t coreType() const override { return typeKey; }
+
+    static const uint16_t propertyValuePropertyKey = 635;
+
+private:
+    std::string m_PropertyValue = "";
+
+public:
+    inline const std::string& propertyValue() const { return m_PropertyValue; }
+    void propertyValue(std::string value)
+    {
+        if (m_PropertyValue == value)
+        {
+            return;
+        }
+        m_PropertyValue = value;
+        propertyValueChanged();
+    }
+
+    Core* clone() const override;
+    void copy(const BindablePropertyStringBase& object)
+    {
+        m_PropertyValue = object.m_PropertyValue;
+        BindableProperty::copy(object);
+    }
+
+    bool deserialize(uint16_t propertyKey, BinaryReader& reader) override
+    {
+        switch (propertyKey)
+        {
+            case propertyValuePropertyKey:
+                m_PropertyValue = CoreStringType::deserialize(reader);
+                return true;
+        }
+        return BindableProperty::deserialize(propertyKey, reader);
+    }
+
+protected:
+    virtual void propertyValueChanged() {}
+};
+} // namespace rive
+
+#endif
\ No newline at end of file
diff --git a/include/rive/generated/data_bind/data_bind_base.hpp b/include/rive/generated/data_bind/data_bind_base.hpp
index 4c73ffc..b900663 100644
--- a/include/rive/generated/data_bind/data_bind_base.hpp
+++ b/include/rive/generated/data_bind/data_bind_base.hpp
@@ -1,13 +1,13 @@
 #ifndef _RIVE_DATA_BIND_BASE_HPP_
 #define _RIVE_DATA_BIND_BASE_HPP_
-#include "rive/component.hpp"
+#include "rive/core.hpp"
 #include "rive/core/field_types/core_uint_type.hpp"
 namespace rive
 {
-class DataBindBase : public Component
+class DataBindBase : public Core
 {
 protected:
-    typedef Component Super;
+    typedef Core Super;
 
 public:
     static const uint16_t typeKey = 446;
@@ -19,7 +19,6 @@
         switch (typeKey)
         {
             case DataBindBase::typeKey:
-            case ComponentBase::typeKey:
                 return true;
             default:
                 return false;
@@ -28,27 +27,14 @@
 
     uint16_t coreType() const override { return typeKey; }
 
-    static const uint16_t targetIdPropertyKey = 585;
     static const uint16_t propertyKeyPropertyKey = 586;
     static const uint16_t flagsPropertyKey = 587;
 
 private:
-    uint32_t m_TargetId = -1;
     uint32_t m_PropertyKey = Core::invalidPropertyKey;
     uint32_t m_Flags = 0;
 
 public:
-    inline uint32_t targetId() const { return m_TargetId; }
-    void targetId(uint32_t value)
-    {
-        if (m_TargetId == value)
-        {
-            return;
-        }
-        m_TargetId = value;
-        targetIdChanged();
-    }
-
     inline uint32_t propertyKey() const { return m_PropertyKey; }
     void propertyKey(uint32_t value)
     {
@@ -74,19 +60,14 @@
     Core* clone() const override;
     void copy(const DataBindBase& object)
     {
-        m_TargetId = object.m_TargetId;
         m_PropertyKey = object.m_PropertyKey;
         m_Flags = object.m_Flags;
-        Component::copy(object);
     }
 
     bool deserialize(uint16_t propertyKey, BinaryReader& reader) override
     {
         switch (propertyKey)
         {
-            case targetIdPropertyKey:
-                m_TargetId = CoreUintType::deserialize(reader);
-                return true;
             case propertyKeyPropertyKey:
                 m_PropertyKey = CoreUintType::deserialize(reader);
                 return true;
@@ -94,11 +75,10 @@
                 m_Flags = CoreUintType::deserialize(reader);
                 return true;
         }
-        return Component::deserialize(propertyKey, reader);
+        return false;
     }
 
 protected:
-    virtual void targetIdChanged() {}
     virtual void propertyKeyChanged() {}
     virtual void flagsChanged() {}
 };
diff --git a/include/rive/generated/data_bind/data_bind_context_base.hpp b/include/rive/generated/data_bind/data_bind_context_base.hpp
index d1871d4..e8b772a 100644
--- a/include/rive/generated/data_bind/data_bind_context_base.hpp
+++ b/include/rive/generated/data_bind/data_bind_context_base.hpp
@@ -21,7 +21,6 @@
         {
             case DataBindContextBase::typeKey:
             case DataBindBase::typeKey:
-            case ComponentBase::typeKey:
                 return true;
             default:
                 return false;
diff --git a/include/rive/importers/artboard_importer.hpp b/include/rive/importers/artboard_importer.hpp
index 1525803..102bfd0 100644
--- a/include/rive/importers/artboard_importer.hpp
+++ b/include/rive/importers/artboard_importer.hpp
@@ -11,6 +11,7 @@
 class StateMachine;
 class TextValueRun;
 class Event;
+class DataBind;
 class ArtboardImporter : public ImportStackObject
 {
 private:
@@ -21,6 +22,7 @@
     void addComponent(Core* object);
     void addAnimation(LinearAnimation* animation);
     void addStateMachine(StateMachine* stateMachine);
+    void addDataBind(DataBind* dataBind);
     StatusCode resolve() override;
     const Artboard* artboard() const { return m_Artboard; }
 
diff --git a/include/rive/importers/bindable_property_importer.hpp b/include/rive/importers/bindable_property_importer.hpp
new file mode 100644
index 0000000..002ebe7
--- /dev/null
+++ b/include/rive/importers/bindable_property_importer.hpp
@@ -0,0 +1,20 @@
+#ifndef _RIVE_BINDABLE_PROPERTY_IMPORTER_HPP_
+#define _RIVE_BINDABLE_PROPERTY_IMPORTER_HPP_
+
+#include "rive/importers/import_stack.hpp"
+
+namespace rive
+{
+class Core;
+class BindableProperty;
+class BindablePropertyImporter : public ImportStackObject
+{
+private:
+    BindableProperty* m_bindableProperty;
+
+public:
+    BindablePropertyImporter(BindableProperty* bindableProperty);
+    BindableProperty* bindableProperty() { return m_bindableProperty; }
+};
+} // namespace rive
+#endif
\ No newline at end of file
diff --git a/include/rive/importers/state_machine_importer.hpp b/include/rive/importers/state_machine_importer.hpp
index f00ae45..dc08236 100644
--- a/include/rive/importers/state_machine_importer.hpp
+++ b/include/rive/importers/state_machine_importer.hpp
@@ -9,6 +9,7 @@
 class StateMachineLayer;
 class StateMachineListener;
 class StateMachine;
+class DataBind;
 class StateMachineImporter : public ImportStackObject
 {
 private:
@@ -21,6 +22,7 @@
     void addLayer(std::unique_ptr<StateMachineLayer>);
     void addInput(std::unique_ptr<StateMachineInput>);
     void addListener(std::unique_ptr<StateMachineListener>);
+    void addDataBind(std::unique_ptr<DataBind>);
 
     StatusCode resolve() override;
     bool readNullObject() override;
diff --git a/include/rive/nested_artboard.hpp b/include/rive/nested_artboard.hpp
index 9f57ec4..5759815 100644
--- a/include/rive/nested_artboard.hpp
+++ b/include/rive/nested_artboard.hpp
@@ -2,6 +2,8 @@
 #define _RIVE_NESTED_ARTBOARD_HPP_
 
 #include "rive/generated/nested_artboard_base.hpp"
+#include "rive/data_bind/data_context.hpp"
+#include "rive/viewmodel/viewmodel_instance_value.hpp"
 #include "rive/hit_info.hpp"
 #include "rive/span.hpp"
 #include <stdio.h>
@@ -97,6 +99,8 @@
     void decodeDataBindPathIds(Span<const uint8_t> value) override;
     void copyDataBindPathIds(const NestedArtboardBase& object) override;
     std::vector<uint32_t> dataBindPathIds() { return m_DataBindPathIdsBuffer; };
+    void dataContextFromInstance(ViewModelInstance* viewModelInstance, DataContext* parent);
+    void internalDataContext(DataContext* dataContext, DataContext* parent);
 };
 } // namespace rive
 
diff --git a/include/rive/scene.hpp b/include/rive/scene.hpp
index fd96d8e..7d36204 100644
--- a/include/rive/scene.hpp
+++ b/include/rive/scene.hpp
@@ -13,6 +13,7 @@
 {
 class ArtboardInstance;
 class Renderer;
+class ViewModelInstance;
 
 class SMIInput;
 class SMIBool;
@@ -47,6 +48,8 @@
 
     void draw(Renderer*);
 
+    virtual void dataContextFromInstance(ViewModelInstance* viewModelInstance);
+
     virtual HitResult pointerDown(Vec2D);
     virtual HitResult pointerMove(Vec2D);
     virtual HitResult pointerUp(Vec2D);
diff --git a/src/animation/nested_state_machine.cpp b/src/animation/nested_state_machine.cpp
index 6045b56..8176757 100644
--- a/src/animation/nested_state_machine.cpp
+++ b/src/animation/nested_state_machine.cpp
@@ -107,4 +107,20 @@
     return nullptr;
 }
 
-void NestedStateMachine::addNestedInput(NestedInput* input) { m_nestedInputs.push_back(input); }
\ No newline at end of file
+void NestedStateMachine::addNestedInput(NestedInput* input) { m_nestedInputs.push_back(input); }
+
+void NestedStateMachine::dataContextFromInstance(ViewModelInstance* viewModelInstance)
+{
+    if (m_StateMachineInstance != nullptr)
+    {
+        m_StateMachineInstance->dataContextFromInstance(viewModelInstance);
+    }
+}
+
+void NestedStateMachine::dataContext(DataContext* dataContext)
+{
+    if (m_StateMachineInstance != nullptr)
+    {
+        m_StateMachineInstance->dataContext(dataContext);
+    }
+}
\ No newline at end of file
diff --git a/src/animation/state_machine.cpp b/src/animation/state_machine.cpp
index 0450691..9b44672 100644
--- a/src/animation/state_machine.cpp
+++ b/src/animation/state_machine.cpp
@@ -91,6 +91,11 @@
     m_Listeners.push_back(std::move(listener));
 }
 
+void StateMachine::addDataBind(std::unique_ptr<DataBind> dataBind)
+{
+    m_dataBinds.push_back(std::move(dataBind));
+}
+
 const StateMachineInput* StateMachine::input(std::string name) const
 {
     for (auto& input : m_Inputs)
@@ -140,4 +145,13 @@
         return m_Listeners[index].get();
     }
     return nullptr;
+}
+
+const DataBind* StateMachine::dataBind(size_t index) const
+{
+    if (index < m_dataBinds.size())
+    {
+        return m_dataBinds[index].get();
+    }
+    return nullptr;
 }
\ No newline at end of file
diff --git a/src/animation/state_machine_instance.cpp b/src/animation/state_machine_instance.cpp
index 90bafbc..274ea78 100644
--- a/src/animation/state_machine_instance.cpp
+++ b/src/animation/state_machine_instance.cpp
@@ -904,6 +904,23 @@
     return getNamedInput<StateMachineTrigger, SMITrigger>(name);
 }
 
+void StateMachineInstance::dataContextFromInstance(ViewModelInstance* viewModelInstance)
+{
+    dataContext(new DataContext(viewModelInstance));
+}
+
+void StateMachineInstance::dataContext(DataContext* dataContext)
+{
+    m_DataContext = dataContext;
+    for (auto dataBind : m_dataBinds)
+    {
+        if (dataBind->is<DataBindContext>())
+        {
+            dataBind->as<DataBindContext>()->bindFromContext(dataContext);
+        }
+    }
+}
+
 size_t StateMachineInstance::stateChangedCount() const
 {
     size_t count = 0;
@@ -1039,4 +1056,14 @@
             }
         }
     }
+}
+
+BindableProperty* StateMachineInstance::bindablePropertyInstance(BindableProperty* bindableProperty)
+{
+    auto bindablePropertyInstance = m_bindablePropertyInstances.find(bindableProperty);
+    if (bindablePropertyInstance == m_bindablePropertyInstances.end())
+    {
+        return nullptr;
+    }
+    return bindablePropertyInstance->second;
 }
\ No newline at end of file
diff --git a/src/artboard.cpp b/src/artboard.cpp
index 47c5d04..3a0b299 100644
--- a/src/artboard.cpp
+++ b/src/artboard.cpp
@@ -173,9 +173,6 @@
             case NestedArtboardBase::typeKey:
                 m_NestedArtboards.push_back(object->as<NestedArtboard>());
                 break;
-            case DataBindContext::typeKey:
-                m_DataBinds.push_back(object->as<DataBind>());
-                break;
 
             case JoystickBase::typeKey:
             {
@@ -515,12 +512,12 @@
     for (auto dataBind : m_AllDataBinds)
     {
         dataBind->updateSourceBinding();
-        auto d = dataBind->m_Dirt;
+        auto d = dataBind->dirt();
         if (d == ComponentDirt::None)
         {
             continue;
         }
-        dataBind->m_Dirt = ComponentDirt::None;
+        dataBind->dirt(ComponentDirt::None);
         dataBind->update(d);
     }
 }
@@ -1004,102 +1001,38 @@
         auto value = m_DataContext->getViewModelInstance(nestedArtboard->dataBindPathIds());
         if (value != nullptr && value->is<ViewModelInstance>())
         {
-            nestedArtboard->artboard()->dataContextFromInstance(value, m_DataContext, false);
+            nestedArtboard->dataContextFromInstance(value, m_DataContext);
         }
         else
         {
-            nestedArtboard->artboard()->internalDataContext(m_DataContext,
-                                                            m_DataContext->parent(),
-                                                            false);
+            nestedArtboard->internalDataContext(m_DataContext, m_DataContext->parent());
         }
     }
     for (auto dataBind : m_DataBinds)
     {
         if (dataBind->is<DataBindContext>())
         {
-            dataBind->as<DataBindContext>()->bind();
+            dataBind->as<DataBindContext>()->bindFromContext(m_DataContext);
         }
     }
     if (isRoot)
     {
-        std::vector<Component*> dataBinds;
+        std::vector<DataBind*> dataBinds;
         populateDataBinds(&dataBinds);
-        buildDataBindDependencies(&dataBinds);
         sortDataBinds(dataBinds);
     }
 }
 
-void Artboard::sortDataBinds(std::vector<Component*> dataBinds)
+void Artboard::sortDataBinds(std::vector<DataBind*> dataBinds)
 {
-    DependencySorter sorter;
     // TODO: @hernan review this. Should not need to push to a component list to sort.
 
-    std::vector<Component*> dbOrder;
-    sorter.sort(dataBinds, dbOrder);
-    for (auto dataBind : dbOrder)
+    for (auto dataBind : dataBinds)
     {
         m_AllDataBinds.push_back(dataBind->as<DataBind>());
     }
 }
 
-void Artboard::buildDataBindDependencies(std::vector<Component*>* dataBinds)
-{
-    // TODO: @hernan review this dependency building
-    // Do we really need this? If a property is bound to a data bind, it can't be bound
-    // to a second data bind object.
-    for (auto component : *dataBinds)
-    {
-        auto dataBind = component->as<DataBind>();
-        auto flags = static_cast<DataBindFlags>(dataBind->flags());
-        // If the data bind reads from the target, we want to add it as dependent from any other
-        // parent data bind that writes into that target.
-        if (((flags & DataBindFlags::Direction) == DataBindFlags::ToSource) ||
-            ((flags & DataBindFlags::TwoWay) == DataBindFlags::TwoWay))
-        {
-            for (auto innerComponent : *dataBinds)
-            {
-                auto dataBindParent = innerComponent->as<DataBind>();
-                auto parentFlags = static_cast<DataBindFlags>(dataBindParent->flags());
-                if (dataBindParent != dataBind &&
-                    (((parentFlags & DataBindFlags::Direction) == DataBindFlags::ToTarget) ||
-                     ((parentFlags & DataBindFlags::TwoWay) == DataBindFlags::TwoWay)) &&
-                    dataBindParent->target() == dataBind->target() &&
-                    dataBindParent->propertyKey() == dataBind->propertyKey())
-                {
-                    dataBindParent->addDependent(dataBind);
-                    break;
-                }
-            }
-        }
-        else
-        {
-            // If the data bind reads from a source we want to add it as dependent
-            // from any other parent data bind that writes into that source.
-            if (dataBind->is<DataBindContext>())
-            {
-                for (auto innerComponent : *dataBinds)
-                {
-                    auto dataBindParent = innerComponent->as<DataBind>();
-                    if (dataBindParent != dataBind)
-                    {
-                        auto parentFlags = static_cast<DataBindFlags>(dataBindParent->flags());
-                        if (((parentFlags & DataBindFlags::Direction) == DataBindFlags::ToSource) ||
-                            ((parentFlags & DataBindFlags::TwoWay) == DataBindFlags::TwoWay))
-                        {
-                            if (dataBindParent->is<DataBindContext>() &&
-                                dataBindParent->as<DataBindContext>()->source() ==
-                                    dataBind->as<DataBindContext>()->source())
-                            {
-                                dataBindParent->addDependent(dataBind);
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
 float Artboard::volume() const { return m_volume; }
 void Artboard::volume(float value)
 {
@@ -1114,7 +1047,7 @@
     }
 }
 
-void Artboard::populateDataBinds(std::vector<Component*>* dataBinds)
+void Artboard::populateDataBinds(std::vector<DataBind*>* dataBinds)
 {
     for (auto dataBind : m_DataBinds)
     {
@@ -1129,6 +1062,8 @@
     }
 }
 
+void Artboard::addDataBind(DataBind* dataBind) { m_DataBinds.push_back(dataBind); }
+
 void Artboard::dataContext(DataContext* value, DataContext* parent)
 {
     internalDataContext(value, parent, true);
diff --git a/src/data_bind/context/context_value_boolean.cpp b/src/data_bind/context/context_value_boolean.cpp
index 3116aa9..b7b708b 100644
--- a/src/data_bind/context/context_value_boolean.cpp
+++ b/src/data_bind/context/context_value_boolean.cpp
@@ -6,16 +6,17 @@
 DataBindContextValueBoolean::DataBindContextValueBoolean(ViewModelInstanceValue* value)
 {
     m_Source = value;
+    m_Value = m_Source->as<ViewModelInstanceBoolean>()->propertyValue();
 }
 
-void DataBindContextValueBoolean::apply(Component* target, uint32_t propertyKey)
+void DataBindContextValueBoolean::apply(Core* target, uint32_t propertyKey)
 {
     CoreRegistry::setBool(target,
                           propertyKey,
                           m_Source->as<ViewModelInstanceBoolean>()->propertyValue());
 }
 
-void DataBindContextValueBoolean::applyToSource(Component* target, uint32_t propertyKey)
+void DataBindContextValueBoolean::applyToSource(Core* target, uint32_t propertyKey)
 {
     auto value = CoreRegistry::getBool(target, propertyKey);
     if (m_Value != value)
diff --git a/src/data_bind/context/context_value_color.cpp b/src/data_bind/context/context_value_color.cpp
index 18d392f..44a1857 100644
--- a/src/data_bind/context/context_value_color.cpp
+++ b/src/data_bind/context/context_value_color.cpp
@@ -6,16 +6,17 @@
 DataBindContextValueColor::DataBindContextValueColor(ViewModelInstanceValue* value)
 {
     m_Source = value;
+    m_Value = m_Source->as<ViewModelInstanceColor>()->propertyValue();
 }
 
-void DataBindContextValueColor::apply(Component* target, uint32_t propertyKey)
+void DataBindContextValueColor::apply(Core* target, uint32_t propertyKey)
 {
     CoreRegistry::setColor(target,
                            propertyKey,
                            m_Source->as<ViewModelInstanceColor>()->propertyValue());
 }
 
-void DataBindContextValueColor::applyToSource(Component* target, uint32_t propertyKey)
+void DataBindContextValueColor::applyToSource(Core* target, uint32_t propertyKey)
 {
     auto value = CoreRegistry::getColor(target, propertyKey);
     if (m_Value != value)
diff --git a/src/data_bind/context/context_value_enum.cpp b/src/data_bind/context/context_value_enum.cpp
index 8569ce9..a0064bc 100644
--- a/src/data_bind/context/context_value_enum.cpp
+++ b/src/data_bind/context/context_value_enum.cpp
@@ -6,17 +6,23 @@
 DataBindContextValueEnum::DataBindContextValueEnum(ViewModelInstanceValue* value)
 {
     m_Source = value;
+    m_Value = m_Source->as<ViewModelInstanceEnum>()->propertyValue();
 }
 
-void DataBindContextValueEnum::apply(Component* target, uint32_t propertyKey)
+void DataBindContextValueEnum::apply(Core* target, uint32_t propertyKey)
 {
     auto enumSource = m_Source->as<ViewModelInstanceEnum>();
     auto enumProperty = enumSource->viewModelProperty()->as<ViewModelPropertyEnum>();
     auto enumValue = enumProperty->value(m_Source->as<ViewModelInstanceEnum>()->propertyValue());
+    // TODO: @hernan decide which one makes more sense. Probably setUint, but setString was used to
+    // update text input with enum values.
     CoreRegistry::setString(target, propertyKey, enumValue);
+    CoreRegistry::setUint(target,
+                          propertyKey,
+                          m_Source->as<ViewModelInstanceEnum>()->propertyValue());
 }
 
-void DataBindContextValueEnum::applyToSource(Component* target, uint32_t propertyKey)
+void DataBindContextValueEnum::applyToSource(Core* target, uint32_t propertyKey)
 {
     auto value = CoreRegistry::getString(target, propertyKey);
     auto enumSource = m_Source->as<ViewModelInstanceEnum>();
diff --git a/src/data_bind/context/context_value_list.cpp b/src/data_bind/context/context_value_list.cpp
index 59f0f55..f0aa427 100644
--- a/src/data_bind/context/context_value_list.cpp
+++ b/src/data_bind/context/context_value_list.cpp
@@ -40,12 +40,12 @@
     return nullptr;
 }
 
-void DataBindContextValueList::insertItem(Component* target,
+void DataBindContextValueList::insertItem(Core* target,
                                           ViewModelInstanceListItem* listItem,
                                           int index)
 {
     auto artboard = listItem->artboard();
-    auto artboardCopy = createArtboard(target, artboard, listItem);
+    auto artboardCopy = createArtboard(target->as<Component>(), artboard, listItem);
     auto stateMachineInstance = createStateMachineInstance(artboardCopy.get());
     std::unique_ptr<DataBindContextValueListItem> cacheListItem =
         rivestd::make_unique<DataBindContextValueListItem>(std::move(artboardCopy),
@@ -61,14 +61,14 @@
     }
 }
 
-void DataBindContextValueList::swapItems(Component* target, int index1, int index2)
+void DataBindContextValueList::swapItems(Core* target, int index1, int index2)
 {
     std::iter_swap(m_ListItemsCache.begin() + index1, m_ListItemsCache.begin() + index2);
 }
 
-void DataBindContextValueList::popItem(Component* target) { m_ListItemsCache.pop_back(); }
+void DataBindContextValueList::popItem(Core* target) { m_ListItemsCache.pop_back(); }
 
-void DataBindContextValueList::update(Component* target)
+void DataBindContextValueList::update(Core* target)
 {
     if (target != nullptr)
     {
@@ -125,9 +125,9 @@
     }
 }
 
-void DataBindContextValueList::apply(Component* target, uint32_t propertyKey) {}
+void DataBindContextValueList::apply(Core* target, uint32_t propertyKey) {}
 
-void DataBindContextValueList::applyToSource(Component* target, uint32_t propertyKey)
+void DataBindContextValueList::applyToSource(Core* target, uint32_t propertyKey)
 {
     // TODO: @hernan does applyToSource make sense? Should we block it somehow?
 }
\ No newline at end of file
diff --git a/src/data_bind/context/context_value_number.cpp b/src/data_bind/context/context_value_number.cpp
index ecc5b7f..63fabf8 100644
--- a/src/data_bind/context/context_value_number.cpp
+++ b/src/data_bind/context/context_value_number.cpp
@@ -6,16 +6,17 @@
 DataBindContextValueNumber::DataBindContextValueNumber(ViewModelInstanceValue* value)
 {
     m_Source = value;
+    m_Value = m_Source->as<ViewModelInstanceNumber>()->propertyValue();
 }
 
-void DataBindContextValueNumber::apply(Component* target, uint32_t propertyKey)
+void DataBindContextValueNumber::apply(Core* target, uint32_t propertyKey)
 {
     CoreRegistry::setDouble(target,
                             propertyKey,
                             m_Source->as<ViewModelInstanceNumber>()->propertyValue());
 }
 
-void DataBindContextValueNumber::applyToSource(Component* target, uint32_t propertyKey)
+void DataBindContextValueNumber::applyToSource(Core* target, uint32_t propertyKey)
 {
     auto value = CoreRegistry::getDouble(target, propertyKey);
     if (m_Value != value)
diff --git a/src/data_bind/context/context_value_string.cpp b/src/data_bind/context/context_value_string.cpp
index 6a62e75..9cf19f7 100644
--- a/src/data_bind/context/context_value_string.cpp
+++ b/src/data_bind/context/context_value_string.cpp
@@ -6,16 +6,17 @@
 DataBindContextValueString::DataBindContextValueString(ViewModelInstanceValue* value)
 {
     m_Source = value;
+    m_Value = m_Source->as<ViewModelInstanceString>()->propertyValue();
 }
 
-void DataBindContextValueString::apply(Component* target, uint32_t propertyKey)
+void DataBindContextValueString::apply(Core* target, uint32_t propertyKey)
 {
     CoreRegistry::setString(target,
                             propertyKey,
                             m_Source->as<ViewModelInstanceString>()->propertyValue());
 }
 
-void DataBindContextValueString::applyToSource(Component* target, uint32_t propertyKey)
+void DataBindContextValueString::applyToSource(Core* target, uint32_t propertyKey)
 {
     auto value = CoreRegistry::getString(target, propertyKey);
     if (m_Value != value)
diff --git a/src/data_bind/data_bind.cpp b/src/data_bind/data_bind.cpp
index adfa276..a1ab715 100644
--- a/src/data_bind/data_bind.cpp
+++ b/src/data_bind/data_bind.cpp
@@ -2,6 +2,11 @@
 #include "rive/artboard.hpp"
 #include "rive/data_bind_flags.hpp"
 #include "rive/generated/core_registry.hpp"
+#include "rive/data_bind/bindable_property_number.hpp"
+#include "rive/data_bind/bindable_property_string.hpp"
+#include "rive/data_bind/bindable_property_color.hpp"
+#include "rive/data_bind/bindable_property_enum.hpp"
+#include "rive/data_bind/bindable_property_boolean.hpp"
 #include "rive/data_bind/context/context_value.hpp"
 #include "rive/data_bind/context/context_value_boolean.hpp"
 #include "rive/data_bind/context/context_value_number.hpp"
@@ -9,14 +14,12 @@
 #include "rive/data_bind/context/context_value_enum.hpp"
 #include "rive/data_bind/context/context_value_list.hpp"
 #include "rive/data_bind/context/context_value_color.hpp"
+#include "rive/animation/state_machine.hpp"
+#include "rive/importers/artboard_importer.hpp"
+#include "rive/importers/state_machine_importer.hpp"
 
 using namespace rive;
 
-// StatusCode DataBind::onAddedClean(CoreContext* context)
-// {
-//     return Super::onAddedClean(context);
-// }
-
 StatusCode DataBind::onAddedDirty(CoreContext* context)
 {
     StatusCode code = Super::onAddedDirty(context);
@@ -24,28 +27,44 @@
     {
         return code;
     }
-    auto coreObject = context->resolve(targetId());
-    if (coreObject == nullptr || !coreObject->is<Component>())
-    {
-        return StatusCode::MissingObject;
-    }
-
-    m_target = static_cast<Component*>(coreObject);
 
     return StatusCode::Ok;
 }
 
-StatusCode DataBind::import(ImportStack& importStack) { return Super::import(importStack); }
-
-void DataBind::buildDependencies()
+StatusCode DataBind::import(ImportStack& importStack)
 {
-    Super::buildDependencies();
-    auto flagsValue = static_cast<DataBindFlags>(flags());
-    if (((flagsValue & DataBindFlags::Direction) == DataBindFlags::ToSource) ||
-        ((flagsValue & DataBindFlags::TwoWay) == DataBindFlags::TwoWay))
+    if (target())
     {
-        m_target->addDependent(this);
+        switch (target()->coreType())
+        {
+            case BindablePropertyNumberBase::typeKey:
+            case BindablePropertyStringBase::typeKey:
+            case BindablePropertyBooleanBase::typeKey:
+            case BindablePropertyEnumBase::typeKey:
+            case BindablePropertyColorBase::typeKey:
+            {
+                auto stateMachineImporter =
+                    importStack.latest<StateMachineImporter>(StateMachineBase::typeKey);
+                if (stateMachineImporter != nullptr)
+                {
+                    stateMachineImporter->addDataBind(std::unique_ptr<DataBind>(this));
+                    return Super::import(importStack);
+                }
+                break;
+            }
+            default:
+            {
+                auto artboardImporter = importStack.latest<ArtboardImporter>(ArtboardBase::typeKey);
+                if (artboardImporter != nullptr)
+                {
+                    artboardImporter->addDataBind(this);
+                    return Super::import(importStack);
+                }
+                break;
+            }
+        }
     }
+    return Super::import(importStack);
 }
 
 void DataBind::bind()
@@ -97,7 +116,6 @@
             }
         }
     }
-    Super::update(value);
 }
 
 void DataBind::updateSourceBinding()
@@ -111,4 +129,16 @@
             m_ContextValue->applyToSource(m_target, propertyKey());
         }
     }
+}
+
+bool DataBind::addDirt(ComponentDirt value, bool recurse)
+{
+    if ((m_Dirt & value) == value)
+    {
+        // Already marked.
+        return false;
+    }
+
+    m_Dirt |= value;
+    return true;
 }
\ No newline at end of file
diff --git a/src/data_bind/data_bind_context.cpp b/src/data_bind/data_bind_context.cpp
index 4bb86f6..62eae73 100644
--- a/src/data_bind/data_bind_context.cpp
+++ b/src/data_bind/data_bind_context.cpp
@@ -26,9 +26,8 @@
     m_SourcePathIdsBuffer = object.as<DataBindContext>()->m_SourcePathIdsBuffer;
 }
 
-void DataBindContext::bind()
+void DataBindContext::bindFromContext(DataContext* dataContext)
 {
-    auto dataContext = artboard()->dataContext();
     if (dataContext != nullptr)
     {
         auto value = dataContext->getViewModelProperty(m_SourcePathIdsBuffer);
@@ -36,7 +35,7 @@
         {
             value->addDependent(this);
             m_Source = value;
-            Super::bind();
+            bind();
         }
     }
 }
\ No newline at end of file
diff --git a/src/file.cpp b/src/file.cpp
index 93bdf04..57fb4a7 100644
--- a/src/file.cpp
+++ b/src/file.cpp
@@ -8,6 +8,7 @@
 #include "rive/generated/core_registry.hpp"
 #include "rive/importers/artboard_importer.hpp"
 #include "rive/importers/backboard_importer.hpp"
+#include "rive/importers/bindable_property_importer.hpp"
 #include "rive/importers/enum_importer.hpp"
 #include "rive/importers/file_asset_importer.hpp"
 #include "rive/importers/import_stack.hpp"
@@ -30,6 +31,12 @@
 #include "rive/animation/animation_state.hpp"
 #include "rive/animation/blend_state_1d.hpp"
 #include "rive/animation/blend_state_direct.hpp"
+#include "rive/data_bind/bindable_property.hpp"
+#include "rive/data_bind/bindable_property_number.hpp"
+#include "rive/data_bind/bindable_property_string.hpp"
+#include "rive/data_bind/bindable_property_color.hpp"
+#include "rive/data_bind/bindable_property_enum.hpp"
+#include "rive/data_bind/bindable_property_boolean.hpp"
 #include "rive/assets/file_asset.hpp"
 #include "rive/assets/audio_asset.hpp"
 #include "rive/assets/file_asset_contents.hpp"
@@ -204,6 +211,10 @@
 ImportResult File::read(BinaryReader& reader, const RuntimeHeader& header)
 {
     ImportStack importStack;
+    // TODO: @hernan consider moving this to a special importer. It's not that
+    // simple because Core doesn't have a typeKey, so it should be treated as
+    // a special case. In any case, it's not that bad having it here for now.
+    Core* lastBindableObject;
     while (!reader.reachedEnd())
     {
         auto object = readRuntimeObject(reader, header);
@@ -212,6 +223,14 @@
             importStack.readNullObject();
             continue;
         }
+        if (!object->is<DataBind>())
+        {
+            lastBindableObject = object;
+        }
+        else if (lastBindableObject != nullptr)
+        {
+            object->as<DataBind>()->target(lastBindableObject);
+        }
         if (object->import(importStack) == StatusCode::Ok)
         {
             switch (object->coreType())
@@ -353,6 +372,15 @@
                     object->as<ViewModelInstanceList>());
                 stackType = ViewModelInstanceList::typeKey;
                 break;
+            case BindablePropertyNumber::typeKey:
+            case BindablePropertyString::typeKey:
+            case BindablePropertyColor::typeKey:
+            case BindablePropertyEnum::typeKey:
+            case BindablePropertyBoolean::typeKey:
+                stackObject =
+                    rivestd::make_unique<BindablePropertyImporter>(object->as<BindableProperty>());
+                stackType = BindablePropertyBase::typeKey;
+                break;
         }
         if (importStack.makeLatest(stackType, std::move(stackObject)) != StatusCode::Ok)
         {
diff --git a/src/generated/data_bind/bindable_property_boolean_base.cpp b/src/generated/data_bind/bindable_property_boolean_base.cpp
new file mode 100644
index 0000000..4e3dcc2
--- /dev/null
+++ b/src/generated/data_bind/bindable_property_boolean_base.cpp
@@ -0,0 +1,11 @@
+#include "rive/generated/data_bind/bindable_property_boolean_base.hpp"
+#include "rive/data_bind/bindable_property_boolean.hpp"
+
+using namespace rive;
+
+Core* BindablePropertyBooleanBase::clone() const
+{
+    auto cloned = new BindablePropertyBoolean();
+    cloned->copy(*this);
+    return cloned;
+}
diff --git a/src/generated/data_bind/bindable_property_color_base.cpp b/src/generated/data_bind/bindable_property_color_base.cpp
new file mode 100644
index 0000000..fa64a07
--- /dev/null
+++ b/src/generated/data_bind/bindable_property_color_base.cpp
@@ -0,0 +1,11 @@
+#include "rive/generated/data_bind/bindable_property_color_base.hpp"
+#include "rive/data_bind/bindable_property_color.hpp"
+
+using namespace rive;
+
+Core* BindablePropertyColorBase::clone() const
+{
+    auto cloned = new BindablePropertyColor();
+    cloned->copy(*this);
+    return cloned;
+}
diff --git a/src/generated/data_bind/bindable_property_enum_base.cpp b/src/generated/data_bind/bindable_property_enum_base.cpp
new file mode 100644
index 0000000..acd5be6
--- /dev/null
+++ b/src/generated/data_bind/bindable_property_enum_base.cpp
@@ -0,0 +1,11 @@
+#include "rive/generated/data_bind/bindable_property_enum_base.hpp"
+#include "rive/data_bind/bindable_property_enum.hpp"
+
+using namespace rive;
+
+Core* BindablePropertyEnumBase::clone() const
+{
+    auto cloned = new BindablePropertyEnum();
+    cloned->copy(*this);
+    return cloned;
+}
diff --git a/src/generated/data_bind/bindable_property_number_base.cpp b/src/generated/data_bind/bindable_property_number_base.cpp
new file mode 100644
index 0000000..95b0453
--- /dev/null
+++ b/src/generated/data_bind/bindable_property_number_base.cpp
@@ -0,0 +1,11 @@
+#include "rive/generated/data_bind/bindable_property_number_base.hpp"
+#include "rive/data_bind/bindable_property_number.hpp"
+
+using namespace rive;
+
+Core* BindablePropertyNumberBase::clone() const
+{
+    auto cloned = new BindablePropertyNumber();
+    cloned->copy(*this);
+    return cloned;
+}
diff --git a/src/generated/data_bind/bindable_property_string_base.cpp b/src/generated/data_bind/bindable_property_string_base.cpp
new file mode 100644
index 0000000..04133c7
--- /dev/null
+++ b/src/generated/data_bind/bindable_property_string_base.cpp
@@ -0,0 +1,11 @@
+#include "rive/generated/data_bind/bindable_property_string_base.hpp"
+#include "rive/data_bind/bindable_property_string.hpp"
+
+using namespace rive;
+
+Core* BindablePropertyStringBase::clone() const
+{
+    auto cloned = new BindablePropertyString();
+    cloned->copy(*this);
+    return cloned;
+}
diff --git a/src/importers/artboard_importer.cpp b/src/importers/artboard_importer.cpp
index d0d93df..f2957b0 100644
--- a/src/importers/artboard_importer.cpp
+++ b/src/importers/artboard_importer.cpp
@@ -2,6 +2,7 @@
 #include "rive/importers/artboard_importer.hpp"
 #include "rive/animation/linear_animation.hpp"
 #include "rive/animation/state_machine.hpp"
+#include "rive/data_bind/data_bind.hpp"
 #include "rive/text/text_value_run.hpp"
 #include "rive/event.hpp"
 #include "rive/artboard.hpp"
@@ -22,6 +23,8 @@
     m_Artboard->addStateMachine(stateMachine);
 }
 
+void ArtboardImporter::addDataBind(DataBind* dataBind) { m_Artboard->addDataBind(dataBind); }
+
 StatusCode ArtboardImporter::resolve() { return m_Artboard->initialize(); }
 
 bool ArtboardImporter::readNullObject()
diff --git a/src/importers/bindable_property_importer.cpp b/src/importers/bindable_property_importer.cpp
new file mode 100644
index 0000000..1d992af
--- /dev/null
+++ b/src/importers/bindable_property_importer.cpp
@@ -0,0 +1,9 @@
+#include "rive/artboard.hpp"
+#include "rive/importers/bindable_property_importer.hpp"
+#include "rive/data_bind/bindable_property.hpp"
+
+using namespace rive;
+
+BindablePropertyImporter::BindablePropertyImporter(BindableProperty* bindableProperty) :
+    m_bindableProperty(bindableProperty)
+{}
\ No newline at end of file
diff --git a/src/importers/state_machine_importer.cpp b/src/importers/state_machine_importer.cpp
index 7994c37..70a3985 100644
--- a/src/importers/state_machine_importer.cpp
+++ b/src/importers/state_machine_importer.cpp
@@ -3,6 +3,7 @@
 #include "rive/animation/state_machine_listener.hpp"
 #include "rive/animation/state_machine_input.hpp"
 #include "rive/animation/state_machine_layer.hpp"
+#include "rive/data_bind/data_bind.hpp"
 
 using namespace rive;
 
@@ -23,6 +24,11 @@
     m_StateMachine->addListener(std::move(listener));
 }
 
+void StateMachineImporter::addDataBind(std::unique_ptr<DataBind> dataBind)
+{
+    m_StateMachine->addDataBind(std::move(dataBind));
+}
+
 bool StateMachineImporter::readNullObject()
 {
     // Hard assumption that we won't add new layer types...
diff --git a/src/nested_artboard.cpp b/src/nested_artboard.cpp
index 6ef8cf3..19437dc 100644
--- a/src/nested_artboard.cpp
+++ b/src/nested_artboard.cpp
@@ -273,4 +273,29 @@
 void NestedArtboard::copyDataBindPathIds(const NestedArtboardBase& object)
 {
     m_DataBindPathIdsBuffer = object.as<NestedArtboard>()->m_DataBindPathIdsBuffer;
+}
+
+void NestedArtboard::internalDataContext(DataContext* value, DataContext* parent)
+{
+    artboard()->internalDataContext(value, parent, false);
+    for (auto animation : m_NestedAnimations)
+    {
+        if (animation->is<NestedStateMachine>())
+        {
+            animation->as<NestedStateMachine>()->dataContext(value);
+        }
+    }
+}
+
+void NestedArtboard::dataContextFromInstance(ViewModelInstance* viewModelInstance,
+                                             DataContext* parent)
+{
+    artboard()->dataContextFromInstance(viewModelInstance, parent, false);
+    for (auto animation : m_NestedAnimations)
+    {
+        if (animation->is<NestedStateMachine>())
+        {
+            animation->as<NestedStateMachine>()->dataContextFromInstance(viewModelInstance);
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/scene.cpp b/src/scene.cpp
index a987dfe..679f33e 100644
--- a/src/scene.cpp
+++ b/src/scene.cpp
@@ -25,6 +25,7 @@
 SMIBool* Scene::getBool(const std::string&) const { return nullptr; }
 SMINumber* Scene::getNumber(const std::string&) const { return nullptr; }
 SMITrigger* Scene::getTrigger(const std::string&) const { return nullptr; }
+void Scene::dataContextFromInstance(ViewModelInstance* viewModelInstance) {}
 
 void Scene::reportKeyedCallback(uint32_t objectId, uint32_t propertyKey, float elapsedSeconds)
 {
diff --git a/src/viewmodel/viewmodel_instance_enum.cpp b/src/viewmodel/viewmodel_instance_enum.cpp
index 0cdbc60..3b7a755 100644
--- a/src/viewmodel/viewmodel_instance_enum.cpp
+++ b/src/viewmodel/viewmodel_instance_enum.cpp
@@ -8,7 +8,7 @@
 
 using namespace rive;
 
-void ViewModelInstanceEnum::propertyValueChanged() { addDirt(ComponentDirt::Components); }
+void ViewModelInstanceEnum::propertyValueChanged() { addDirt(ComponentDirt::Bindings); }
 
 bool ViewModelInstanceEnum::value(std::string name)
 {