diff --git a/XternalAppsParametricTool.py b/XternalAppsParametricTool.py
index 9bd8988..a7b5aa1 100644
--- a/XternalAppsParametricTool.py
+++ b/XternalAppsParametricTool.py
@@ -1,14 +1,16 @@
 import FreeCAD as App
 import FreeCADGui
-#from xml.etree import ElementTree
 from lxml import etree
 import ExternalAppsList
 from ToolXML import *
 from collections import namedtuple
 import re
+from copy import deepcopy
+from collections import defaultdict
 
-XFormsInput = namedtuple('XFormsInput', ['input', 'modelElement', 'type', 'maybeEnum'])
+XFormsInput = namedtuple('XFormsInput', ['input', 'modelElementPath', 'type', 'maybeEnum', 'InputValueToModelValue', 'ModelValueToInputValue'])
 XFormsEnum = namedtuple('XFormsEnum', ['labels', 'values'])
+InterpretedXML = namedtuple('InterpretedXML', ['xml', 'types', 'inputs']) # Parsed XML, dictionary(modelElementPath) -> type, dictionary(formElementPath) -> XFormsInput
 
 def CreateCommand(appName, toolName):
     App.ActiveDocument.openTransaction('Create parametric %s from %s'%(toolName, appName))
@@ -45,14 +47,71 @@ def MIMETypeToFreeCADType(MIMEType):
     else:
         raise ArgumentException('Unsupported MIME type')
 
+def encode_bytes(bytestring):
+    try:
+        return ("utf-8", bytestring.decode('utf-8', errors='strict'))
+    except ValueError:
+        from base64 import b64encode
+        return ("base64", b64encode(bytestring))
+
+def decode_bytes(encoding_and_string):
+    encoding, string = encoding_and_string
+    if encoding == "utf-8":
+        return string.encode('utf-8')
+    elif encoding == "base64":
+        from base64 import b64decode
+        return b64decode(string)
+    else:
+        raise ValueError("invalid encoding: expected utf-8 or base64")
+
 class XternalAppsParametricTool():
     def __init__(self, obj, appName, toolName):
         self.Type = "XternalAppsParametricTool"
         self.AppName = appName
         self.ToolName = toolName
         obj.Proxy = self
+        self.ModelInstance = self.getDefaultModelInstance(obj)
+        self.ModelToProperties = {}
+        self.ModelOnChanged = defaultdict(set)
         self.createPropertiesFromXML(obj)
 
