diff --git a/wgui/src/parser.rs b/wgui/src/parser.rs
index 4a355f6..a8cec85 100644
--- a/wgui/src/parser.rs
+++ b/wgui/src/parser.rs
@@ -48,16 +48,14 @@ struct ParserFile<'a> {
 	path: PathBuf,
 	document: Rc<XmlDocument>,
 	ctx: Rc<RefCell<ParserContext<'a>>>,
-	current_template: Rc<Template>,
 	template_parameters: HashMap<Rc<str>, Rc<str>>,
 }
 
-#[derive(Default)]
-pub struct ParserState {
-	pub ids: HashMap<Rc<str>, WidgetID>,
+pub struct ParserResult {
+	ids: HashMap<Rc<str>, WidgetID>,
 }
 
-impl ParserState {
+impl ParserResult {
 	pub fn require_by_id(&self, id: &str) -> anyhow::Result<WidgetID> {
 		match self.ids.get(id) {
 			Some(id) => Ok(*id),
@@ -70,7 +68,7 @@ struct ParserContext<'a> {
 	layout: &'a mut Layout,
 	var_map: VarMap,
 	templates: HashMap<Rc<str>, Rc<Template>>,
-	state: &'a mut ParserState,
+	ids: HashMap<Rc<str>, WidgetID>,
 }
 
 // Parses a color from a HTML hex string
@@ -562,6 +560,39 @@ fn parse_widget_sprite<'a>(
 	Ok(())
 }
 
+fn parse_widget_other<'a>(
+	xml_tag_name: &str,
+	file: &'a ParserFile,
+	ctx: &mut ParserContext,
+	node: roxmltree::Node<'a, 'a>,
+	parent_id: WidgetID,
+) -> anyhow::Result<()> {
+	let Some(template) = ctx.templates.get(xml_tag_name) else {
+		log::error!("Undefined tag named \"{}\"", xml_tag_name);
+		return Ok(()); // not critical
+	};
+
+	let template_parameters: HashMap<Rc<str>, Rc<str>> = iter_attribs(file, ctx, &node).collect();
+
+	let template_file = ParserFile {
+		ctx: file.ctx.clone(),
+		document: template.node_document.clone(),
+		path: file.path.clone(),
+		template_parameters,
+	};
+
+	let doc = template_file.document.clone();
+
+	let template_node = doc
+		.borrow_doc()
+		.get_node(template.node)
+		.ok_or(anyhow::anyhow!("template node invalid"))?;
+
+	parse_children(&template_file, ctx, template_node, parent_id)?;
+
+	Ok(())
+}
+
 fn parse_widget_label<'a>(
 	file: &'a ParserFile,
 	ctx: &mut ParserContext,
@@ -800,7 +831,7 @@ fn parse_universal<'a>(
 		match key.as_ref() {
 			"id" => {
 				// Attach a specific widget to name-ID map (just like getElementById)
-				if ctx.state.ids.insert(value.clone(), widget_id).is_some() {
+				if ctx.ids.insert(value.clone(), widget_id).is_some() {
 					log::warn!("duplicate ID \"{}\" in the same layout file!", value);
 				}
 			}
@@ -835,30 +866,7 @@ fn parse_children<'a>(
 			}
 			"" => { /* ignore */ }
 			other_tag_name => {
-				let Some(template) = ctx.templates.get(other_tag_name) else {
-					log::error!("Undefined tag named \"{}\"", other_tag_name);
-					continue;
-				};
-
-				let template_parameters: HashMap<Rc<str>, Rc<str>> =
-					iter_attribs(file, ctx, &child_node).collect();
-
-				let template_file = ParserFile {
-					ctx: file.ctx.clone(),
-					document: template.node_document.clone(),
-					path: file.path.clone(),
-					template_parameters,
-					current_template: template.clone(),
-				};
-
-				let doc = template_file.document.clone();
-
-				let template_node = doc
-					.borrow_doc()
-					.get_node(template.node)
-					.ok_or(anyhow::anyhow!("template node invalid"))?;
-
-				parse_children(&template_file, ctx, template_node, parent_id)?;
+				parse_widget_other(other_tag_name, file, ctx, child_node, parent_id)?;
 			}
 		}
 	}
@@ -869,13 +877,12 @@ pub fn parse_from_assets(
 	layout: &mut Layout,
 	parent_id: WidgetID,
 	path: &str,
-) -> anyhow::Result<ParserState> {
+) -> anyhow::Result<ParserResult> {
 	let path = PathBuf::from(path);
-	let mut result = ParserState::default();
 
 	let ctx_rc = Rc::new(RefCell::new(ParserContext {
 		layout,
-		state: &mut result,
+		ids: Default::default(),
 		var_map: Default::default(),
 		templates: Default::default(),
 	}));
@@ -884,11 +891,27 @@ pub fn parse_from_assets(
 
 	let (file, node_layout) = get_doc_from_path(ctx_rc.clone(), &mut ctx, &path)?;
 	parse_document_root(file, &mut ctx, parent_id, node_layout)?;
+
+	// move everything essential to the result
+	let result = ParserResult {
+		ids: std::mem::take(&mut ctx.ids),
+	};
+
 	drop(ctx);
 
 	Ok(result)
 }
 
+pub fn new_layout_from_assets(
+	assets: Box<dyn AssetProvider>,
+	path: &str,
+) -> anyhow::Result<(Layout, ParserResult)> {
+	let mut layout = Layout::new(assets)?;
+	let widget = layout.root_widget;
+	let state = parse_from_assets(&mut layout, widget, path)?;
+	Ok((layout, state))
+}
+
 fn assets_path_to_xml(assets: &mut Box<dyn AssetProvider>, path: &Path) -> anyhow::Result<String> {
 	let data = assets.load_from_path(&path.to_string_lossy())?;
 	Ok(String::from_utf8(data)?)
@@ -911,17 +934,11 @@ fn get_doc_from_path<'a>(
 	let root = document.borrow_doc().root();
 	let tag_layout = require_tag_by_name(&root, "layout")?;
 
-	let template = Template {
-		node: root.id(),
-		node_document: document.clone(),
-	};
-
 	let file = ParserFile {
 		ctx: ctx_rc.clone(),
 		path: PathBuf::from(path),
 		document: document.clone(),
-		current_template: Rc::new(template),
-		template_parameters: Default::default(), // todo
+		template_parameters: Default::default(),
 	};
 
 	Ok((file, tag_layout.id()))
diff --git a/wgui/uidev-vk/src/testbed/testbed_any.rs b/wgui/uidev-vk/src/testbed/testbed_any.rs
index 7faa135..06cc77e 100644
--- a/wgui/uidev-vk/src/testbed/testbed_any.rs
+++ b/wgui/uidev-vk/src/testbed/testbed_any.rs
@@ -9,12 +9,7 @@ pub struct TestbedAny {
 impl TestbedAny {
 	pub fn new(name: &str) -> anyhow::Result<Self> {
 		let path = format!("gui/{name}.xml");
-		let mut layout = Layout::new(Box::new(assets::Asset {}))?;
-
-		let parent = layout.root_widget;
-
-		let _res = wgui::parser::parse_from_assets(&mut layout, parent, &path)?;
-
+		let (layout, _state) = wgui::parser::new_layout_from_assets(Box::new(assets::Asset {}), &path)?;
 		Ok(Self { layout })
 	}
 }
diff --git a/wgui/uidev-vk/src/testbed/testbed_dashboard.rs b/wgui/uidev-vk/src/testbed/testbed_dashboard.rs
index 98cd027..207f4e5 100644
--- a/wgui/uidev-vk/src/testbed/testbed_dashboard.rs
+++ b/wgui/uidev-vk/src/testbed/testbed_dashboard.rs
@@ -9,13 +9,8 @@ pub struct TestbedDashboard {
 impl TestbedDashboard {
 	pub fn new() -> anyhow::Result<Self> {
 		const XML_PATH: &str = "gui/dashboard.xml";
-
-		let mut layout = Layout::new(Box::new(assets::Asset {}))?;
-
-		let parent = layout.root_widget;
-
-		let _res = wgui::parser::parse_from_assets(&mut layout, parent, XML_PATH)?;
-
+		let (layout, _state) =
+			wgui::parser::new_layout_from_assets(Box::new(assets::Asset {}), XML_PATH)?;
 		Ok(Self { layout })
 	}
 }
diff --git a/wgui/uidev-vk/src/testbed/testbed_generic.rs b/wgui/uidev-vk/src/testbed/testbed_generic.rs
index da96975..cbf5ed2 100644
--- a/wgui/uidev-vk/src/testbed/testbed_generic.rs
+++ b/wgui/uidev-vk/src/testbed/testbed_generic.rs
@@ -20,13 +20,8 @@ impl TestbedGeneric {
 	pub fn new() -> anyhow::Result<Self> {
 		const XML_PATH: &str = "gui/testbed.xml";
 
-		let mut layout = Layout::new(Box::new(assets::Asset {}))?;
-
-		layout.assets.load_from_path(XML_PATH)?;
-
-		let parent = layout.root_widget;
-
-		let res = wgui::parser::parse_from_assets(&mut layout, parent, XML_PATH)?;
+		let (mut layout, res) =
+			wgui::parser::new_layout_from_assets(Box::new(assets::Asset {}), XML_PATH)?;
 
 		use wgui::components::button;
 		let my_div_parent = res.require_by_id("my_div_parent")?;
diff --git a/wlx-overlay-s/src/assets/key.xml b/wlx-overlay-s/src/assets/key.xml
new file mode 100644
index 0000000..6dabf3c
--- /dev/null
+++ b/wlx-overlay-s/src/assets/key.xml
@@ -0,0 +1,7 @@
+<layout>
+  <template name="Key">
+    <rectangle color="#FF0000" width="32" height="32" margin="4">
+
+    </rectangle>
+  </template>
+</layout>
\ No newline at end of file
diff --git a/wlx-overlay-s/src/gui/mod.rs b/wlx-overlay-s/src/gui/mod.rs
index 8ccb048..153e2c4 100644
--- a/wlx-overlay-s/src/gui/mod.rs
+++ b/wlx-overlay-s/src/gui/mod.rs
@@ -1,3 +1,3 @@
-mod asset;
+pub mod asset;
 pub mod panel;
 mod timestep;
diff --git a/wlx-overlay-s/src/overlays/keyboard.rs b/wlx-overlay-s/src/overlays/keyboard.rs
index e8fcb1d..a790ab4 100644
--- a/wlx-overlay-s/src/overlays/keyboard.rs
+++ b/wlx-overlay-s/src/overlays/keyboard.rs
@@ -15,7 +15,7 @@ use crate::{
     },
     config::{self, ConfigType},
     graphics::CommandBuffers,
-    gui::panel::GuiPanel,
+    gui::{self, panel::GuiPanel},
     hid::{
         ALT, CTRL, KEYS_TO_MODS, KeyModifier, KeyType, META, NUM_LOCK, SHIFT, SUPER, VirtualKey,
         XkbKeymap, get_key_type,
@@ -125,6 +125,9 @@ where
         keymap = None;
     }
 
+    let (key_layout, _state) =
+        wgui::parser::new_layout_from_assets(Box::new(gui::asset::GuiAsset {}), "key.xml")?;
+
     for row in 0..LAYOUT.key_sizes.len() {
         let (div, _) = panel.layout.add_child(
             background,
@@ -142,113 +145,115 @@ where
                 height: length(PIXELS_PER_UNIT),
             };
 
-            if let Some(key) = LAYOUT.main_layout[row][col].as_ref() {
-                let mut label = Vec::with_capacity(2);
-                let mut maybe_state: Option<KeyButtonData> = None;
-                let mut cap_type = KeyCapType::Regular;
+            let Some(key) = LAYOUT.main_layout[row][col].as_ref() else {
+                continue;
+            };
 
-                if let Ok(vk) = VirtualKey::from_str(key) {
-                    if let Some(keymap) = keymap.as_ref() {
-                        match get_key_type(vk) {
-                            KeyType::Symbol => {
-                                let label0 = keymap.label_for_key(vk, 0);
-                                let label1 = keymap.label_for_key(vk, SHIFT);
+            let mut label = Vec::with_capacity(2);
+            let mut maybe_state: Option<KeyButtonData> = None;
+            let mut cap_type = KeyCapType::Regular;
 
-                                if label0.chars().next().is_some_and(char::is_alphabetic) {
-                                    label.push(label1);
-                                    if has_altgr {
-                                        cap_type = KeyCapType::RegularAltGr;
-                                        label.push(keymap.label_for_key(vk, META));
-                                    } else {
-                                        cap_type = KeyCapType::Regular;
-                                    }
+            if let Ok(vk) = VirtualKey::from_str(key) {
+                if let Some(keymap) = keymap.as_ref() {
+                    match get_key_type(vk) {
+                        KeyType::Symbol => {
+                            let label0 = keymap.label_for_key(vk, 0);
+                            let label1 = keymap.label_for_key(vk, SHIFT);
+
+                            if label0.chars().next().is_some_and(char::is_alphabetic) {
+                                label.push(label1);
+                                if has_altgr {
+                                    cap_type = KeyCapType::RegularAltGr;
+                                    label.push(keymap.label_for_key(vk, META));
                                 } else {
-                                    label.push(label0);
-                                    label.push(label1);
-                                    if has_altgr {
-                                        label.push(keymap.label_for_key(vk, META));
-                                        cap_type = KeyCapType::ReversedAltGr;
-                                    } else {
-                                        cap_type = KeyCapType::Reversed;
-                                    }
+                                    cap_type = KeyCapType::Regular;
+                                }
+                            } else {
+                                label.push(label0);
+                                label.push(label1);
+                                if has_altgr {
+                                    label.push(keymap.label_for_key(vk, META));
+                                    cap_type = KeyCapType::ReversedAltGr;
+                                } else {
+                                    cap_type = KeyCapType::Reversed;
                                 }
                             }
-                            KeyType::NumPad => {
-                                label.push(keymap.label_for_key(vk, NUM_LOCK));
-                            }
-                            KeyType::Other => {}
                         }
+                        KeyType::NumPad => {
+                            label.push(keymap.label_for_key(vk, NUM_LOCK));
+                        }
+                        KeyType::Other => {}
                     }
+                }
 
-                    if let Some(mods) = KEYS_TO_MODS.get(vk) {
-                        maybe_state = Some(KeyButtonData::Modifier {
-                            modifier: *mods,
-                            sticky: false,
-                        });
-                    } else {
-                        maybe_state = Some(KeyButtonData::Key { vk, pressed: false });
-                    }
-                } else if let Some(macro_verbs) = LAYOUT.macros.get(key) {
-                    maybe_state = Some(KeyButtonData::Macro {
-                        verbs: key_events_for_macro(macro_verbs),
+                if let Some(mods) = KEYS_TO_MODS.get(vk) {
+                    maybe_state = Some(KeyButtonData::Modifier {
+                        modifier: *mods,
+                        sticky: false,
                     });
-                } else if let Some(exec_args) = LAYOUT.exec_commands.get(key) {
-                    if exec_args.is_empty() {
-                        log::error!("Keyboard: EXEC args empty for {key}");
-                    } else {
-                        let mut iter = exec_args.iter().cloned();
-                        if let Some(program) = iter.next() {
-                            maybe_state = Some(KeyButtonData::Exec {
-                                program,
-                                args: iter.by_ref().take_while(|arg| arg[..] != *"null").collect(),
-                                release_program: iter.next(),
-                                release_args: iter.collect(),
-                            });
-                        }
-                    }
                 } else {
-                    log::error!("Unknown key: {key}");
+                    maybe_state = Some(KeyButtonData::Key { vk, pressed: false });
                 }
+            } else if let Some(macro_verbs) = LAYOUT.macros.get(key) {
+                maybe_state = Some(KeyButtonData::Macro {
+                    verbs: key_events_for_macro(macro_verbs),
+                });
+            } else if let Some(exec_args) = LAYOUT.exec_commands.get(key) {
+                if exec_args.is_empty() {
+                    log::error!("Keyboard: EXEC args empty for {key}");
+                } else {
+                    let mut iter = exec_args.iter().cloned();
+                    if let Some(program) = iter.next() {
+                        maybe_state = Some(KeyButtonData::Exec {
+                            program,
+                            args: iter.by_ref().take_while(|arg| arg[..] != *"null").collect(),
+                            release_program: iter.next(),
+                            release_args: iter.collect(),
+                        });
+                    }
+                }
+            } else {
+                log::error!("Unknown key: {key}");
+            }
 
-                if let Some(state) = maybe_state {
-                    if label.is_empty() {
-                        label = LAYOUT.label_for_key(key);
-                    }
-                    let _ = panel.layout.add_child(
-                        div,
-                        Rectangle::create(RectangleParams {
-                            border_color: parse_color_hex("#dddddd").unwrap(),
-                            border: 2.0,
-                            round: WLength::Units(4.0),
-                            ..Default::default()
-                        })
-                        .unwrap(),
-                        taffy::Style {
-                            size: my_size,
-                            min_size: my_size,
-                            max_size: my_size,
-                            ..Default::default()
-                        },
-                    )?;
-                } else {
-                    let _ = panel.layout.add_child(
-                        div,
-                        Rectangle::create(RectangleParams {
-                            border_color: wgui::drawing::Color::new(0., 0., 0., 0.),
-                            color: wgui::drawing::Color::new(0., 0., 0., 0.),
-                            border: 2.0,
-                            round: WLength::Units(4.0),
-                            ..Default::default()
-                        })
-                        .unwrap(),
-                        taffy::Style {
-                            size: my_size,
-                            min_size: my_size,
-                            max_size: my_size,
-                            ..Default::default()
-                        },
-                    )?;
+            if let Some(state) = maybe_state {
+                if label.is_empty() {
+                    label = LAYOUT.label_for_key(key);
                 }
+                let _ = panel.layout.add_child(
+                    div,
+                    Rectangle::create(RectangleParams {
+                        border_color: parse_color_hex("#dddddd").unwrap(),
+                        border: 2.0,
+                        round: WLength::Units(4.0),
+                        ..Default::default()
+                    })
+                    .unwrap(),
+                    taffy::Style {
+                        size: my_size,
+                        min_size: my_size,
+                        max_size: my_size,
+                        ..Default::default()
+                    },
+                )?;
+            } else {
+                let _ = panel.layout.add_child(
+                    div,
+                    Rectangle::create(RectangleParams {
+                        border_color: wgui::drawing::Color::new(0., 0., 0., 0.),
+                        color: wgui::drawing::Color::new(0., 0., 0., 0.),
+                        border: 2.0,
+                        round: WLength::Units(4.0),
+                        ..Default::default()
+                    })
+                    .unwrap(),
+                    taffy::Style {
+                        size: my_size,
+                        min_size: my_size,
+                        max_size: my_size,
+                        ..Default::default()
+                    },
+                )?;
             }
         }
     }