diff --git a/dependencies/PhyMacParser b/dependencies/PhyMacParser
index 75e06d0e..e292ffd6 160000
--- a/dependencies/PhyMacParser
+++ b/dependencies/PhyMacParser
@@ -1 +1 @@
-Subproject commit 75e06d0e4baee22408a2293a5f3fe608f1dbe54b
+Subproject commit e292ffd6bdf9b80ef56ad25c537a1b780c348c51
diff --git a/sutk/include/sutk/ThemeManager.hpp b/sutk/include/sutk/ThemeManager.hpp
index 9fc6cace..312f61b9 100644
--- a/sutk/include/sutk/ThemeManager.hpp
+++ b/sutk/include/sutk/ThemeManager.hpp
@@ -8,6 +8,7 @@
 
 #include <string_view> // for std::string_view
 #include <type_traits> // for std::is_same_v
+#include <optional> // for std::optional<>
 
 typedef struct v3d_generic_node_t v3d_generic_node_t;
 
@@ -44,14 +45,19 @@ namespace SUTK
 		template<typename ValueType>
 		void define(const KeyViewType& key) noexcept;
 		void undefine(const KeyViewType& key) noexcept;
-		Type getType(const KeyViewType& key) noexcept;
+		std::optional<Type> getKeyType(const KeyViewType& key) noexcept;
 		template<typename ValueType>
-		EventHandlerID bind(const KeyViewType& key, ValueChangeCallback<ValueType> callback) noexcept;
-		void unbind(const KeyViewType& key, EventHandlerID id) noexcept;
+		BindID bind(const KeyViewType& key, ValueChangeCallback<ValueType> callback) noexcept;
+		void unbind(const KeyViewType& key, BindID id) noexcept;
 		template<typename ValueType>
 		const ValueType& getValue(Type type, const KeyViewType& key) noexcept;
 		void applyTheme(Theme<KeyType, KeyViewType>* theme) noexcept;
 		Theme<KeyType, KeyViewType>* getCurrentTheme() noexcept { return m_currentTheme; }
+		com::Bool verifyKey(const KeyViewType& key, Type type) noexcept
+		{
+			auto value = try_find_value(m_defs, key);
+			return com::Bool { value && (value->first == type) };
+		}
 
 		// Published after publishing events for every key
 		OnThemeChangeEvent& getOnThemeChangeEvent() noexcept { return m_onThemeChange; }