+    def __getstate__(self):
+        copied = self.__dict__.copy()
+        copied['ModelInstance'] = encode_bytes(etree.tostring(copied['ModelInstance']))
+        return copied
+
+    def __setstate__(self, state):
+        if state:
+            state['ModelInstance'] = etree.fromstring(decode_bytes(state['ModelInstance']))
+            self.__dict__ = state
+            
+    def getDefaultModelInstance(self, obj):
+        xml = etree.parse(self.Tool.XForms)
+        model = xml.find('./xforms:model', ns)
+        instanceDocument = etree.ElementTree(model.find('./xforms:instance/*', ns))
+        return deepcopy(instanceDocument)
+
+    def typecheckModelInstance(self, types, instance):
+        """TODO"""
+
+    def updateModelInstance(self, instance, ref, value):
+        """TODO"""
+
+    def onChanged(self, obj, prop):
+        if hasattr(self, 'SimpleInputNameToInput'):
+            inputPath = self.SimpleInputNameToInput.get(prop, None)
+            if inputPath is not None:
+                modelElementPath = self.Inputs[inputPath].modelElementPath
+                modelElement = self.ModelInstance.find(modelElementPath)
+                newText = self.Inputs[inputPath].InputValueToModelValue(getattr(obj, prop))
+                print((prop, getattr(obj, prop), modelElement.text, newText))
+                if modelElement.text != newText:
+                    modelElement.text = newText
+                    for inputPathToUpdate in self.ModelOnChanged[modelElementPath]:
+                        if inputPathToUpdate != inputPath:
+                            # TODO: this is terrible and will lead to infinite update loops
+                            setattr(obj, self.InputToSimpleInputName[inputPathToUpdate], self.Inputs[inputPathToUpdate].ModelValueToInputValue(newText))
+
     def interpretFormElement(self, xmlXFormsElement, xml, instanceDocument, types):
         # TODO: is it safe to pass input unprotected here?
         modelElement = instanceDocument.find(xmlXFormsElement.attrib['ref'],
@@ -60,11 +119,12 @@ class XternalAppsParametricTool():
         if modelElement is None:
             raise Exception('Could not find ' + xmlXFormsElement.attrib['ref'] \
                             + ' in instance document with namespaces=' + repr(xmlXFormsElement.nsmap))
-        type = types.get(instanceDocument.getpath(modelElement))
+        modelElementPath = instanceDocument.getelementpath(modelElement)
+        type = types.get(modelElementPath)
         if type is None:
-            raise Exception('Could not find type for ' + instanceDocument.getpath(modelElement))
-        path = xml.getpath(xmlXFormsElement)
-        return (path, xmlXFormsElement, modelElement, type)
+            raise Exception('Could not find type for ' + modelElementPath)
+        path = xml.getelementpath(xmlXFormsElement)
+        return (path, xmlXFormsElement, modelElementPath, type)
 
     def interpretXML(self):
         """Parse the self.Tool.XForms document, and return
@@ -72,22 +132,17 @@ class XternalAppsParametricTool():
         * a dictionary types[path] = "type"
         * a dictionary inputs[path] = (xml_input_element, xml_model_element, type)."""
         types = {}
-        modelInstance = {}
+        #modelInstance = {}
         inputs = {}
 
         xml = etree.parse(self.Tool.XForms)
         model = xml.find('./xforms:model', ns)
         instanceDocument = etree.ElementTree(model.find('./xforms:instance/*', ns))
 
-        # Traverse the XForms instance and register all elements in modelInstance[pathToElement]
-        for element in instanceDocument.findall('.//*'):
-            path = instanceDocument.getpath(element)
-            modelInstance[path] = element.text
-
         # register all xform:bind to types[pathToTargetElement]
         for bind in model.findall('xforms:bind', ns):
             for bound in instanceDocument.findall(bind.attrib['ref'], namespaces=bind.nsmap):
-                path = instanceDocument.getpath(bound)
+                path = instanceDocument.getelementpath(bound)
                 # TODO: if has attrib type then …
                 type = bind.attrib['type']
                 # TODO: I guess XForms implicitly allows intersection types by using several bind statements?
@@ -97,37 +152,86 @@ class XternalAppsParametricTool():
         # register all inputs to inputs[pathToElement]
         for group in xml.findall('./xforms:group', ns):
             for input in group.findall('./xforms:input', ns):
-                path, xmlXFormsElement, modelElement, type = self.interpretFormElement(input, xml, instanceDocument, types)
-                inputs[path] = XFormsInput(input=xmlXFormsElement, modelElement=modelElement, type=type, maybeEnum=None)
+                path, xmlXFormsElement, modelElementPath, type = self.interpretFormElement(input, xml, instanceDocument, types)
+                inputs[path] = XFormsInput(input=xmlXFormsElement, modelElementPath=modelElementPath, type=type, maybeEnum=None, InputValueToModelValue = None, ModelValueToInputValue = None)
             for select1 in group.findall('./xforms:select1', ns):
-                path, xmlXFormsElement, modelElement, type = self.interpretFormElement(select1, xml, instanceDocument, types)
+                path, xmlXFormsElement, modelElementPath, type = self.interpretFormElement(select1, xml, instanceDocument, types)
                 # Gather the allowed elements for the enum
                 enum = {}
                 for item in select1.findall('./xforms:item', ns):
                   enum[item.attrib['label']] = item.attrib['value']
-                inputs[path] = XFormsInput(input=xmlXFormsElement, modelElement=modelElement, type=type, maybeEnum=enum)
-        return (xml, types, modelInstance, inputs)
+                inputs[path] = XFormsInput(input=xmlXFormsElement, modelElementPath=modelElementPath, type=type, maybeEnum=enum, InputValueToModelValue = None, ModelValueToInputValue = None)
+        return InterpretedXML(xml=xml, types=types, inputs=inputs) # modelInstance, 
 
     def toSimpleName(self, name):
         return re.sub(r'( |[^-a-zA-Z0-9])+', ' ', name).title().replace(' ', '')
 
+    def toUniqueSimpleName(self, name, mutableNextUnique):
+        m = re.match(r'^((.*[^0-9])?)([0-9]*)$', name)
+        base = m.group(1)
+        counter = m.group(3)
+        if counter == '' and mutableNextUnique[base] == 0:
+            mutableNextUnique[name] = 1
+        elif counter == '':
+            counter = str(mutableNextUnique[name])
+            mutableNextUnique[name] = mutableNextUnique[name] + 1
+        elif int(counter) > mutableNextUnique[name]:
+            mutableNextUnique[name] = str(int(counter)+1)
+        else:
+            counter = str(mutableNextUnique[name])
+            mutableNextUnique[name] = mutableNextUnique[name] + 1
+        return base + counter
+
     def createPropertiesFromXML(self, obj):
-        xml, types, modelInstance, inputs = self.interpretXML()
-        for (input, modelElement, type, maybeEnum) in inputs.values():
-            simpleName = self.toSimpleName(input.attrib['label'])
+        xml, types, inputs = self.interpretXML() # modelInstance,
+        simpleInputNameToInput = {}
+        inputToSimpleInputName = {}
+        nextUniqueSimpleName = defaultdict(lambda: 0)
+        inputs2 = {}
+        for inputPath, (input, modelElementPath, type, maybeEnum, _1, _2) in inputs.items():
+            simpleName = self.toUniqueSimpleName(self.toSimpleName(input.attrib['label']), nextUniqueSimpleName)
+            simpleInputNameToInput[simpleName] = inputPath
+            inputToSimpleInputName[inputPath] = simpleName
+        
             group = "/".join(input.xpath('ancestor-or-self::xforms:group/xforms:label/text()', namespaces=ns)) or None
-            print((simpleName, typeToFreeCADType(type, maybeEnum), maybeEnum))
+
+            loadedValue = self.ModelInstance.find(modelElementPath).text
+
             obj.addProperty(typeToFreeCADType(type, maybeEnum),
                             simpleName,
                             group,
                             input.attrib['label'] + '\nA value of type ' + type)
+
+            inputValueToModelValue = str
+            modelValueToInputValue = lambda x: x
             if maybeEnum is not None:
-                setattr(obj, simpleName, [self.toSimpleName(k) for k in maybeEnum.keys()])
-                # TODO: have a converter from the labels to the values
+                enumWithSimpleNames = { self.toSimpleName(k): v for k, v in maybeEnum.items() }
+                setattr(obj, simpleName, list(enumWithSimpleNames.keys()))
+                inputValueToModelValue = enumWithSimpleNames.get
+                modelValueToInputValue = {v: l for l, v in enumWithSimpleNames.items()}.get
+
+            if loadedValue is not None:
+                print("setting " + simpleName + "(full label = " + input.attrib['label'] + ") to " + str(loadedValue))
+                setattr(obj, simpleName, modelValueToInputValue(loadedValue))
+            
+            # TODO: refactor this!
+            inputs2[inputPath] = XFormsInput(
+                input=input,
+                modelElementPath=modelElementPath,
+                type=type,
+                maybeEnum=maybeEnum,
+                InputValueToModelValue = inputValueToModelValue,
+                ModelValueToInputValue = modelValueToInputValue)
+            
+            self.ModelOnChanged[modelElementPath].add(inputPath)
+        self.Types = types
+        self.Inputs = inputs2
+        self.SimpleInputNameToInput = simpleInputNameToInput
+        self.InputToSimpleInputName = inputToSimpleInputName
 
     @property
     def Tool(self):
         return ExternalAppsList.apps[self.AppName].Tools[self.ToolName]
 
-def execute(self, obj):
+    def execute(self, obj):
         """This is called when the object is recomputed"""
diff --git a/myTool.xforms b/myTool.xforms
index c58450b..5ba14bb 100644
--- a/myTool.xforms
+++ b/myTool.xforms
@@ -12,8 +12,8 @@
     <xforms:instance>
       <my:tool>
         <my:svgfile/>
-        <my:option1/>
-        <my:option2>default value</my:option2>
+        <my:option1>default value</my:option1>
+        <my:option2/>
         <my:option3>bar</my:option3>
       </my:tool>
     </xforms:instance>
@@ -22,8 +22,8 @@
     -->
     <!-- use XternalApps:pipe to have the file piped directly into the command being run -->
     <xforms:bind ref="my:svgfile" type="mime:image/svg+xml" required="true()"/>
-    <xforms:bind ref="my:option1" type="xsd:decimal" required="true()"/>
-    <xforms:bind ref="my:option2" type="xsd:string" required="true()"/>
+    <xforms:bind ref="my:option1" type="xsd:string" required="true()"/>
+    <xforms:bind ref="my:option2" type="xsd:decimal" required="true()"/>
     <xforms:bind ref="my:option3" type="xsd:string" required="true()"/>
     <!--<xforms:submission action="myTool.py" method="exec-double-dash" />-->
     <XternalApps:command medhod="exec" style="double-dash">
@@ -48,5 +48,9 @@
       <xforms:item label="Foo label" value="foo"/>
       <xforms:item label="Bar label" value="bar"/>
     </xforms:select1>
+    <xforms:select1 ref="my:option3" label="Option Three (alt labels)">
+      <xforms:item label="Alt foo label" value="foo"/>
+      <xforms:item label="ALt bar label" value="bar"/>
+    </xforms:select1>
   </xforms:group>
 </XternalApps:tool>