Index: binaries/data/mods/public/gui/pregame/MainMenuPage.js
===================================================================
--- binaries/data/mods/public/gui/pregame/MainMenuPage.js
+++ binaries/data/mods/public/gui/pregame/MainMenuPage.js
@@ -9,6 +9,46 @@
 		this.menuHandler = new MainMenuItemHandler(mainMenuItems);
 		this.splashScreenHandler = new SplashScreenHandler(data, hotloadData && hotloadData.splashScreenHandler);
 
+		let toto = Engine.GetGUIObjectByName("mainMenuPage");
+		let doText = (caption, size) => ({
+			"@type": "text",
+			"@size": size,
+			"@style": "ModernLabelText",
+			"@caption": caption,
+		});
+		let added = toto.createChild({
+			"@type": "image",
+			"@size": "200 200 500 500",
+			"@style": "ModernDialog",
+			"@z": 200,
+			"object": [
+				doText("turlututu", "0 0 200 200"),
+				{
+					"@type": "text",
+					"@size": "0 200 200 400",
+					"@style": "ModernLabelText",
+					"@caption": "ChapoPointu",
+					"object": {
+						"@type": "image",
+						"@size": "600 300 100% 600+40",
+						"@style": "ModernDialog",
+						"@z": 250,
+					}
+				}]
+		});
+		added.deleteChild(added.children[0].name);
+
+		toto.createChild({
+			"script": {
+				"@file": "not_a_file.js",
+			},
+		});
+
+
+		toto.createChild({
+			"script": "warn('Hey you')",
+		});
+
 		new MusicHandler();
 		new ProjectInformationHandler(projectInformation);
 		new CommunityButtonHandler(communityButtons);
Index: source/gui/CGUI.h
===================================================================
--- source/gui/CGUI.h
+++ source/gui/CGUI.h
@@ -43,6 +43,7 @@
 
 class CGUISpriteInstance;
 class CGUISprite;
+class CParamNode;
 class IGUIObject;
 struct SGUIImageEffects;
 struct SGUIScrollBarStyle;
@@ -251,6 +252,18 @@
 
 	shared_ptr<ScriptInterface> GetScriptInterface() { return m_ScriptInterface; };
 
+	/**
+	 * The CGUI creates the object and adds it as a child to parent.
+	 * To the created object, this is the same as being created on page open (same events, etc.)
+	 */
+	IGUIObject* CreateChildFromParamNode(const CParamNode& paramNode, IGUIObject* parent, std::vector<std::pair<CStr, CStr>>& nameSubst, u32 depth);
+
+	/**
+	 * Detach the object from its parent and delete it.
+	 * The object must have a parent - use PopPage to delete the root page object.
+	 */
+	void DetachAndDeleteChild(IGUIObject* child);
+
 private:
 	/**
 	 * The CGUI takes ownership of the child object and links the parent with the child.
@@ -349,16 +362,12 @@
 	// Read Roots
 
 	/**
-	 * Reads in the root element \<objects\> (the DOMElement).
+	 * Reads in the "objects" root element
 	 *
-	 * @param Element	The Xeromyces object that represents
-	 *					the objects-tag.
-	 * @param pFile		The Xeromyces object for the file being read
-	 * @param Paths		Collects the set of all XML/JS files that are loaded
-	 *
-	 * @see LoadXmlFile()
+	 * @param paramNode input data.
+	 * @param Paths		Collects the set of all files that are loaded
 	 */