@@ -64,60 +70,83 @@ namespace SUTK
 	{
 	public:
 		using ThemeInterfaceType = ThemeInterface<KeyType, KeyViewType>;
+		using ThemeInterfaceList = std::vector<ThemeInterfaceType*>;
 	private:
 		com::unordered_map<KeyType, Color4, KeyViewType> m_colors;
 		com::unordered_map<KeyType, UIDriver::ImageReference, KeyViewType> m_images;
 		com::unordered_map<KeyType, UIDriver::FontReference, KeyViewType> m_fonts;
 		com::unordered_map<KeyType, f32> m_floats;
 		com::unordered_map<KeyType, std::string> m_strings;
-		ThemeInterfaceType* m_interface;
+		ThemeInterfaceList m_interfaces;
 	public:
-		Theme(UIDriver& driver, ThemeInterfaceType* interface) noexcept : UIDriverObject(driver), m_interface(interface) { }
+		Theme(UIDriver& driver, std::initializer_list<ThemeInterfaceType*> interfaces) noexcept : UIDriverObject(driver), m_interfaces(interfaces) { }
+		Theme(UIDriver& driver, std::vector<ThemeInterfaceType*> interfaces) noexcept : UIDriverObject(driver), m_interfaces(interfaces) { }
+		Theme(UIDriver& driver, ThemeInterfaceType* interface) noexcept : Theme(driver, { interface }) { }
+
+		ThemeInterfaceList& getInterfaces() noexcept { return m_interfaces; }
+
+		void apply() noexcept
+		{
+			for(auto& interface : m_interfaces)
+				interface->applyTheme(this);
+		}
 
-		ThemeInterfaceType* getInterface() noexcept { return m_interface; }
+		com::Bool verifyKey(const KeyViewType& key, ThemeInterfaceType::Type type) noexcept
+		{
+			for(auto& interface : m_interfaces)
+				if(interface->verifyKey(key, type))
+					return com::True;
+			DEBUG_LOG_ERROR("Either the key doesn't exist or type mismatch has been occurred");
+			return com::False;
+		}
+
+		std::optional<typename ThemeInterfaceType::Type> getKeyType(const KeyViewType& key) noexcept
+		{
+			for(auto& interface : m_interfaces)
+				if(auto value = interface->getKeyType(key))
+					return value;
+			return { };
+		}
 
 		template<typename ValueType>
-		void add(const KeyViewType& key, ValueType&& value) noexcept
+		constexpr ThemeInterfaceType::Type getTypeEnum() noexcept
 		{
 			if constexpr(std::is_same_v<ValueType, Color4>)
+				return ThemeInterfaceType::Type::Color;
+			else if constexpr(std::is_same_v<ValueType, UIDriver::ImageReference>)
+				return ThemeInterfaceType::Type::Image;
+			else if constexpr(std::is_same_v<ValueType, UIDriver::FontReference>)
+				return ThemeInterfaceType::Type::Font;
+			else if constexpr(std::is_same_v<ValueType, f32>)
+				return ThemeInterfaceType::Type::Float;
+			else if constexpr(std::is_same_v<ValueType, std::string>)
+				return ThemeInterfaceType::Type::String;
+			else
+				static_assert(false, "Type not supported");
+		}
+
+		template<typename ValueType>
+		void add(const KeyViewType& key, ValueType&& value) noexcept
+		{
+			if(!verifyKey(key, getTypeEnum<ValueType>()))
 			{
-				if(m_interface->getType(key) != ThemeInterfaceType::Type::Color)
-					DEBUG_LOG_ERROR("Type mismatch");
-				else
-					m_colors.insert({ KeyType { key }, std::forward<Color4&&>(value) });
+				DEBUG_LOG_ERROR("Failed to add value into the theme");
+				return;
 			}
+			if constexpr(std::is_same_v<ValueType, Color4>)
+					m_colors.insert({ KeyType { key }, std::forward<Color4&&>(value) });
 			else if constexpr(std::is_same_v<ValueType, UIDriver::ImageReference>)
-			{
-				if(m_interface->getType(key) != ThemeInterfaceType::Type::Image)
-					DEBUG_LOG_ERROR("Type mismatch");
-				else
 					m_images.insert({ KeyType { key }, std::forward<UIDriver::ImageReference&&>(value) });
-			}
 			else if constexpr(std::is_same_v<ValueType, UIDriver::FontReference>)
-			{
-				if(m_interface->getType(key) != ThemeInterfaceType::Type::Font)
-					DEBUG_LOG_ERROR("Type mismatch");
-				else
 					m_fonts.insert({ KeyType { key }, std::forward<UIDriver::FontReference&&>(value) });
-			}
 			else if constexpr(std::is_same_v<ValueType, f32>)
-			{
-				if(m_interface->getType(key) != ThemeInterfaceType::Type::Float)
-					DEBUG_LOG_ERROR("Type mismatch");
-				else
 					m_floats.insert({ KeyType { key }, std::forward<f32&&>(value) });
-			}
 			else if constexpr(std::is_same_v<ValueType, std::string>)
-			{
-				if(m_interface->getType(key) != ThemeInterfaceType::Type::String)
-					DEBUG_LOG_ERROR("Type mismatch");
-				else
 					m_strings.insert({ KeyType { key }, std::forward<std::string&&>(value) });
-			}
 			else
 				static_assert(false, "Type not supported");
 		}
-		template<typename ValueType> requires(std::same_as<ValueType, std::string>)
+		template<typename ValueType> requires(com::SameAsAny<ValueType, UIDriver::ImageReference, UIDriver::FontReference>)
 		void add(const KeyViewType& key, std::string_view view) noexcept
 		{
 			if(view.ends_with(".png") || view.ends_with(".jpg") || view.ends_with(".bmp"))
@@ -195,30 +224,41 @@ namespace SUTK
 	}
 
 	template<typename KeyType, com::ViewType<KeyType> KeyViewType>
-	ThemeInterface<KeyType, KeyViewType>::Type ThemeInterface<KeyType, KeyViewType>::getType(const KeyViewType& key) noexcept
+	std::optional<typename ThemeInterface<KeyType, KeyViewType>::Type> ThemeInterface<KeyType, KeyViewType>::getKeyType(const KeyViewType& key) noexcept
 	{
-		return com::find_value(m_defs, key).first;
+		auto value = com::try_find_value(m_defs, key);
+		if(value)
+			return { value->first };
+		return { };
 	}
 
 	template<typename KeyType, com::ViewType<KeyType> KeyViewType>
 	template<typename ValueType>
-	ThemeInterface<KeyType, KeyViewType>::EventHandlerID ThemeInterface<KeyType, KeyViewType>::bind(const KeyViewType& key, ValueChangeCallback<ValueType> callback) noexcept
+	ThemeInterface<KeyType, KeyViewType>::BindID ThemeInterface<KeyType, KeyViewType>::bind(const KeyViewType& key, ValueChangeCallback<ValueType> callback) noexcept
 	{
-		auto& value = com::find_value(m_defs, key);
-		auto fn = [_callback = std::move(callback), key, this]()
+		auto value = com::try_find_value(m_defs, key);
+		if(value)
 		{
-			_callback(this->m_currentTheme->template getValue<ValueType>(key));
-		};
-		if(m_currentTheme)
-			fn();
-		return value.second.subscribe(std::move(fn));
+			auto fn = [_callback = std::move(callback), key, this]()
+			{
+				_callback(this->m_currentTheme->template getValue<ValueType>(key));
+			};
+			if(m_currentTheme)
+				fn();
+			return value->second.subscribe(std::move(fn));
+		}
+		else DEBUG_LOG_ERROR("Failed to bind, no such key exists");
+		return ThemeInterface<KeyType, KeyViewType>::InvalidBindID;
 	}
 
 	template<typename KeyType, com::ViewType<KeyType> KeyViewType>
