diff --git a/assets/games/liminal/scenes/prologue/ScenePrologue0.xml b/assets/games/liminal/scenes/prologue/ScenePrologue0.xml
index 2163328f..e42b1dbf 100644
--- a/assets/games/liminal/scenes/prologue/ScenePrologue0.xml
+++ b/assets/games/liminal/scenes/prologue/ScenePrologue0.xml
@@ -255,10 +255,12 @@
     </text>
 
     <text>
-      <string lang="en">No.
-      They would die.
-      For me.
-      If I called for it.</string>
+      <string lang="en">
+        No.
+        They would die.
+        For me.
+        If I called for it.
+      </string>
     </text>
 
     <!--
diff --git a/lib/SDL b/lib/SDL
index c065a9b1..4a53dc5b 160000
--- a/lib/SDL
+++ b/lib/SDL
@@ -1 +1 @@
-Subproject commit c065a9b1289a1de09981c46a4c5e53e3627fd95c
+Subproject commit 4a53dc5b8ddb77b09f069d171f5277cee877a0f3
diff --git a/lib/freetype b/lib/freetype
index e4586d96..dec2743e 160000
--- a/lib/freetype
+++ b/lib/freetype
@@ -1 +1 @@
-Subproject commit e4586d960f339cf75e2e0b34aee30a0ed8353c0d
+Subproject commit dec2743e6a2a40cddfc8a9892895cb4f861e1eeb
diff --git a/lib/openal-soft b/lib/openal-soft
index 2da9d168..05f9ce8b 160000
--- a/lib/openal-soft
+++ b/lib/openal-soft
@@ -1 +1 @@
-Subproject commit 2da9d168b6bee32376889a394e11981a4515d041
+Subproject commit 05f9ce8b978239cebecef1a60f0d451a118fa3df
diff --git a/src/dawn/scene/components/ui/text/UILabel.cpp b/src/dawn/scene/components/ui/text/UILabel.cpp
index 881705de..854d7ff1 100644
--- a/src/dawn/scene/components/ui/text/UILabel.cpp
+++ b/src/dawn/scene/components/ui/text/UILabel.cpp
@@ -122,6 +122,7 @@ void UILabel::rebufferQuads(const std::vector<struct UILabelText> newTexts) {
 
   // Reset
   lines.clear();
+  textureMap.clear();
 
   // Determine font dimensions.
   auto itText = newTexts.begin();
diff --git a/src/dawn/scene/components/ui/text/UIRichTextLabel.cpp b/src/dawn/scene/components/ui/text/UIRichTextLabel.cpp
index ec710eb5..04986758 100644
--- a/src/dawn/scene/components/ui/text/UIRichTextLabel.cpp
+++ b/src/dawn/scene/components/ui/text/UIRichTextLabel.cpp
@@ -29,33 +29,33 @@ void UIRichTextLabel::onStart() {
     }
 
     std::function<void(Xml*)> parseChildren = [&](Xml *node) {
-      if(node->children.empty()) {
-        if(node->node == "root") return;
-        struct UILabelText text;
-        text.style = current;
-        text.text = node->value;
-        bufferTexts.push_back(text);
-      } else {
-        auto itNode = node->children.begin();
-        while(itNode != node->children.end()) {
-          auto child = *itNode;
-          assertTrue(child->node == "font");
+      auto itChildren = node->childNodes.begin();
+      while(itChildren != node->childNodes.end()) {
+        auto child = *itChildren;
+        if(child.nodeType == XML_NODE_TYPE_TEXT) {
+          struct UILabelText text;
+          text.style = current;
+          text.text = child.value;
+          bufferTexts.push_back(text);
+        } else if(child.nodeType == XML_NODE_TYPE_ELEMENT) {
+          auto node = child.child;
+          assertTrue(node->node == "font");
 
           struct UILabelStyle style;
-          if(child->attributes.contains("font")) {
-            style.font = this->getGame()->assetManager.get<TrueTypeAsset>(child->attributes["font"]);
+          if(node->attributes.contains("font")) {
+            style.font = this->getGame()->assetManager.get<TrueTypeAsset>(node->attributes["font"]);
           } else {
             style.font = current.font;
           }
 
-          if(child->attributes.contains("size")) {
-            style.size = std::stoi(child->attributes["size"]);
+          if(node->attributes.contains("size")) {
+            style.size = std::stoi(node->attributes["size"]);
           } else {
             style.size = current.size;
           }
 
-          if(child->attributes.contains("style")) {
-            std::string s = child->attributes["style"];
+          if(node->attributes.contains("style")) {
+            std::string s = node->attributes["style"];
             style.style = 0;
             if(s.find("bold") != std::string::npos) style.style |= TRUE_TYPE_VARIANT_BOLD;
             if(s.find("italic") != std::string::npos) style.style |= TRUE_TYPE_VARIANT_ITALICS;
@@ -63,25 +63,23 @@ void UIRichTextLabel::onStart() {
             style.style = current.style;
           }
 
-          if(child->attributes.contains("color")) {
-            style.color = Color::fromString(child->attributes["color"]);
+          if(node->attributes.contains("color")) {
+            style.color = Color::fromString(node->attributes["color"]);
           } else {
             style.color = current.color;
           }
 
           styleStack.push_back(style);
           current = style;
-
-          parseChildren(child);
-
+          parseChildren(node);
           styleStack.pop_back();
           current = styleStack.back();
-          ++itNode;
         }
+        ++itChildren;
       }
     };
 
-    auto root = Xml::load("<root>" + ((std::string)this->richText) + "</root>");
+    auto root = Xml::load("<root><font font=\"font_main\">" + ((std::string)this->richText) + "</font></root>");
     parseChildren(&root);
     this->rebufferQuads(bufferTexts);
   }, this->richText)();
diff --git a/src/dawnliminal/scenes/HelloWorldScene.hpp b/src/dawnliminal/scenes/HelloWorldScene.hpp
index ec365bb5..12797a3e 100644
--- a/src/dawnliminal/scenes/HelloWorldScene.hpp
+++ b/src/dawnliminal/scenes/HelloWorldScene.hpp
@@ -8,7 +8,6 @@
 #include "prefabs/SimpleSpinningCubePrefab.hpp"
 #include "scene/components/display/Camera.hpp"
 #include "scene/components/ui/text/UIRichTextLabel.hpp"
-#include "prefabs/VNTextbox.hpp"
 
 namespace Dawn {
   class HelloWorldScene : public Scene {
@@ -25,28 +24,12 @@ namespace Dawn {
         auto canvasItem = this->createSceneItem();
         auto canvas = canvasItem->addComponent<UICanvas>();
         canvas->camera = camera;
-        
-        auto textboxItem = this->createSceneItem();
-        auto textbox = textboxItem->addComponent<UIRichTextLabel>();
-        textbox->alignX = UI_COMPONENT_ALIGN_STRETCH;
-        textbox->alignY = UI_COMPONENT_ALIGN_STRETCH;
-        textbox->alignment = glm::vec4(0, 0, 0, 0);
-        textbox->richText = std::string(
-          "<font font=\"font_main\" size=\"64\" style=\"italics\" color=\"MAGENTA\">"
-            "Hello World"
-          "</font>"
-          "<font font=\"font_main\" size=\"64\" style=\"bold\" color=\"WHITE\">"
-            "BBBBBB"
-          "</font>"
-        );
-        textbox->transform->setParent(canvas->transform);
       }
       
       std::vector<Asset*> getRequiredAssets() override {
         auto assMan = &this->game->assetManager;
         std::vector<Asset*> assets;
         vectorAppend(&assets, SimpleSpinningCubePrefab::getRequiredAssets(assMan));
-        assets.push_back(assMan->get<TrueTypeAsset>("font_main"));
         return assets;
       }
 
diff --git a/src/dawnshared/util/Xml.cpp b/src/dawnshared/util/Xml.cpp
index 9dd94886..ba89006d 100644
--- a/src/dawnshared/util/Xml.cpp
+++ b/src/dawnshared/util/Xml.cpp
@@ -7,6 +7,12 @@
 
 using namespace Dawn;
 
+XmlNode::XmlNode() {
+  this->child = nullptr;
+  this->value.clear();
+}
+
+
 bool_t Xml::isWhitespace(char_t c) {
   return c == ' ' || c == '\r' || c == '\n' || c == '\t';
 }
@@ -26,9 +32,8 @@ void Xml::load(Xml *xml, std::string data, size_t *j) {
   bool_t insideTag = false;
   std::string buffer = "";
   std::string attrKey = "";
-  std::string bufferWhitespaces;
-  bool_t valueIsInWhitespace = false;
   size_t i = *j;
+  struct XmlNode childNode;
   
   while(c = data[i++]) {
     if(insideTag) {
@@ -39,26 +44,21 @@ void Xml::load(Xml *xml, std::string data, size_t *j) {
       case XML_PARSE_STATE_DOING_NOTHING:
         if(c == '>') continue;
         if(c == '<') {
+          // Parsing comment?
           if(data[i] == '!' && data[i+1] == '-' && data[i+2] == '-') {
             doingBeforeComment = doing;
             doing = XML_PARSE_STATE_PARSING_COMMENT;
             i += 3;
+          } else if(data[i] == '!' && !insideTag) {
+            // Likely <!DOCTYPE ...>
+            while((c = data[i++]) != '>') {
+              // Nothing needs doing here right now, in future may support doctype
+            }
+            continue;
           } else if(insideTag) {
             if(data[i] == '/') {
-              i -= 1;
-              doing = XML_PARSE_STATE_PARSING_CHILD;
-            } else {
-              i -= 1;
-              auto child = new Xml();
-              Xml::load(child, data, &i);
-              xml->children.push_back(child);
-              doing = XML_PARSE_STATE_PARSING_CHILD;
-
-
-              // Remove last char since we kinda already parsed it.
-              xml->innerXml += child->outerXml;
-              xml->outerXml = xml->outerXml.substr(0, xml->outerXml.size()-1);
-              xml->outerXml += child->outerXml;
+              doing = XML_PARSE_STATE_PARSING_CLOSE;
+              continue;
             }
           } else {
             doing = XML_PARSE_STATE_PARSING_TAG_NAME;
@@ -69,8 +69,8 @@ void Xml::load(Xml *xml, std::string data, size_t *j) {
           continue;
         }
 
-        xml->innerXml += c;
-        if(Xml::isWhitespace(c)) continue;
+        if(insideTag) xml->innerXml += c;
+        if(Xml::isWhitespace(c)) continue;// NEEDS TO GO?
         doing = XML_PARSE_STATE_PARSING_VALUE;
         buffer += c;
         break;
@@ -86,7 +86,7 @@ void Xml::load(Xml *xml, std::string data, size_t *j) {
             insideTag = false;
             doing = XML_PARSE_STATE_PARSING_CLOSE;
           } else {
-            doing = c == '>' ? XML_PARSE_STATE_DOING_NOTHING : XML_PARSE_STATE_LOOKING_FOR_ATTRIBUTE;
+            doing = c == '>' ? XML_PARSE_STATE_PARSING_VALUE : XML_PARSE_STATE_LOOKING_FOR_ATTRIBUTE;
           }
           continue;
         }
@@ -98,7 +98,7 @@ void Xml::load(Xml *xml, std::string data, size_t *j) {
         // Look until we hit either the end of a tag, or the attribute itself
         if(Xml::isWhitespace(c) || c == '>' || c == '/' || c == '=') {
           if(c == '>' || c == '/') {
-            doing = XML_PARSE_STATE_DOING_NOTHING;
+            doing = XML_PARSE_STATE_PARSING_VALUE;
             if(c == '/') {
               level--;
               insideTag = false;
@@ -149,116 +149,86 @@ void Xml::load(Xml *xml, std::string data, size_t *j) {
       case XML_PARSE_STATE_PARSING_VALUE:
         // Keep parsing child until we find a < for an opening/closing tag.
         if(c == '<' && !(data[i] == '<' || data[i-2] == '<')) {
+          if(buffer.size() > 0) {
+            childNode.nodeType = XML_NODE_TYPE_TEXT;
+            childNode.value = buffer;
+            xml->childNodes.push_back(childNode);
+          }
+
+          // Are we parsing the close tag, or parsing a child?
           if(data[i] == '/') {
-            // In HTML Spec there could be a child here but not in XML spec.
             doing = XML_PARSE_STATE_PARSING_CLOSE;
-            xml->value = buffer;
+            xml->textContent = buffer;
             buffer.clear();
-            valueIsInWhitespace = false;
-            bufferWhitespaces.clear();
             continue;
-          }
-
-          std::cout << "Detected unsupported use of a child within a node value, e.g. <div>Hello <b>world</b> how are you?</div>" << std::endl;
-          throw "Test";
-          continue;
-        }
-
-        xml->innerXml += c;
-
-        if(Xml::isWhitespace(c)) {
-          if(!valueIsInWhitespace) {
-            bufferWhitespaces.clear();
-            bufferWhitespaces += c;
-            valueIsInWhitespace = true;
-          } else {
-            if(c != ' ') bufferWhitespaces += c;
-          }
-          // TODO: I can maybe consider indentation here
-        } else {
-          if(valueIsInWhitespace) {
-            buffer += bufferWhitespaces;
-            valueIsInWhitespace = false;
-          }
-
-          if(c == '&') {
-            // Handle special characters. First read ahead to nearest semicolon OR
-            // nearest closing tag.
-            std::string sc;
-            while(c = data[i++]) {
-              xml->innerXml += c;
-              if(c == ';') break;
-              if(c == '<') assertUnreachable();//Invalid XML
-              sc += c;
-            }
-
-            if(valueIsInWhitespace) {
-              buffer += bufferWhitespaces;
-              valueIsInWhitespace = false;
-            }
-            
-            if(sc == "lt") {
-              buffer += '<';
-            } else if(sc == "gt") {
-              buffer += '>';
-            } else if(sc == "amp") {
-              buffer += '&';
-            } else if(sc == "apos") {
-              buffer += '\'';
-            } else if(sc == "quot") {
-              buffer += '"';
-            } else if(sc == "nbsp") {
-              buffer += ' ';
-            } else {
-              // Try parse as integer
-              if(sc.size() > 1 && sc[0] == '#') {
-                int code = std::stoi(sc.substr(1));
-                buffer += (char)code;
-              } else {
-                std::cout << "Unknown Special character: " << sc << std::endl;
-                assertUnreachable();
-              }
-            }
-          } else {
-            buffer += c;
-          }
-        }
-
-        break;
-        
-      case XML_PARSE_STATE_PARSING_CHILD:
-        if(c == '<') {
-          // Read ahead and confirm this is a close or not
-          if(data[i] == '/') {
-            doing = XML_PARSE_STATE_PARSING_CLOSE;
-            continue;
-          }
-
-          if(data[i] == '!' && data[i+1] == '-' && data[i+2] == '-') {
+          } else if(data[i] == '!' && data[i+1] == '-' && data[i+2] == '-') {
             doingBeforeComment = doing;
             doing = XML_PARSE_STATE_PARSING_COMMENT;
             i += 3;
             continue;
           }
 
-          // Likely another child.
-          auto child = new Xml();
+          // Parsing child
           i -= 1;
+
+          // @deprecated
+          auto child = new Xml();
           Xml::load(child, data, &i);
           xml->children.push_back(child);
 
+          childNode = XmlNode();
+          childNode.nodeType = XML_NODE_TYPE_ELEMENT;
+          childNode.child = child;
+          xml->childNodes.push_back(childNode);
+
+          // Remove last char since we kinda already parsed it.
           xml->innerXml += child->outerXml;
           xml->outerXml = xml->outerXml.substr(0, xml->outerXml.size()-1);
           xml->outerXml += child->outerXml;
-        }
 
-        if(Xml::isWhitespace(c)) {
-          xml->innerXml += c;
+          buffer.clear();
           continue;
         }
 
-        // In HTML Spec there's a chance for there to be a value here, but not
-        // in the XML spec.
+        xml->innerXml += c;
+
+        if(c == '&') {
+          // Handle special characters. First read ahead to nearest semicolon OR
+          // nearest closing tag.
+          std::string sc;
+          while(c = data[i++]) {
+            xml->innerXml += c;
+            if(c == ';') break;
+            if(c == '<') assertUnreachable();//Invalid XML
+            sc += c;
+          }
+
+          if(sc == "lt") {
+            buffer += '<';
+          } else if(sc == "gt") {
+            buffer += '>';
+          } else if(sc == "amp") {
+            buffer += '&';
+          } else if(sc == "apos") {
+            buffer += '\'';
+          } else if(sc == "quot") {
+            buffer += '"';
+          } else if(sc == "nbsp") {
+            buffer += ' ';
+          } else {
+            // Try parse as integer
+            if(sc.size() > 1 && sc[0] == '#') {
+              int code = std::stoi(sc.substr(1));
+              buffer += (char)code;
+            } else {
+              std::cout << "Unknown Special character: " << sc << std::endl;
+              assertUnreachable();
+            }
+          }
+        } else {
+          buffer += c;
+        }
+
         break;
       
       case XML_PARSE_STATE_PARSING_CLOSE:
diff --git a/src/dawnshared/util/Xml.hpp b/src/dawnshared/util/Xml.hpp
index 8af4936f..02849cd2 100644
--- a/src/dawnshared/util/Xml.hpp
+++ b/src/dawnshared/util/Xml.hpp
@@ -17,11 +17,18 @@ namespace Dawn {
     XML_PARSE_STATE_LOOKING_FOR_ATTRIBUTE_VALUE,
     XML_PARSE_STATE_PARSING_ATTRIBUTE_VALUE,
     XML_PARSE_STATE_PARSING_VALUE,
-    XML_PARSE_STATE_PARSING_CHILD,
     XML_PARSE_STATE_PARSING_CLOSE,
     XML_PARSE_STATE_PARSING_COMMENT
   };
 
+  class Xml;
+  struct XmlNode;
+
+  enum XmlNodeType {
+    XML_NODE_TYPE_TEXT,
+    XML_NODE_TYPE_ELEMENT
+  };
+
   class Xml {
     protected:
       static bool_t isWhitespace(char_t c);
@@ -31,10 +38,13 @@ namespace Dawn {
       static void load(Xml *xml, std::string data, size_t *j);
 
       std::string node;
-      std::string value;
       std::string innerXml;
       std::string outerXml;
+      std::string textContent;
       std::map<std::string, std::string> attributes;
+      std::vector<struct XmlNode> childNodes;
+
+      // @deprecated
       std::vector<Xml*> children;
       
       std::vector<Xml*> getChildrenOfType(std::string type);
@@ -42,4 +52,12 @@ namespace Dawn {
 
       ~Xml();
   };
+
+  struct XmlNode {
+    enum XmlNodeType nodeType;
+    std::string value;
+    Xml *child;
+
+    XmlNode();
+  };
 }
\ No newline at end of file
diff --git a/src/dawntools/util/parser/SceneCodeParser.cpp b/src/dawntools/util/parser/SceneCodeParser.cpp
index 0c839221..c523a98f 100644
--- a/src/dawntools/util/parser/SceneCodeParser.cpp
+++ b/src/dawntools/util/parser/SceneCodeParser.cpp
@@ -33,7 +33,7 @@ int32_t SceneCodeParser::onParse(
   }
 
   // Get the code
-  out->code = node->value;
+  out->code = node->textContent;
 
   return 0;
 }
\ No newline at end of file