-	void Xeromyces_ReadRootObjects(XMBElement Element, CXeromyces* pFile, std::unordered_set<VfsPath>& Paths);
+	void ReadRootObjects(const CParamNode& paramNode, std::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Reads in the root element \<sprites\> (the DOMElement).
@@ -417,7 +426,7 @@
 	 *
 	 * @see LoadXmlFile()
 	 */
-	void Xeromyces_ReadObject(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth);
+	IGUIObject* ReadObject(const CParamNode& paramNode, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth);
 
 	/**
 	 * Reads in the element \<repeat\>, which repeats its child \<object\>s
@@ -425,7 +434,7 @@
 	 * 'var' enclosed in square brackets) in its descendants' names with "[0]",
 	 * "[1]", etc.
 	 */
-	void Xeromyces_ReadRepeat(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth);
+	void ReadRepeat(const CParamNode& paramNode, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth);
 
 	/**
 	 * Reads in the element \<script\> (the XMBElement) and executes
@@ -438,7 +447,7 @@
 	 *
 	 * @see LoadXmlFile()
 	 */
-	void Xeromyces_ReadScript(XMBElement Element, CXeromyces* pFile, std::unordered_set<VfsPath>& Paths);
+	void ReadScript(const CParamNode& paramNode, std::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Reads in the element \<sprite\> (the XMBElement) and stores the
Index: source/gui/CGUI.cpp
===================================================================
--- source/gui/CGUI.cpp
+++ source/gui/CGUI.cpp
@@ -41,6 +41,7 @@
 #include "renderer/Renderer.h"
 #include "scriptinterface/ScriptContext.h"
 #include "scriptinterface/ScriptInterface.h"
+#include "simulation2/system/ParamNode.h"
 
 #include <string>
 #include <unordered_map>
@@ -331,6 +332,36 @@
 	return (*it->second)(*this);
 }
 
+
+IGUIObject* CGUI::CreateChildFromParamNode(const CParamNode& paramNode, IGUIObject* parent, std::vector<std::pair<CStr, CStr>>& nameSubst, u32 depth)
+{
+	std::unordered_set<VfsPath> paths;
+	IGUIObject* child = ReadObject(paramNode, parent, nameSubst, paths, depth);
+	if (!child)
+		return nullptr;
+
+	child->RecurseObject(nullptr, &IGUIObject::UpdateCachedSize);
+	SGUIMessage msg(GUIM_LOAD);
+	child->RecurseObject(nullptr, &IGUIObject::HandleMessage, msg);
+	child->ScriptEvent(EventNameLoad);
+
+	return child;
+}
+
+void CGUI::DetachAndDeleteChild(IGUIObject* child)
+{
+	if (!child)
+		return;
+	if (!child->m_pParent)
+	{
+		LOGERROR("Cannot delete the root object of a page");
+		return;
+	}
+	child->m_pParent->RemoveChild(*child);
+	m_pAllObjects.erase(child->m_Name);
+	delete child;
+}
+
 bool CGUI::AddObject(IGUIObject& parent, IGUIObject& child)
 {
 	if (child.m_Name.empty())
@@ -491,16 +522,19 @@
 	if (XeroFile.Load(g_VFS, Filename, "gui") != PSRETURN_OK)
 		return;
 
+	CParamNode paramNode;
+	CParamNode::LoadXML(paramNode, XeroFile);
+
 	XMBElement node = XeroFile.GetRoot();
 	CStr root_name(XeroFile.GetElementString(node.GetNodeName()));
 
-	if (root_name == "objects")
-		Xeromyces_ReadRootObjects(node, &XeroFile, Paths);
-	else if (root_name == "sprites")
+	if (paramNode.GetChild("objects").IsOk())
+		ReadRootObjects(paramNode.GetChild("objects"), Paths);
+	else if (paramNode.GetChild("sprites").IsOk())
 		Xeromyces_ReadRootSprites(node, &XeroFile);
-	else if (root_name == "styles")
+	else if (paramNode.GetChild("styles").IsOk())
 		Xeromyces_ReadRootStyles(node, &XeroFile);
-	else if (root_name == "setup")
+	else if (paramNode.GetChild("setup").IsOk())
 		Xeromyces_ReadRootSetup(node, &XeroFile);
 	else
 		LOGERROR("CGUI::LoadXmlFile encountered an unknown XML root node type: %s", root_name.c_str());
@@ -520,22 +554,23 @@
 //	XML Reading Xeromyces Specific Sub-Routines
 //===================================================================
 
-void CGUI::Xeromyces_ReadRootObjects(XMBElement Element, CXeromyces* pFile, std::unordered_set<VfsPath>& Paths)
+void CGUI::ReadRootObjects(const CParamNode& paramNode, std::unordered_set<VfsPath>& Paths)
 {
-	int el_script = pFile->GetElementID("script");
+	std::vector<std::pair<CStr, CStr>> subst;
 
-	std::vector<std::pair<CStr, CStr> > subst;
-
-	// Iterate main children
-	//  they should all be <object> or <script> elements
-	for (XMBElement child : Element.GetChildNodes())
+	// Iterate main children.
+	// They should all be <object> or <script> elements.
+	for (const auto& child : paramNode.GetChildren())
 	{
-		if (child.GetNodeName() == el_script)
+		if (child.first == "script")
 			// Execute the inline script
-			Xeromyces_ReadScript(child, pFile, Paths);
-		else
+			ReadScript(child.second, Paths);
+	}
+	for (const auto& child : paramNode.GetChildren())
+	{
+		if (child.first == "object")
 			// Read in this whole object into the GUI
-			Xeromyces_ReadObject(child, pFile, m_BaseObject.get(), subst, Paths, 0);
+			ReadObject(child.second, m_BaseObject.get(), subst, Paths, 0);
 	}
 }
 
@@ -570,13 +605,11 @@
 	}
 }
 
-void CGUI::Xeromyces_ReadObject(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth)
+IGUIObject* CGUI::ReadObject(const CParamNode& paramNode, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth)
 {
 	ENSURE(pParent);
 
-	XMBAttributeList attributes = Element.GetAttributes();
-
-	CStr type(attributes.GetNamedItem(pFile->GetAttributeID("type")));
+	CStr type(paramNode.GetChild("@type").ToUTF8());
 	if (type.empty())
 		type = "empty";
 
@@ -588,31 +621,9 @@
 	if (!object)
 	{
 		LOGERROR("GUI: Unrecognized object type \"%s\"", type.c_str());
-		return;
+		return nullptr;
 	}
 
-	// Cache some IDs for element attribute names, to avoid string comparisons
-	#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
-	#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
-	ELMT(object);
-	ELMT(action);
-	ELMT(script);
-	ELMT(repeat);
-	ELMT(translatableAttribute);
-	ELMT(translate);
-	ELMT(attribute);
-	ELMT(keep);
-	ELMT(include);
-	ATTR(style);
-	ATTR(type);
-	ATTR(name);
-	ATTR(z);
-	ATTR(on);
-	ATTR(file);
-	ATTR(directory);
-	ATTR(id);
-	ATTR(context);
-
 	//
 	//	Read Style and set defaults
 	//
@@ -622,7 +633,7 @@
 	//
 	SetObjectStyle(object, "default");
 
-	CStr argStyle(attributes.GetNamedItem(attr_style));
+	CStr argStyle(paramNode.GetChild("@style").ToUTF8());
 	if (!argStyle.empty())
 		SetObjectStyle(object, argStyle);
 
@@ -631,19 +642,22 @@
 
 	CStrW inclusionPath;
 
-	for (XMBAttribute attr : attributes)
+	for (const auto& child : paramNode.GetChildren())
 	{
+		if (!child.first.attribute)
+			continue;
+
 		// If value is "null", then it is equivalent as never being entered
-		if (attr.Value == "null")
+		if (child.second.ToString() == L"null")
 			continue;
 
 		// Ignore "type" and "style", we've already checked it
-		if (attr.Name == attr_type || attr.Name == attr_style)
+		if (child.first == "@type" || child.first == "@style")
 			continue;
 
-		if (attr.Name == attr_name)
+		if (child.first == "@name")
 		{
-			CStr name(attr.Value);
+			CStr name(child.second.ToUTF8());
 
 			for (const std::pair<CStr, CStr>& sub : NameSubst)
 				name.Replace(sub.first, sub.second);
@@ -653,10 +667,10 @@
 			continue;
 		}
 
-		if (attr.Name == attr_z)
+		if (child.first == "@z")
 			ManuallySetZ = true;
 
-		object->SetSettingFromString(pFile->GetAttributeString(attr.Name), attr.Value.FromUTF8(), false);
+		object->SetSettingFromString(child.first.name.substr(1), child.second.ToString(), false);
 	}
 
 	// Check if name isn't set, generate an internal name in that case.
@@ -666,26 +680,26 @@
 		++m_InternalNameNumber;
 	}
 