-	void ThemeInterface<KeyType, KeyViewType>::unbind(const KeyViewType& key, EventHandlerID id) noexcept
+	void ThemeInterface<KeyType, KeyViewType>::unbind(const KeyViewType& key, BindID id) noexcept
 	{
-		auto& value = com::find_value(m_defs, key);
-		value.second.unsubscribe(id);
+		auto value = com::try_find_value(m_defs, key);
+		if(value)
+			value->second.unsubscribe(id);
+		else
+			DEBUG_LOG_ERROR("Failed to unbind, no such key exists");
 	}
 
 	template<typename KeyType, com::ViewType<KeyType> KeyViewType>
@@ -328,9 +368,14 @@ namespace SUTK
 		}
 
 		ThemeType* createTheme(const KeyViewType& key, ThemeInterfaceType* interface) noexcept
+		{
+			return createTheme(key, std::initializer_list { interface });
+		}
+		template<typename InitVectorType> requires(com::SameAsAny<InitVectorType, std::initializer_list<ThemeInterfaceType*>, std::vector<ThemeInterfaceType*>>)
+		ThemeType* createTheme(const KeyViewType& key, InitVectorType& interfaces) noexcept
 		{
 			_com_assert(!m_themes.contains(key));
-			ThemeType* theme = new ThemeType(getUIDriver(), interface);
+			ThemeType* theme = new ThemeType(getUIDriver(), std::forward<InitVectorType&&>(interfaces));
 			m_themes.insert({ KeyType { key }, theme });
 			return theme;
 		}
diff --git a/sutk/include/sutk/tests/MultipleThemeModelTest.hpp b/sutk/include/sutk/tests/MultipleThemeModelTest.hpp
new file mode 100644
index 00000000..ca2c97fa
--- /dev/null
+++ b/sutk/include/sutk/tests/MultipleThemeModelTest.hpp
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <sutk/ITest.hpp>
+
+#include <sge-cpp/sge.hpp>
+
+#include <sutk/UIDriver.hpp>
+
+namespace SUTK
+{
+	class IGfxDriver;
+
+	class MultipleThemeModelTest : public ITest
+	{
+	private:
+		UIDriver* m_uiDriver;
+		IGfxDriver* m_gfxDriver;
+		IInputDriver* m_inputDriver;
+		RenderImage* m_renderRect;
+		RenderableContainer* m_renderRectContainer;
+
+	public:
+		MultipleThemeModelTest() : m_uiDriver(NULL), m_gfxDriver(NULL), m_inputDriver(NULL) { }
+
+		TestInitializationData getInitializationData() override;
+
+		void initialize(SGE::Driver& driver) override;
+
+		void terminate(SGE::Driver& driver) override;
+
+		void render(SGE::Driver& driver) override;
+
+		void update(SGE::Driver& driver, float deltaTime) override;
+	};
+}
diff --git a/sutk/source/ITest.cpp b/sutk/source/ITest.cpp
index 32651dbe..ab45a4c6 100644
--- a/sutk/source/ITest.cpp
+++ b/sutk/source/ITest.cpp
@@ -25,6 +25,7 @@
 #include <sutk/tests/ContainerTest.hpp>
 #include <sutk/tests/FontTest.hpp>
 #include <sutk/tests/NotebookTest.hpp>