-	CStrW caption(Element.GetText().FromUTF8());
+	CStrW caption(paramNode.ToString());
 	if (!caption.empty())
 		object->SetSettingFromString("caption", caption, false);
 
-	for (XMBElement child : Element.GetChildNodes())
+	for (const auto& child : paramNode.GetChildren())
 	{
-		// Check what name the elements got
-		int element_name = child.GetNodeName();
+		if (child.first.attribute)
+			continue;
 
-		if (element_name == elmt_object)
+		if (child.first == "object")
 		{
 			// Call this function on the child
-			Xeromyces_ReadObject(child, pFile, object, NameSubst, Paths, nesting_depth);
+			ReadObject(child.second, object, NameSubst, Paths, nesting_depth);
 		}
-		else if (element_name == elmt_action)
+		else if (child.first == "action")
 		{
 			// Scripted <action> element
 
 			// Check for a 'file' parameter
-			CStrW filename(child.GetAttributes().GetNamedItem(attr_file).FromUTF8());
+			CStrW filename(child.second.GetChild("@file").ToString());
 
 			CStr code;
 
@@ -703,45 +717,35 @@
 				code = scriptfile.DecodeUTF8(); // assume it's UTF-8
 			}
 
-			XMBElementList grandchildren = child.GetChildNodes();
-			if (!grandchildren.empty()) // The <action> element contains <keep> and <translate> tags.
-				for (XMBElement grandchild : grandchildren)
-				{
-					if (grandchild.GetNodeName() == elmt_translate)
-						code += g_L10n.Translate(grandchild.GetText());
-					else if (grandchild.GetNodeName() == elmt_keep)
-						code += grandchild.GetText();
-				}
-			else // It's pure JavaScript code.
-				// Read the inline code (concatenating to the file code, if both are specified)
-				code += CStr(child.GetText());
+			// Read the inline code (concatenating to the file code, if both are specified)
+			code += child.second.ToUTF8();
 
-			CStr eventName = child.GetAttributes().GetNamedItem(attr_on);
+			CStr eventName = child.second.GetChild("@on").ToUTF8();
 			object->RegisterScriptHandler(eventName, code, *this);
 		}
-		else if (child.GetNodeName() == elmt_script)
+		else if (child.first == "script")
 		{
-			Xeromyces_ReadScript(child, pFile, Paths);
+			ReadScript(child.second, Paths);
 		}
-		else if (element_name == elmt_repeat)
+		else if (child.first == "repeat")
 		{
-			Xeromyces_ReadRepeat(child, pFile, object, NameSubst, Paths, nesting_depth);
+			ReadRepeat(child.second, object, NameSubst, Paths, nesting_depth);
 		}
-		else if (element_name == elmt_translatableAttribute)
+		else if (child.first == "translatableAttribute")
 		{
 			// This is an element in the form "<translatableAttribute id="attributeName">attributeValue</translatableAttribute>".
-			CStr attributeName(child.GetAttributes().GetNamedItem(attr_id)); // Read the attribute name.
+			CStr attributeName(child.second.GetChild("@id").ToUTF8()); // Read the attribute name.
 			if (attributeName.empty())
 			{
 				LOGERROR("GUI: 'translatableAttribute' XML element with empty 'id' XML attribute found. (object: %s)", object->GetPresentableName().c_str());
 				continue;
 			}
 
-			CStr value(child.GetText());
+			CStr value(child.second.ToUTF8());
 			if (value.empty())
 				continue;
 
-			CStr context(child.GetAttributes().GetNamedItem(attr_context)); // Read the context if any.
+			CStr context(child.second.GetChild("@context").ToUTF8()); // Read the context if any.
 
 			CStr translatedValue = context.empty() ?
 				g_L10n.Translate(value) :
@@ -749,32 +753,10 @@
 
 			object->SetSettingFromString(attributeName, translatedValue.FromUTF8(), false);
 		}
-		else if (element_name == elmt_attribute)
+		else if (child.first == "include")
 		{
-			// This is an element in the form "<attribute id="attributeName"><keep>Don't translate this part
-			// </keep><translate>but translate this one.</translate></attribute>".
-			CStr attributeName(child.GetAttributes().GetNamedItem(attr_id)); // Read the attribute name.
-			if (attributeName.empty())
-			{
-				LOGERROR("GUI: 'attribute' XML element with empty 'id' XML attribute found. (object: %s)", object->GetPresentableName().c_str());
-				continue;
-			}
-
-			CStr translatedValue;
-
-			for (XMBElement grandchild : child.GetChildNodes())
-			{
-				if (grandchild.GetNodeName() == elmt_translate)
-					translatedValue += g_L10n.Translate(grandchild.GetText());
-				else if (grandchild.GetNodeName() == elmt_keep)
-					translatedValue += grandchild.GetText();
-			}
-			object->SetSettingFromString(attributeName, translatedValue.FromUTF8(), false);
-		}
-		else if (element_name == elmt_include)
-		{
-			CStrW filename(child.GetAttributes().GetNamedItem(attr_file).FromUTF8());
-			CStrW directory(child.GetAttributes().GetNamedItem(attr_directory).FromUTF8());
+			CStrW filename(child.second.GetChild("@file").ToString());
+			CStrW directory(child.second.GetChild("@directory").ToString());
 			if (!filename.empty())
 			{
 				if (!directory.empty())
@@ -789,8 +771,10 @@
 					continue;
 				}
 
-				XMBElement node = XeroIncluded.GetRoot();
-				if (node.GetNodeName() != XeroIncluded.GetElementID("object"))
+				CParamNode included;
+				CParamNode::LoadXML(included, XeroIncluded);
+
+				if (!included.GetChild("object").IsOk())
 				{
 					LOGERROR("GUI: Error reading included XML: '%s', root element must have be of type 'object'.", utf8_from_wstring(filename));
 					continue;
@@ -802,7 +786,7 @@
 					continue;
 				}
 
-				Xeromyces_ReadObject(node, &XeroIncluded, object, NameSubst, Paths, nesting_depth+1);
+				ReadObject(included.GetChild("object"), object, NameSubst, Paths, nesting_depth+1);
 			}
 			else if (!directory.empty())
 			{
@@ -826,13 +810,15 @@
 						continue;
 					}
 
-					XMBElement node = XeroIncluded.GetRoot();
-					if (node.GetNodeName() != XeroIncluded.GetElementID("object"))
+					CParamNode included;
+					CParamNode::LoadXML(included, XeroIncluded);
+
+					if (!included.GetChild("object").IsOk())
 					{
 						LOGERROR("GUI: Error reading included XML: '%s', root element must have be of type 'object'.", path.string8());
 						continue;
 					}
-					Xeromyces_ReadObject(node, &XeroIncluded, object, NameSubst, Paths, nesting_depth+1);
+					ReadObject(included.GetChild("object"), object, NameSubst, Paths, nesting_depth+1);
 				}
 
 			}
@@ -842,8 +828,8 @@
 		else
 		{
 			// Try making the object read the tag.
-			if (!object->HandleAdditionalChildren(child, pFile))
-				LOGERROR("GUI: (object: %s) Reading unknown children for its type", object->GetPresentableName().c_str());
+			if (!object->HandleAdditionalChildren(child.first.name, child.second))
+				LOGERROR("GUI: (object: %s) Reading unknown children for its type - %s", object->GetPresentableName().c_str(), child.first.name);
 		}
 	}
 
@@ -862,21 +848,17 @@
 	}
 
 	if (!AddObject(*pParent, *object))
+	{
 		delete object;
+		return nullptr;
+	}
+	return object;
 }
 
-void CGUI::Xeromyces_ReadRepeat(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth)
+void CGUI::ReadRepeat(const CParamNode& paramNode, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth)
 {
-	#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
-	#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
-	ELMT(object);
-	ATTR(count);
-	ATTR(var);
-
-	XMBAttributeList attributes = Element.GetAttributes();
-
-	int count = CStr(attributes.GetNamedItem(attr_count)).ToInt();
-	CStr var("["+attributes.GetNamedItem(attr_var)+"]");
+	int count = paramNode.GetChild("@count").ToInt();
+	CStr var("["+paramNode.GetChild("@var").ToUTF8()+"]");
 	if (var.size() < 3)
 		var = "[n]";
 
@@ -884,19 +866,19 @@
 	{
 		NameSubst.emplace_back(var, "[" + CStr::FromInt(n) + "]");
 
-		XERO_ITER_EL(Element, child)
+		for (const auto& child : paramNode.GetChildren())
 		{
-			if (child.GetNodeName() == elmt_object)
-				Xeromyces_ReadObject(child, pFile, pParent, NameSubst, Paths, nesting_depth);
+			if (child.first == "object")
+				ReadObject(child.second, pParent, NameSubst, Paths, nesting_depth);
 		}
 		NameSubst.pop_back();
 	}
 }
 
-void CGUI::Xeromyces_ReadScript(XMBElement Element, CXeromyces* pFile, std::unordered_set<VfsPath>& Paths)
+void CGUI::ReadScript(const CParamNode& paramNode, std::unordered_set<VfsPath>& Paths)
 {
 	// Check for a 'file' parameter
-	CStrW file(Element.GetAttributes().GetNamedItem(pFile->GetAttributeID("file")).FromUTF8());
+	CStrW file(paramNode.GetChild("@file").ToString());
 
 	// If there is a file specified, open and execute it
 	if (!file.empty())
@@ -911,7 +893,7 @@
 	}
 
 	// If it has a directory attribute, read all JS files in that directory