+#include <sutk/tests/MultipleThemeModelTest.hpp>
 
 namespace SUTK
 {
@@ -53,7 +54,8 @@ namespace SUTK
 		{ "CONTAINER", [] () { return std::unique_ptr<ITest>(new ContainerTest()); }},
 		{ "FONT", [] () { return std::unique_ptr<ITest>(new FontTest()); }},
 		{ "NOTEBOOK", [] () { return std::unique_ptr<ITest>(new NotebookTest()); }},
-		{ "LUNASVG", [] () { return std::unique_ptr<ITest>(new LunaSVGTest()); }}
+		{ "LUNASVG", [] () { return std::unique_ptr<ITest>(new LunaSVGTest()); }},
+		{ "MULTIPLE_THEME_MODEL", [] () { return std::unique_ptr<ITest>(new MultipleThemeModelTest()); }}
 	};
 
 	std::unique_ptr<ITest> ITest::Create(const std::string& testName)
diff --git a/sutk/source/ThemeManager.cpp b/sutk/source/ThemeManager.cpp
index eefecbce..87ac1885 100644
--- a/sutk/source/ThemeManager.cpp
+++ b/sutk/source/ThemeManager.cpp
@@ -336,7 +336,7 @@ namespace SUTK
 		ppsr_v3d_generic_parse_result_t result = ppsr_v3d_generic_parse(NULL, str, buf_get_element_count(text) - 1);
 		ThemeType* theme = NULL;
 		std::string_view strView { };
-		v3d_generic_node_t* themeModelNode = NULL;
+		v3d_generic_node_t* themeNode = NULL;
 		if(result.result != PPSR_SUCCESS)
 		{
 			DEBUG_LOG_ERROR("Unable to parse the file at %.*s", filePath.length(), filePath.data());
@@ -348,15 +348,15 @@ namespace SUTK
 			goto HANDLE_FAILURE;
 		}
 