-	CStrW directory(Element.GetAttributes().GetNamedItem(pFile->GetAttributeID("directory")).FromUTF8());
+	CStrW directory(paramNode.GetChild("@directory").ToString());
 	if (!directory.empty())
 	{
 		if (VfsPath(directory).IsDirectory())
@@ -929,7 +911,7 @@
 			LOGERROR("GUI: Script path %s is not a directory path", directory.ToUTF8().c_str());
 	}
 
-	CStr code(Element.GetText());
+	CStr code(paramNode.ToUTF8());
 	if (!code.empty())
 		m_ScriptInterface->LoadGlobalScript(L"Some XML file", code);
 }
Index: source/gui/ObjectBases/IGUIObject.h
===================================================================
--- source/gui/ObjectBases/IGUIObject.h
+++ source/gui/ObjectBases/IGUIObject.h
@@ -35,6 +35,7 @@
 #include <vector>
 
 class CGUI;
+class CParamNode;
 class IGUIObject;
 class IGUISetting;
 
@@ -106,9 +107,16 @@
 	CStr GetPresentableName() const;
 
 	/**
-	 * Builds the object hierarchy with references.
+	 * Create a child object from the given definition.
+	 * @return nullptr on failure.
 	 */
-	void AddChild(IGUIObject& pChild);
+	IGUIObject* CreateChild(const CParamNode& node);
+
+	/**
+	 * Remove a child & delete it.
+	 * @return whether the child was deleted.
+	 */
+	bool DeleteChild(IGUIObject* child);
 
 	/**
 	 * Return all child objects of the current object.
@@ -249,12 +257,21 @@
 	 * Methods that the CGUI will call using
 	 * its friendship, these should not
 	 * be called by user.
-	 * These functions' security are a lot
-	 * what constitutes the GUI's
+	 * TODO: this comment is old and the following interface should be cleaned up.
 	 */
 	//--------------------------------------------------------
 	//@{
 
+	/**
+	 * Builds the object hierarchy with references.
+	 */
+	void AddChild(IGUIObject& pChild);
+
+	/**
+	 * Remove an object from the hierarchy.
+	 */
+	void RemoveChild(IGUIObject& pChild);
+
 public:
 
 	/**
@@ -375,7 +392,7 @@
 	 * Notice 'false' is default, because an object not using this function, should not
 	 * have any additional children (and this function should never be called).
 	 */
-	virtual bool HandleAdditionalChildren(const XMBElement& UNUSED(child), CXeromyces* UNUSED(pFile))
+	virtual bool HandleAdditionalChildren(const CStr& name, const CParamNode& data)
 	{
 		return false;
 	}
Index: source/gui/ObjectBases/IGUIObject.cpp
===================================================================
--- source/gui/ObjectBases/IGUIObject.cpp
+++ source/gui/ObjectBases/IGUIObject.cpp
@@ -86,12 +86,40 @@
 	// m_Children is deleted along all other GUI Objects in the CGUI destructor
 }
 
+IGUIObject* IGUIObject::CreateChild(const CParamNode& node)
+{
+	std::vector<std::pair<CStr, CStr>> nameSubst;
+	return m_pGUI.CreateChildFromParamNode(node, this, nameSubst, 0);
+}
+
+bool IGUIObject::DeleteChild(IGUIObject* child)
+{
+	// Don't delete someone else's child.
+	std::vector<IGUIObject*>::iterator it = std::find(m_Children.begin(), m_Children.end(), child);
+	if (it == m_Children.end())
+		return false;
+
+	m_pGUI.DetachAndDeleteChild(child);
+	return true;
+}
+
 void IGUIObject::AddChild(IGUIObject& pChild)
 {
 	pChild.SetParent(this);
 	m_Children.push_back(&pChild);
 }
 
+void IGUIObject::RemoveChild(IGUIObject& pChild)
+{
+	std::vector<IGUIObject*>::iterator it = std::find(m_Children.begin(), m_Children.end(), &pChild);
+	if (it != m_Children.end())
+	{
+		(*it)->m_pParent = nullptr;
+		m_Children.erase(it);
+	}
+}
+
+
 template<typename T>
 void IGUIObject::RegisterSetting(const CStr& Name, T& Value)
 {
Index: source/gui/ObjectTypes/CList.h
===================================================================
--- source/gui/ObjectTypes/CList.h
+++ source/gui/ObjectTypes/CList.h
@@ -94,7 +94,7 @@
 	/**
 	 * Handle the \<item\> tag.
 	 */
-	virtual bool HandleAdditionalChildren(const XMBElement& child, CXeromyces* pFile);
+	virtual bool HandleAdditionalChildren(const CStr& name, const CParamNode& data);
 
 	// Called every time the auto-scrolling should be checked.
 	void UpdateAutoScroll();
Index: source/gui/ObjectTypes/CList.cpp
===================================================================
--- source/gui/ObjectTypes/CList.cpp
+++ source/gui/ObjectTypes/CList.cpp
@@ -26,6 +26,7 @@
 #include "gui/Scripting/JSInterface_GUIProxy.h"
 #include "lib/external_libraries/libsdl.h"
 #include "lib/timer.h"
+#include "simulation2/system/ParamNode.h"
 
 const CStr CList::EventNameSelectionChange = "SelectionChange";
 const CStr CList::EventNameHoverChange = "HoverChange";
@@ -408,14 +409,12 @@
 	SetupText(true);
 }
 
-bool CList::HandleAdditionalChildren(const XMBElement& child, CXeromyces* pFile)
+bool CList::HandleAdditionalChildren(const CStr& name, const CParamNode& data)
 {
-	int elmt_item = pFile->GetElementID("item");
-
-	if (child.GetNodeName() == elmt_item)
+	if (name == "item")
 	{
 		CGUIString vlist;
-		vlist.SetValue(child.GetText().FromUTF8());
+		vlist.SetValue(data.ToString());
 		AddItem(vlist, vlist);
 		return true;
 	}
Index: source/gui/ObjectTypes/COList.h
===================================================================
--- source/gui/ObjectTypes/COList.h
+++ source/gui/ObjectTypes/COList.h
@@ -61,7 +61,7 @@
 	/**
 	 * Handle the \<item\> tag.
 	 */
-	virtual bool HandleAdditionalChildren(const XMBElement& child, CXeromyces* pFile);
+	virtual bool HandleAdditionalChildren(const CStr& name, const CParamNode& data);
 	virtual void AdditionalChildrenHandled();
 
 	void DrawList(const int& selected, const CGUISpriteInstance& sprite, const CGUISpriteInstance& sprite_selected, const CGUIColor& textcolor);
Index: source/gui/ObjectTypes/COList.cpp
===================================================================
--- source/gui/ObjectTypes/COList.cpp
+++ source/gui/ObjectTypes/COList.cpp
@@ -25,6 +25,7 @@
 #include "gui/SettingTypes/CGUIList.h"
 #include "i18n/L10n.h"
 #include "ps/CLogger.h"
+#include "simulation2/system/ParamNode.h"
 
 const float SORT_SPRITE_DIM = 16.0f;
 const CVector2D COLUMN_SHIFT = CVector2D(0, 4);
@@ -180,74 +181,66 @@
 	}
 }
 
-bool COList::HandleAdditionalChildren(const XMBElement& child, CXeromyces* pFile)
+bool COList::HandleAdditionalChildren(const CStr& name, const CParamNode& data)
 {
-	#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
-	#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
-	ELMT(item);
-	ELMT(column);
-	ELMT(translatableAttribute);
-	ATTR(id);
-	ATTR(context);
-
-	if (child.GetNodeName() == elmt_item)
+	if (name == "item")
 	{
 		CGUIString vlist;
-		vlist.SetValue(child.GetText().FromUTF8());
+		vlist.SetValue(data.ToString());
 		AddItem(vlist, vlist);
 		return true;
 	}
-	else if (child.GetNodeName() == elmt_column)
+	else if (name == "column")
 	{
 		COListColumn column;
 
-		for (XMBAttribute attr : child.GetAttributes())
+		for (const auto& child : data.GetChildren())
 		{
-			CStr attr_name(pFile->GetAttributeString(attr.Name));
-			CStr attr_value(attr.Value);
+			if (!child.first.attribute)
+				continue;
 
-			if (attr_name == "color")
+			if (child.first == "@color")
 			{
-				if (!CGUI::ParseString<CGUIColor>(&m_pGUI, attr_value.FromUTF8(), column.m_TextColor))
-					LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name.c_str(), attr_value.c_str());
+				if (!CGUI::ParseString<CGUIColor>(&m_pGUI, child.second.ToString(), column.m_TextColor))
+					LOGERROR("GUI: Error parsing '%s' (\"%s\")", std::string(child.first), child.second.ToUTF8());
 			}
-			else if (attr_name == "id")
+			else if (child.first == "@id")
 			{
-				column.m_Id = attr_value;
+				column.m_Id = child.second.ToUTF8();
 			}
-			else if (attr_name == "hidden")
+			else if (child.first == "@hidden")
 			{
 				bool hidden = false;
-				if (!CGUI::ParseString<bool>(&m_pGUI, attr_value.FromUTF8(), hidden))
-					LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name.c_str(), attr_value.c_str());
+				if (!CGUI::ParseString<bool>(&m_pGUI, child.second.ToString(), hidden))
+					LOGERROR("GUI: Error parsing '%s' (\"%s\")", std::string(child.first), child.second.ToUTF8());
 				else
 					column.m_Hidden = hidden;
 			}
-			else if (attr_name == "width")
+			else if (child.first == "@width")
 			{
 				float width;
-				if (!CGUI::ParseString<float>(&m_pGUI, attr_value.FromUTF8(), width))
-					LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name.c_str(), attr_value.c_str());
+				if (!CGUI::ParseString<float>(&m_pGUI, child.second.ToString(), width))
+					LOGERROR("GUI: Error parsing '%s' (\"%s\")", std::string(child.first), child.second.ToUTF8());
 				else
 				{
 					// Check if it's a relative value, and save as decimal if so.
-					if (attr_value.find("%") != std::string::npos)
+					if (child.second.ToString().find(L"%") != std::string::npos)
 						width = width / 100.f;
 					column.m_Width = width;
 				}
 			}
-			else if (attr_name == "heading")
+			else if (child.first == "@heading")
 			{
-				column.m_Heading = attr_value.FromUTF8();
+				column.m_Heading = child.second.ToString();
 			}
 		}
 