-		themeModelNode = result.root->childs[0];
-		if(themeModelNode->qualifier_count == 0)
+		themeNode = result.root->childs[0];
+		if(themeNode->qualifier_count == 0)
 		{
-			DEBUG_LOG_ERROR("Anonymous root block is not allowed, it must be named \"ThemeModel\"");
+			DEBUG_LOG_ERROR("Anonymous root block is not allowed, it must be named \"Theme\"");
 			goto HANDLE_FAILURE;
 		}
 
 		{
-			u32_pair_t name = themeModelNode->qualifiers[0];
+			u32_pair_t name = themeNode->qualifiers[0];
 			if(com_safe_strncmp(name.start + str, "Theme", U32_PAIR_DIFF(name)))
 			{
 				DEBUG_LOG_ERROR("Expected \"Theme\" but given \"%*.s\"", U32_PAIR_DIFF(name), name.start + str);
@@ -365,41 +365,48 @@ namespace SUTK
 		}
 
 		{
-			v3d_generic_attribute_t* nameAttr = node_find_attribute(themeModelNode, str, "Name");
+			v3d_generic_attribute_t* nameAttr = node_find_attribute(themeNode, str, "Name");
 			if(!nameAttr)
 			{
 				DEBUG_LOG_ERROR("[Name] attribute is expected on \"Theme\" block, but not given");
 				goto HANDLE_FAILURE;
 			}
-			v3d_generic_attribute_t* modelAttr = node_find_attribute(themeModelNode, str, "Model");
-			if(!modelAttr)
+			std::vector<ThemeInterfaceType*> interfaces;
+			using UserData = struct { std::vector<ThemeInterfaceType*>* interfaces; ThemeManager<std::string, std::string_view>* thisPtr; };
+			UserData userData = { &interfaces, this };
+			node_foreach_attribute_name(themeNode, str, "Model", [](v3d_generic_attribute_t* modelAttr, const char* start, void* user_data) noexcept -> bool
 			{
-				DEBUG_LOG_ERROR("[Model] attribute is expected on \"Theme\" block, but not given");
-				goto HANDLE_FAILURE;
-			}
-			ThemeInterfaceType* interface = NULL;
-			if(modelAttr->argument_count == 1)
-			{
-				auto themeInterfaceName = std::string_view { modelAttr->arguments[0].start + str, U32_PAIR_DIFF(modelAttr->arguments[0]) };
-				if(!containsThemeInterface(themeInterfaceName))
+				auto* ud = static_cast<UserData*>(user_data);
+				if(modelAttr->argument_count == 1)
 				{
-					DEBUG_LOG_ERROR("No Theme interface/model with name \"%.*s\" is found", themeInterfaceName.length(), themeInterfaceName.data());
-					goto HANDLE_FAILURE;
+					auto themeInterfaceName = std::string_view { modelAttr->arguments[0].start + start, U32_PAIR_DIFF(modelAttr->arguments[0]) };
+					if(!ud->thisPtr->containsThemeInterface(themeInterfaceName))
+					{
+						DEBUG_LOG_ERROR("No Theme interface/model with name \"%.*s\" is found", themeInterfaceName.length(), themeInterfaceName.data());
+						return false;
+					}
+					ud->interfaces->push_back(ud->thisPtr->getThemeInterface(themeInterfaceName));
+					return true;
 				}
-				interface = getThemeInterface(themeInterfaceName);
-			}
-			else
+				else
+				{
+					DEBUG_LOG_ERROR("Arguments mismatch, \"Model\" attribute accepts one argument (string), but either not given or more provided");
+					return false;
+				}
+				return true;
+			}, &userData);
+			if(!interfaces.size())
 			{
-				DEBUG_LOG_ERROR("Arguments mismatch, \"Model\" attribute accepts one argument (string), but either not given or more provided");
+				DEBUG_LOG_ERROR("[Model] attribute is expected on \"Theme\" block, but not given");
 				goto HANDLE_FAILURE;
 			}
 			if(nameAttr->argument_count == 1)
 			{
 				strView = std::string_view { nameAttr->arguments[0].start + str, U32_PAIR_DIFF(nameAttr->arguments[0]) };
-				theme = createTheme(strView, interface);
-				for(u32 i = 0; i < themeModelNode->child_count; ++i)
+				theme = createTheme(strView, interfaces);
+				for(u32 i = 0; i < themeNode->child_count; ++i)
 				{
-					v3d_generic_node_t* child = themeModelNode->childs[i];
+					v3d_generic_node_t* child = themeNode->childs[i];
 					if(!child->qualifier_count)
 					{
 						DEBUG_LOG_ERROR("Anonymous (empty names) aren't allowed");
@@ -412,42 +419,43 @@ namespace SUTK
 						DEBUG_LOG_ERROR("No value has been assigned to \"%.*s\"", nameSV.length(), nameSV.data());
 						goto HANDLE_FAILURE;
 					}
-					ThemeInterfaceType::Type type = interface->getType(nameSV);
-					switch(type)
+					std::optional<ThemeInterfaceType::Type> type = theme->getKeyType(nameSV);
+					if(!type)
+						DEBUG_LOG_WARNING("Couldn't find a key into any of the theme models which the theme implements, skipping \"%.*s\"", nameSV.length(), nameSV.data());
+					else
 					{
-						case ThemeInterfaceType::Type::Color:
-						{
-							Color4 color = deriveValue<Color4>(child->value, str);
-							theme->add<Color4>(nameSV, std::move(color));
-							break;
-						}
-						case ThemeInterfaceType::Type::Image:
-						{
-							UIDriver::ImageReference image = deriveValue<UIDriver::ImageReference>(child->value, str);
-							theme->add<UIDriver::ImageReference>(nameSV, std::move(image));
-							break;
-						}
-						case ThemeInterfaceType::Type::Font:
-						{
-							UIDriver::FontReference font = deriveValue<UIDriver::FontReference>(child->value, str);
-							theme->add<UIDriver::FontReference>(nameSV, std::move(font));
-							break;
-						}
-						case ThemeInterfaceType::Type::Float:
-						{
-							f32 flt = deriveValue<f32>(child->value, str);
-							theme->add<f32>(nameSV, std::move(flt));
-							break;
-						}
-						case ThemeInterfaceType::Type::String:
-						{
-							std::string stdstr = deriveValue<std::string>(child->value, str);
-							theme->add<std::string>(nameSV, std::move(stdstr));
-							break;
-						}
-						default:
+						switch(*type)
 						{
-							DEBUG_LOG_WARNING("Type either isn't recognized or not given, skipping \"%.*s\"", nameSV.length(), nameSV.data());
+							case ThemeInterfaceType::Type::Color:
+							{
+								Color4 color = deriveValue<Color4>(child->value, str);
+								theme->add<Color4>(nameSV, std::move(color));
+								break;
+							}
+							case ThemeInterfaceType::Type::Image:
+							{
+								UIDriver::ImageReference image = deriveValue<UIDriver::ImageReference>(child->value, str);
+								theme->add<UIDriver::ImageReference>(nameSV, std::move(image));
+								break;
+							}
+							case ThemeInterfaceType::Type::Font:
+							{
+								UIDriver::FontReference font = deriveValue<UIDriver::FontReference>(child->value, str);
+								theme->add<UIDriver::FontReference>(nameSV, std::move(font));
+								break;
+							}
+							case ThemeInterfaceType::Type::Float:
+							{
+								f32 flt = deriveValue<f32>(child->value, str);
+								theme->add<f32>(nameSV, std::move(flt));
+								break;
+							}
+							case ThemeInterfaceType::Type::String:
+							{
+								std::string stdstr = deriveValue<std::string>(child->value, str);
+								theme->add<std::string>(nameSV, std::move(stdstr));
+								break;
+							}
 						}
 					}
 				}
diff --git a/sutk/source/tests/MultipleThemeModelTest.cpp b/sutk/source/tests/MultipleThemeModelTest.cpp
new file mode 100644
index 00000000..e41ce271
--- /dev/null
+++ b/sutk/source/tests/MultipleThemeModelTest.cpp
@@ -0,0 +1,151 @@
+#include <sutk/tests/MultipleThemeModelTest.hpp>
+
+#include <sutk/RenderImage.hpp>
+#include <sutk/RenderRectFill.hpp>
+#include <sutk/SGEGfxDriver.hpp>
+#include <sutk/SGEInputDriver.hpp>
+#include <sutk/RenderableContainer.hpp>
+#include <sutk/FullWindowContainer.hpp>
+#include <sutk/ThemeManager.hpp>
+#include <sutk/Label.hpp>
+
+namespace SUTK
+{
+	ITest::TestInitializationData MultipleThemeModelTest::getInitializationData()
+	{
+		auto data = ITest::getInitializationData();
+		data.driverInitializationData.title = "Multiple Theme Load Test (press B to toggle themes)";
+		return data;
+	}
+
+	void MultipleThemeModelTest::initialize(SGE::Driver& driver)
+	{
+		m_gfxDriver = new SGEGfxDriver(driver);
+		m_inputDriver = new SGEInputDriver(driver);
+		m_uiDriver = new UIDriver(*m_gfxDriver, *m_inputDriver);
+
+		ThemeManager<std::string, std::string_view>* themeManager = new ThemeManager<std::string, std::string_view>(*m_uiDriver);
+		ThemeInterface<std::string, std::string_view>* themeInt = themeManager->loadThemeInterface("themes/multiple_theme_model_test/model1.tmdl");
+		if(themeInt)
+			themeInt->dump();
+		else
+			DEBUG_LOG_FETAL_ERROR("Failed to load or parse the themes/multiple_theme_model_test/model1.tmdl file");
+		ThemeInterface<std::string, std::string_view>* themeInt2 = themeManager->loadThemeInterface("themes/multiple_theme_model_test/model2.tmdl");
+		if(themeInt2)
+			themeInt2->dump();
+		else
+			DEBUG_LOG_FETAL_ERROR("Failed to load or parse the themes/multiple_theme_model_test/model2.tmdl file");
+		Theme<std::string, std::string_view>* theme1 = themeManager->loadTheme("themes/multiple_theme_model_test/theme1.theme");
+		Theme<std::string, std::string_view>* theme2 = themeManager->loadTheme("themes/multiple_theme_model_test/theme2.theme");
+		Theme<std::string, std::string_view>* theme3 = themeManager->loadTheme("themes/multiple_theme_model_test/theme3.theme");
+
+		FullWindowContainer* rootContainer = m_uiDriver->createContainer<FullWindowContainer>(com::null_pointer<Container>());
+		Container* emptyContainer = m_uiDriver->createContainer<Container>(rootContainer);
+		emptyContainer->setRect({ 1.0f, 1.0f, 7.0f, 7.0f });
+		AnchorRect* anchor = emptyContainer->getAnchorRect();
+		anchor->setTopLeft({ 0, 0 });
+		anchor->setBottomRight({ 1, 1 });
+		m_renderRectContainer = m_uiDriver->createContainer<RenderableContainer>(emptyContainer);
+		m_renderRectContainer->setRect({ 1.0f, 1.0f, 5, 5 });
+		anchor = m_renderRectContainer->getAnchorRect();
+		anchor->setTopLeft({ 1, 1 });
+		anchor->setBottomRight({ 1, 1 });
+		emptyContainer->setRect({ 1.0f, 1.0f, 9.0f, 7.0f });
+		emptyContainer->setRect({ 1.0f, 1.0f, 11.0f, 7.0f });
+		m_renderRect = m_uiDriver->createRenderable<RenderImage>(m_renderRectContainer);
+		themeInt->bind<UIDriver::ImageReference>("Folder.Open", std::bind(&RenderImage::setImage, m_renderRect, std::placeholders::_1));
+
+		Container* emptyContainer1 = m_uiDriver->createContainer<Container>(rootContainer);
+		emptyContainer1->setRect({ 1.0f, 1.0f, 7.0f, 7.0f });
+		AnchorRect* anchor1 = emptyContainer1->getAnchorRect();
+		anchor1->setTopLeft({ 0, 0 });
+		anchor1->setBottomRight({ 1, 1 });
+		RenderableContainer* renderRectContainer1 = m_uiDriver->createContainer<RenderableContainer>(emptyContainer1);
+		renderRectContainer1->setRect({ 7.0f, 1.0f, 5, 5 });
+		anchor1 = renderRectContainer1->getAnchorRect();
+		anchor1->setTopLeft({ 1, 1 });
+		anchor1->setBottomRight({ 1, 1 });
+		emptyContainer1->setRect({ 1.0f, 1.0f, 9.0f, 7.0f });
+		emptyContainer1->setRect({ 1.0f, 1.0f, 11.0f, 7.0f });
+		RenderImage* renderImage = m_uiDriver->createRenderable<RenderImage>(renderRectContainer1);
+		themeInt->bind<UIDriver::ImageReference>("Folder.Open.VG", std::bind(&RenderImage::setImage, renderImage, std::placeholders::_1));
+		renderImage->setColor(Color4::white());
+
+		RenderableContainer* renderRectContainer2 = m_uiDriver->createContainer<RenderableContainer>(rootContainer);
+		RenderRectFill* renderRect2 = m_uiDriver->createRenderable<RenderRectFill>(renderRectContainer2);
+		renderRectContainer2->setRect({ 5.0f, 10.0f, 5.0f, 5.0f });
+		AnchorRect* anchor2 = renderRectContainer2->getAnchorRect();
+		anchor2->setTopLeft({ 0.0f, 0.0f });
+		anchor2->setBottomRight({ 1.0f, 1.0f });
+		themeInt->bind<Color4>("LargeButton.HoverColor", std::bind(&RenderRectFill::setColor, renderRect2, std::placeholders::_1));
+		renderRect2->setColor(Color4::red());
+
+		RenderableContainer* renderRectContainer3 = m_uiDriver->createContainer<RenderableContainer>(rootContainer);
+		RenderRectFill* renderRect3 = m_uiDriver->createRenderable<RenderRectFill>(renderRectContainer3);
+		renderRectContainer3->setRect({ 11.0f, 10.0f, 5.0f, 5.0f });
+		AnchorRect* anchor3 = renderRectContainer3->getAnchorRect();
+		anchor3->setTopLeft({ 0.0f, 0.0f });
+		anchor3->setBottomRight({ 1.0f, 1.0f });
+		themeInt2->bind<f32>("AnotherButton.AlphaValue", [renderRect3](f32 value) noexcept
+			{ 
+				auto color = renderRect3->getColor(); 
+				std::cout << "Float value: " << value << std::endl;
+				color.alpha(value * 255);
+				renderRect3->setColor(color);
+			});
+		renderRect3->setColor(Color4::yellow());
+
+		Label* label = m_uiDriver->createContainer<Label>(rootContainer);
+		label->setRect({ 11.0f, 8.0f, 5.0f, 5.0f });
+		AnchorRect* anchor4 = label->getAnchorRect();
+		anchor4->setTopLeft({ 0.0f, 0.0f });
+		anchor4->setBottomRight({ 1.0f, 1.0f });
+		// It is expected that "Hello World From Theme 3" will never be set here
+		// As the theme 3 doesn't implement theme model 2
+		themeInt2->bind<std::string>("Label.Value", [label](const std::string& value) noexcept
+			{
+				std::cout << "String value: " << value << std::endl;
+				label->set(value);
+			});
+
+		themeInt->applyTheme(theme1);
+
+		m_inputDriver->getOnKeyEvent().subscribe([theme1, theme2, theme3](IInputDriver* driver, KeyCode keycode, KeyEvent event, ModifierKeys)
+		{
+			static u32 index = 0;
+			if((keycode == KeyCode::B) && (event == KeyEvent::Press))
+			{
+				switch(index)
+				{
+					case 0:
+						theme1->apply();
+						break;
+					case 1:
+						theme2->apply();
+						break;
+					case 2:
+						theme3->apply();
+						break;
+				}
+				index = (index + 1) % 3;
+			}
+		});
+	}
+
+	void MultipleThemeModelTest::terminate(SGE::Driver& driver)
+	{
+		// TODO: m_uiDriver->unloadImage(image);
+		delete m_uiDriver;
+		delete m_gfxDriver;
+	}
+
+	void MultipleThemeModelTest::render(SGE::Driver& driver)
+	{
+		// SUTK::UIDriver::render() should only be called when there is an update in the UI or screen resize
+		m_uiDriver->render();
+	}
+
+	void MultipleThemeModelTest::update(SGE::Driver& driver, float deltaTime)
+	{
+	}
+}
diff --git a/sutk/themes/multiple_theme_model_test/model1.tmdl b/sutk/themes/multiple_theme_model_test/model1.tmdl
new file mode 100644
index 00000000..5d5a9dc4
--- /dev/null
+++ b/sutk/themes/multiple_theme_model_test/model1.tmdl
@@ -0,0 +1,22 @@
+[Name("Theme Model 1")]
+ThemeModel
+{
+	[Color]
+	LargeButton.IdleColor;
+	[Color]
+	LargeButton.HoverColor;
+	[Color]
+	LargeButton.PressColor;
+	[Color]
+	SmallButton.IdleColor;
+	[Color]
+	SmallButton.HoverColor;
+	[Color]
+	SmallButton.PressColor;
+	[Image]
+	Folder.Open;
+	[Image]
+	Folder.Open.VG;
+	[Image]
+	Folder.Close;
+}
\ No newline at end of file
diff --git a/sutk/themes/multiple_theme_model_test/model2.tmdl b/sutk/themes/multiple_theme_model_test/model2.tmdl
new file mode 100644
index 00000000..59b761ca
--- /dev/null
+++ b/sutk/themes/multiple_theme_model_test/model2.tmdl
@@ -0,0 +1,8 @@
+[Name("Theme Model 2")]
+ThemeModel
+{
+	[Float]
+	AnotherButton.AlphaValue;
+	[String]
+	Label.Value;
+}
\ No newline at end of file
diff --git a/sutk/themes/multiple_theme_model_test/theme1.theme b/sutk/themes/multiple_theme_model_test/theme1.theme
new file mode 100644
index 00000000..cbbe77d4
--- /dev/null
+++ b/sutk/themes/multiple_theme_model_test/theme1.theme
@@ -0,0 +1,19 @@
+[Name("My Theme 1")]
+[Model("Theme Model 1")]
+[Model("Theme Model 2")]
+Theme
+{
+    LargeButton.IdleColor = green { };
+    LargeButton.HoverColor = red { };
+    LargeButton.PressColor = grey { };
+    SmallButton.IdleColor = green { };
+    SmallButton.HoverColor = red { 1.0f };
+    SmallButton.PressColor = grey { 1.0f };
+    Folder.Open = "../textures/Thalita-Torres-Office-Archive-folders.512.png";
+    Folder.Open.VG = "svg_files/close-cross-symbol-in-a-circle-svgrepo-com.svg";
+    Folder.Close = "icons/Folder-Close.png";
+    [Float]
+    AnotherButton.AlphaValue = 0.7f;
+    [String]
+    Label.Value = "Hello World From Theme 1";
+}
diff --git a/sutk/themes/multiple_theme_model_test/theme2.theme b/sutk/themes/multiple_theme_model_test/theme2.theme
new file mode 100644
index 00000000..f2834220
--- /dev/null
+++ b/sutk/themes/multiple_theme_model_test/theme2.theme
@@ -0,0 +1,19 @@
+[Name("My Theme 2")]
+[Model("Theme Model 1")]
+[Model("Theme Model 2")]
+Theme
+{
+    LargeButton.IdleColor = green { };
+    LargeButton.HoverColor = red { 0.5f };
+    LargeButton.PressColor = grey { };
+    SmallButton.IdleColor = green { };
+    SmallButton.HoverColor = red { 1.0f };
+    SmallButton.PressColor = grey { 1.0f };
+    Folder.Open = "../textures/Smile.bmp";
+    Folder.Open.VG = "svg_files/apple-svgrepo-com.svg";
+    Folder.Close = "icons/Folder-Close.png";
+    [Float]
+    AnotherButton.AlphaValue = 0.05f;
+    [String]
+    Label.Value = "Hello World From Theme 2";
+}
diff --git a/sutk/themes/multiple_theme_model_test/theme3.theme b/sutk/themes/multiple_theme_model_test/theme3.theme
new file mode 100644
index 00000000..971866ae
--- /dev/null
+++ b/sutk/themes/multiple_theme_model_test/theme3.theme
@@ -0,0 +1,18 @@
+[Name("My Theme 3")]
+[Model("Theme Model 1")]
+Theme
+{
+    LargeButton.IdleColor = green { };
+    LargeButton.HoverColor = blue { 0.7f };
+    LargeButton.PressColor = grey { };
+    SmallButton.IdleColor = green { };
+    SmallButton.HoverColor = red { 1.0f };
+    SmallButton.PressColor = grey { 1.0f };
+    Folder.Open = "../textures/Smile.bmp";
+    Folder.Open.VG = "svg_files/apple-svgrepo-com.svg";
+    Folder.Close = "icons/Folder-Close.png";
+    [Float]
+    AnotherButton.AlphaValue = 0.5f;
+    [String]
+    Label.Value = "Hello World From Theme 3";
+}