-		for (XMBElement grandchild : child.GetChildNodes())
+		for (const auto& child : data.GetChildren())
 		{
-			if (grandchild.GetNodeName() != elmt_translatableAttribute)
+			if (!(child.first == "translatableAttribute"))
 				continue;
 
-			CStr attributeName(grandchild.GetAttributes().GetNamedItem(attr_id));
+			CStr attributeName(child.second.GetChild("@id").ToUTF8());
 			// only the heading is translatable for list column
 			if (attributeName.empty() || attributeName != "heading")
 			{
@@ -255,11 +248,11 @@
 				continue;
 			}
 
-			CStr value(grandchild.GetText());
+			CStr value(child.second.ToUTF8());
 			if (value.empty())
 				continue;
 
-			CStr context(grandchild.GetAttributes().GetNamedItem(attr_context)); // Read the context if any.
+			CStr context(child.second.GetChild("@context").ToUTF8()); // Read the context if any.
 			if (!context.empty())
 			{
 				CStr translatedValue(g_L10n.TranslateWithContext(context, value));
Index: source/gui/Scripting/JSInterface_IGUIObject.cpp
===================================================================
--- source/gui/Scripting/JSInterface_IGUIObject.cpp
+++ source/gui/Scripting/JSInterface_IGUIObject.cpp
@@ -19,8 +19,59 @@
 
 #include "JSInterface_GUIProxy_impl.h"
 
+#include "simulation2/system/ParamNode.h"
+
 using GUIObjectType = IGUIObject;
 
+bool IGUICreateChild(JSContext* cx, uint argc, JS::Value* vp)
+{
+	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
+	IGUIObject* e = static_cast<IGUIObject*>(js::GetProxyPrivate(args.thisv().toObjectOrNull()).toPrivate());
+	if (!e)
+		return false;
+
+	ScriptInterface& scriptInterface = *ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface;
+	ScriptRequest rq(scriptInterface);
+	CParamNode node;
+	node.ApplyLayer(scriptInterface, args.get(0));
+	IGUIObject* child = e->CreateChild(node);
+	if (!child)
+		return false;
+	ScriptInterface::ToJSVal(rq, args.rval(), child);
+	return true;
+}
+
+bool IGUIDeleteChild(JSContext* cx, uint argc, JS::Value* vp)
+{
+	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
+	IGUIObject* e = static_cast<IGUIObject*>(js::GetProxyPrivate(args.thisv().toObjectOrNull()).toPrivate());
+	if (!e)
+		return false;
+
+	ScriptInterface& scriptInterface = *ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface;
+	ScriptRequest rq(scriptInterface);
+
+	CGUI* gui = static_cast<CGUI*>(ScriptInterface::GetScriptInterfaceAndCBData(cx)->pCBData);
+	CStr name;
+	if (!ScriptInterface::FromJSVal(rq, args.get(0), name))
+	{
+		LOGERROR("DeleteChild: first argument (object name) was not a string.");
+		return false;
+	}
+	IGUIObject* child = gui->FindObjectByName(name);
+	// If the object does not exist, assume we already deleted it/we're good and do nothing.
+	if (!child)
+		return true;
+
+	if (!e->DeleteChild(child))
+	{
+		// Fail in this case - it's likely user error.
+		LOGERROR("Object '%s' exists but is not a child of '%s'", name, e->GetPresentableName());
+		return false;
+	}
+	return true;
+}
+
 template<>
 void JSI_GUIProxy<GUIObjectType>::CreateFunctions(const ScriptRequest& rq, GUIProxyProps* cache)
 {
@@ -30,6 +81,8 @@
 	cache->setFunction(rq, "blur", func(IGUIObject, blur), 0);
 	cache->setFunction(rq, "getComputedSize", func(IGUIObject, getComputedSize), 0);
 #undef func
+	cache->setFunction(rq, "createChild", IGUICreateChild, 1);
+	cache->setFunction(rq, "deleteChild", IGUIDeleteChild, 1);
 }
 
 template class JSI_GUIProxy<GUIObjectType>;
Index: source/simulation2/system/ComponentManager.cpp
===================================================================
--- source/simulation2/system/ComponentManager.cpp
+++ source/simulation2/system/ComponentManager.cpp
@@ -824,19 +824,19 @@
 	for (CParamNode::ChildrenMap::const_iterator it = tmplChilds.begin(); it != tmplChilds.end(); ++it)
 	{
 		// Ignore attributes on the root element
-		if (it->first.length() && it->first[0] == '@')
+		if (it->first.attribute)
 			continue;
 
 		CComponentManager::ComponentTypeId cid = LookupCID(it->first);
 		if (cid == CID__Invalid)
 		{
-			LOGERROR("Unrecognized component type name '%s' in entity template '%s'", it->first, utf8_from_wstring(templateName));
+			LOGERROR("Unrecognized component type name '%s' in entity template '%s'", it->first.name, utf8_from_wstring(templateName));
 			return INVALID_ENTITY;
 		}
 
 		if (!AddComponent(handle, cid, it->second))
 		{
-			LOGERROR("Failed to construct component type name '%s' in entity template '%s'", it->first, utf8_from_wstring(templateName));
+			LOGERROR("Failed to construct component type name '%s' in entity template '%s'", it->first.name, utf8_from_wstring(templateName));
 			return INVALID_ENTITY;
 		}
 		// TODO: maybe we should delete already-constructed components if one of them fails?
Index: source/simulation2/system/ParamNode.h
===================================================================
--- source/simulation2/system/ParamNode.h
+++ source/simulation2/system/ParamNode.h
@@ -150,7 +150,47 @@
 class CParamNode
 {
 public:
-	typedef std::map<std::string, CParamNode> ChildrenMap;
+	struct Node
+	{
+		Node(const char* s, u16 i = 0) : name(s)
+		{
+			attribute = !name.empty() && name[0] == '@';
+			index = i;
+		}
+		Node(const std::string& s, u16 i = 0)
+		{
+			name = s;
+			attribute = !name.empty() && name[0] == '@';
+			index = i;
+		}
+
+		operator std::string() const
+		{
+			if (index == 0)
+				return name;
+			return name + "_" + std::to_string(index);
+		}
+
+		bool operator==(const std::string& o) const { return name == o; }
+		bool operator==(const char* o) const { return name.compare(o) == 0; }
+		bool operator<(const Node& b) const
+		{
+			if (name < b.name)
+				return true;
+			if (name > b.name)
+				return false;
+			if (index < b.index)
+				return true;
+			return false;
+		}
+
+		// Name of the node.
+		// Starts with '@' if the node is an attribute for backwards compatbility reasons.
+		std::string name;
+		u16 index = 0;
+		bool attribute = false;
+	};
+	typedef std::map<Node, CParamNode> ChildrenMap;
 
 	/**
 	 * Constructs a new, empty node.
@@ -263,6 +303,9 @@
 	 */
 	static std::wstring EscapeXMLString(const std::wstring& str);
 
+
+	void ApplyLayer(const ScriptInterface& scriptInterface, JS::HandleValue value);
+
 private:
 
 	/**
Index: source/simulation2/system/ParamNode.cpp
===================================================================
--- source/simulation2/system/ParamNode.cpp
+++ source/simulation2/system/ParamNode.cpp
@@ -28,6 +28,8 @@
 
 #include <sstream>
 
+#include "js/Array.h"
+
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/join.hpp>	// this isn't in string.hpp in old Boosts
 
@@ -169,7 +171,11 @@
 	}
 
 	// Add this element as a child node
-	CParamNode& node = m_Childs[name];
+	int index = 0;
+	for (const auto& child : m_Childs)
+		if (child.first.name == name)
+			index++;
+	CParamNode& node = m_Childs.try_emplace(Node(name, index)).first->second;
 	if (op != INVALID)
 	{
 		// TODO: Support parsing of data types other than fixed; log warnings in other cases
@@ -230,6 +236,56 @@
 	}
 }
 
+void CParamNode::ApplyLayer(const ScriptInterface& scriptInterface, JS::HandleValue value)
+{
+	ResetScriptVal();
+	ScriptRequest rq(scriptInterface);
+
+	std::vector<std::string> props;
+	if (!scriptInterface.EnumeratePropertyNames(value, true, props))
+	{
+		ScriptException::Raise(rq, "Failed to enumerate component properties.");
+		return;
+	}
+	for (const std::string& prop : props)
+	{
+		LOGWARNING("prop %s", prop);
+		JS::RootedValue child(rq.cx);
+		scriptInterface.GetProperty(value, prop.c_str(), &child);
+		switch (JS_TypeOfValue(rq.cx, child))
+		{
+			case JSTYPE_STRING:
+			case JSTYPE_NUMBER:
+			{
+				ScriptInterface::FromJSVal(rq, child, m_Childs[prop].m_Value);
+				break;
+			}
+			case JSTYPE_OBJECT:
+			{
+				bool isArray = false;
+				JS::IsArrayObject(rq.cx, child, &isArray);
+				if (!isArray)
+					m_Childs[prop].ApplyLayer(scriptInterface, child);
+				else
+				{
+					JS::RootedObject obj(rq.cx);
+					JS_ValueToObject(rq.cx, child, &obj);
+					u32 length;
+					JS::GetArrayLength(rq.cx, obj, &length);
+					for (size_t i = 0; i < length; ++i)
+					{
+						JS::RootedValue arrayChild(rq.cx);
+						scriptInterface.GetPropertyInt(child, i, &arrayChild);
+						m_Childs.try_emplace(Node(prop, i)).first->second.ApplyLayer(scriptInterface, arrayChild);
+					}
+				}
+				break;
+			}
+		}
+	}
+}
+
+
 const CParamNode& CParamNode::GetChild(const char* name) const
 {
 	ChildrenMap::const_iterator it = m_Childs.find(name);
@@ -335,10 +391,10 @@
 	for (; it != m_Childs.end(); ++it)
 	{
 		// Skip attributes here (they were handled when the caller output the tag)
-		if (it->first.length() && it->first[0] == '@')
+		if (it->first.attribute)
 			continue;
 
-		std::wstring name (it->first.begin(), it->first.end());
+		std::wstring name (it->first.name.begin(), it->first.name.end());
 
 		strm << L"<" << name;
 
@@ -346,9 +402,9 @@
 		ChildrenMap::const_iterator cit = it->second.m_Childs.begin();
 		for (; cit != it->second.m_Childs.end(); ++cit)
 		{
-			if (cit->first.length() && cit->first[0] == '@')
+			if (cit->first.attribute)
 			{
-				std::wstring attrname (cit->first.begin()+1, cit->first.end());
+				std::wstring attrname (cit->first.name.begin()+1, cit->first.name.end());
 				strm << L" " << attrname << L"=\"" << EscapeXMLString(cit->second.m_Value) << L"\"";
 			}
 		}
@@ -409,10 +465,10 @@
 	}
 
 	JS::RootedValue childVal(rq.cx);
-	for (std::map<std::string, CParamNode>::const_iterator it = m_Childs.begin(); it != m_Childs.end(); ++it)
+	for (ChildrenMap::const_iterator it = m_Childs.begin(); it != m_Childs.end(); ++it)
 	{
 		it->second.ConstructJSVal(rq, &childVal);
-		if (!JS_SetProperty(rq.cx, obj, it->first.c_str(), childVal))
+		if (!JS_SetProperty(rq.cx, obj, std::string(it->first).c_str(), childVal))
 		{
 			ret.setUndefined();
 			return; // TODO: report error