diff --git a/Hazel/src/Hazel/Scene/SceneSerializer.cpp b/Hazel/src/Hazel/Scene/SceneSerializer.cpp
index 6aa2a6619..e357d9cfb 100644
--- a/Hazel/src/Hazel/Scene/SceneSerializer.cpp
+++ b/Hazel/src/Hazel/Scene/SceneSerializer.cpp
@@ -88,6 +88,10 @@ namespace YAML {
 }
 namespace Hazel {
 
+	static void SerializeAllEntityComponents(YAML::Emitter& out, Entity entity);
+
+	static void DeserializeAllEntryComponents(YAML::detail::iterator_value& entity, Entity& deserializedEntity);
+
 	YAML::Emitter& operator<<(YAML::Emitter& out, const glm::vec2& v)
 	{
 		out << YAML::Flow;
@@ -113,9 +117,9 @@ namespace Hazel {
 	{
 		switch (bodyType)
 		{
-			case Rigidbody2DComponent::BodyType::Static:    return "Static";
-			case Rigidbody2DComponent::BodyType::Dynamic:   return "Dynamic";
-			case Rigidbody2DComponent::BodyType::Kinematic: return "Kinematic";
+		case Rigidbody2DComponent::BodyType::Static:    return "Static";
+		case Rigidbody2DComponent::BodyType::Dynamic:   return "Dynamic";
+		case Rigidbody2DComponent::BodyType::Kinematic: return "Kinematic";
 		}
 
 		HZ_CORE_ASSERT(false, "Unknown body type");
@@ -127,7 +131,7 @@ namespace Hazel {
 		if (bodyTypeString == "Static")    return Rigidbody2DComponent::BodyType::Static;
 		if (bodyTypeString == "Dynamic")   return Rigidbody2DComponent::BodyType::Dynamic;
 		if (bodyTypeString == "Kinematic") return Rigidbody2DComponent::BodyType::Kinematic;
-	
+
 		HZ_CORE_ASSERT(false, "Unknown body type");
 		return Rigidbody2DComponent::BodyType::Static;
 	}
@@ -144,6 +148,98 @@ namespace Hazel {
 		out << YAML::BeginMap; // Entity
 		out << YAML::Key << "Entity" << YAML::Value << entity.GetUUID();
 
+		// Serialize components (except IDComponent)
+		SerializeAllEntityComponents(out,entity);
+
+		out << YAML::EndMap; // Entity
+	}
+
+	void SceneSerializer::Serialize(const std::string& filepath)
+	{
+		YAML::Emitter out;
+		out << YAML::BeginMap;
+		out << YAML::Key << "Scene" << YAML::Value << "Untitled";
+		out << YAML::Key << "Entities" << YAML::Value << YAML::BeginSeq;
+		m_Scene->m_Registry.each([&](auto entityID)
+		{
+			Entity entity = { entityID, m_Scene.get() };
+			if (!entity)
+				return;
+
+			SerializeEntity(out, entity);
+		});
+		out << YAML::EndSeq;
+		out << YAML::EndMap;
+
+		std::ofstream fout(filepath);
+		fout << out.c_str();
+	}
+
+	void SceneSerializer::SerializeRuntime(const std::string& filepath)
+	{
+		// Not implemented
+		HZ_CORE_ASSERT(false);
+	}
+
+	bool SceneSerializer::Deserialize(const std::string& filepath)
+	{
+		YAML::Node data;
+		try
+		{
+			data = YAML::LoadFile(filepath);
+		}
+		catch (YAML::ParserException e)
+		{
+			HZ_CORE_ERROR("Failed to load .hazel file '{0}'\n     {1}", filepath, e.what());
+			return false;
+		}
+
+		if (!data["Scene"])
+			return false;
+
+		std::string sceneName = data["Scene"].as<std::string>();
+		HZ_CORE_TRACE("Deserializing scene '{0}'", sceneName);
+
+		auto entities = data["Entities"];
+		if (entities)
+		{
+			for (auto entity : entities)
+			{
+				uint64_t uuid = entity["Entity"].as<uint64_t>();
+
+				std::string name;
+				auto tagComponent = entity["TagComponent"];
+				if (tagComponent)
+					name = tagComponent["Tag"].as<std::string>();
+
+				HZ_CORE_TRACE("Deserialized entity with ID = {0}, name = {1}", uuid, name);
+
+				Entity deserializedEntity = m_Scene->CreateEntityWithUUID(uuid, name);
+
+				// Deserialize components (except IDComponent and TagComponent)
+				DeserializeAllEntryComponents(entity, deserializedEntity);
+			}
+		}
+
+		return true;
+	}
+
+	bool SceneSerializer::DeserializeRuntime(const std::string& filepath)
+	{
+		// Not implemented
+		HZ_CORE_ASSERT(false);
+		return false;
+	}
+
+	template<typename Component>
+	static void SerializeEntityComponent(YAML::Emitter&, Entity) = delete;
+
+	template<typename Component>
+	void DeserializeEntryComponent(YAML::detail::iterator_value& entity, Entity&) = delete;
+
+	template<>
+	static void SerializeEntityComponent<TagComponent>(YAML::Emitter& out, Entity entity)
+	{
 		if (entity.HasComponent<TagComponent>())
 		{
 			out << YAML::Key << "TagComponent";
@@ -154,7 +250,11 @@ namespace Hazel {
 
 			out << YAML::EndMap; // TagComponent
 		}
+	}
 
+	template<>
+	static void SerializeEntityComponent<TransformComponent>(YAML::Emitter& out, Entity entity)
+	{
 		if (entity.HasComponent<TransformComponent>())
 		{
 			out << YAML::Key << "TransformComponent";
@@ -168,6 +268,25 @@ namespace Hazel {
 			out << YAML::EndMap; // TransformComponent
 		}
 
+	}
+
+	template<>
+	static void DeserializeEntryComponent<TransformComponent>(YAML::detail::iterator_value& entity, Entity& deserializedEntity)
+	{
+		auto transformComponent = entity["TransformComponent"];
+		if (transformComponent)
+		{
+			// Entities always have transforms
+			auto& tc = deserializedEntity.GetComponent<TransformComponent>();
+			tc.Translation = transformComponent["Translation"].as<glm::vec3>();
+			tc.Rotation = transformComponent["Rotation"].as<glm::vec3>();
+			tc.Scale = transformComponent["Scale"].as<glm::vec3>();
+		}
+	}
+
+	template<>
+	static void SerializeEntityComponent<CameraComponent>(YAML::Emitter& out, Entity entity)
+	{
 		if (entity.HasComponent<CameraComponent>())
 		{
 			out << YAML::Key << "CameraComponent";
@@ -192,22 +311,71 @@ namespace Hazel {
 
 			out << YAML::EndMap; // CameraComponent
 		}
+	}
+
+	template<>
+	static void DeserializeEntryComponent<CameraComponent>(YAML::detail::iterator_value& entity, Entity& deserializedEntity)
+	{
+		auto cameraComponent = entity["CameraComponent"];
+		if (cameraComponent)
+		{
+			auto& cc = deserializedEntity.AddComponent<CameraComponent>();
+
+			auto& cameraProps = cameraComponent["Camera"];
+			cc.Camera.SetProjectionType((SceneCamera::ProjectionType)cameraProps["ProjectionType"].as<int>());
+
+			cc.Camera.SetPerspectiveVerticalFOV(cameraProps["PerspectiveFOV"].as<float>());
+			cc.Camera.SetPerspectiveNearClip(cameraProps["PerspectiveNear"].as<float>());
+			cc.Camera.SetPerspectiveFarClip(cameraProps["PerspectiveFar"].as<float>());
 
+			cc.Camera.SetOrthographicSize(cameraProps["OrthographicSize"].as<float>());
+			cc.Camera.SetOrthographicNearClip(cameraProps["OrthographicNear"].as<float>());
+			cc.Camera.SetOrthographicFarClip(cameraProps["OrthographicFar"].as<float>());
+
+			cc.Primary = cameraComponent["Primary"].as<bool>();
+			cc.FixedAspectRatio = cameraComponent["FixedAspectRatio"].as<bool>();
+		}
+	}
+
+	template<>
+	static void SerializeEntityComponent<SpriteRendererComponent>(YAML::Emitter& out, Entity entity)
+	{
 		if (entity.HasComponent<SpriteRendererComponent>())
 		{
 			out << YAML::Key << "SpriteRendererComponent";
 			out << YAML::BeginMap; // SpriteRendererComponent
 
 			auto& spriteRendererComponent = entity.GetComponent<SpriteRendererComponent>();
-			out << YAML::Key << "Color" << YAML::Value << spriteRendererComponent.Color;
-			if (spriteRendererComponent.Texture)
+			if (spriteRendererComponent.Texture && std::filesystem::exists(spriteRendererComponent.Texture->GetPath()))
+			{
 				out << YAML::Key << "TexturePath" << YAML::Value << spriteRendererComponent.Texture->GetPath();
+			}
+			out << YAML::Key << "Color" << YAML::Value << spriteRendererComponent.Color;
 
 			out << YAML::Key << "TilingFactor" << YAML::Value << spriteRendererComponent.TilingFactor;
 
 			out << YAML::EndMap; // SpriteRendererComponent
 		}
+	}
 
+	template<>
+	static void DeserializeEntryComponent<SpriteRendererComponent>(YAML::detail::iterator_value& entity, Entity& deserializedEntity)
+	{
+		auto spriteRendererComponent = entity["SpriteRendererComponent"];
+		if (spriteRendererComponent)
+		{
+			auto& src = deserializedEntity.AddComponent<SpriteRendererComponent>();
+			if(spriteRendererComponent["TexturePath"])
+				src.Texture = Texture2D::Create(spriteRendererComponent["TexturePath"].as<std::string>());
+			src.Color = spriteRendererComponent["Color"].as<glm::vec4>();
+			if (spriteRendererComponent["TilingFactor"])
+				src.TilingFactor = spriteRendererComponent["TilingFactor"].as<float>();
+		}
+	}
+
+	template<>
+	static void SerializeEntityComponent<CircleRendererComponent>(YAML::Emitter& out, Entity entity)
+	{
 		if (entity.HasComponent<CircleRendererComponent>())
 		{
 			out << YAML::Key << "CircleRendererComponent";
@@ -216,11 +384,26 @@ namespace Hazel {
 			auto& circleRendererComponent = entity.GetComponent<CircleRendererComponent>();
 			out << YAML::Key << "Color" << YAML::Value << circleRendererComponent.Color;
 			out << YAML::Key << "Thickness" << YAML::Value << circleRendererComponent.Thickness;
-			out << YAML::Key << "Fade" << YAML::Value << circleRendererComponent.Fade;
 
 			out << YAML::EndMap; // CircleRendererComponent
 		}
+	}
 
+	template<>
+	static void DeserializeEntryComponent<CircleRendererComponent>(YAML::detail::iterator_value& entity, Entity& deserializedEntity)
+	{
+		auto circleRendererComponent = entity["CircleRendererComponent"];
+		if (circleRendererComponent)
+		{
+			auto& src = deserializedEntity.AddComponent<CircleRendererComponent>();
+			src.Color = circleRendererComponent["Color"].as<glm::vec4>();
+			src.Thickness = circleRendererComponent["Thickness"].as<float>();
+		}
+	}
+
+	template<>
+	static void SerializeEntityComponent<Rigidbody2DComponent>(YAML::Emitter& out, Entity entity)
+	{
 		if (entity.HasComponent<Rigidbody2DComponent>())
 		{
 			out << YAML::Key << "Rigidbody2DComponent";
@@ -232,7 +415,23 @@ namespace Hazel {
 
 			out << YAML::EndMap; // Rigidbody2DComponent
 		}
+	}
+
+	template<>
+	static void DeserializeEntryComponent<Rigidbody2DComponent>(YAML::detail::iterator_value& entity, Entity& deserializedEntity)
+	{
+		auto rigidbody2DComponent = entity["Rigidbody2DComponent"];
+		if (rigidbody2DComponent)
+		{
+			auto& rb2d = deserializedEntity.AddComponent<Rigidbody2DComponent>();
+			rb2d.Type = RigidBody2DBodyTypeFromString(rigidbody2DComponent["BodyType"].as<std::string>());
+			rb2d.FixedRotation = rigidbody2DComponent["FixedRotation"].as<bool>();
+		}
+	}
 
+	template<>
+	static void SerializeEntityComponent<BoxCollider2DComponent>(YAML::Emitter& out, Entity entity)
+	{
 		if (entity.HasComponent<BoxCollider2DComponent>())
 		{
 			out << YAML::Key << "BoxCollider2DComponent";
@@ -248,6 +447,26 @@ namespace Hazel {
 
 			out << YAML::EndMap; // BoxCollider2DComponent
 		}
+	}
+
+	template<>
+	static void DeserializeEntryComponent<BoxCollider2DComponent>(YAML::detail::iterator_value& entity, Entity& deserializedEntity)
+	{
+		auto boxCollider2DComponent = entity["BoxCollider2DComponent"];
+		if (boxCollider2DComponent)
+		{
+			auto& bc2d = deserializedEntity.AddComponent<BoxCollider2DComponent>();
+			bc2d.Offset = boxCollider2DComponent["Offset"].as<glm::vec2>();
+			bc2d.Size = boxCollider2DComponent["Size"].as<glm::vec2>();
+			bc2d.Density = boxCollider2DComponent["Density"].as<float>();
+			bc2d.Friction = boxCollider2DComponent["Friction"].as<float>();
+			bc2d.Restitution = boxCollider2DComponent["Restitution"].as<float>();
+			bc2d.RestitutionThreshold = boxCollider2DComponent["RestitutionThreshold"].as<float>();
+		}
+	}
+	template<>
+	static void SerializeEntityComponent<CircleCollider2DComponent>(YAML::Emitter& out, Entity entity)
+	{
 
 		if (entity.HasComponent<CircleCollider2DComponent>())
 		{
@@ -264,165 +483,67 @@ namespace Hazel {
 
 			out << YAML::EndMap; // CircleCollider2DComponent
 		}
-
-		out << YAML::EndMap; // Entity
 	}
 
-	void SceneSerializer::Serialize(const std::string& filepath)
+	template<>
+	static void DeserializeEntryComponent<CircleCollider2DComponent>(YAML::detail::iterator_value& entity, Entity& deserializedEntity)
 	{
-		YAML::Emitter out;
-		out << YAML::BeginMap;
-		out << YAML::Key << "Scene" << YAML::Value << "Untitled";
-		out << YAML::Key << "Entities" << YAML::Value << YAML::BeginSeq;
-		m_Scene->m_Registry.each([&](auto entityID)
+		auto circleCollider2DComponent = entity["CircleCollider2DComponent"];
+		if (circleCollider2DComponent)
 		{
-			Entity entity = { entityID, m_Scene.get() };
-			if (!entity)
-				return;
-
-			SerializeEntity(out, entity);
-		});
-		out << YAML::EndSeq;
-		out << YAML::EndMap;
-
-		std::ofstream fout(filepath);
-		fout << out.c_str();
+			auto& bc2d = deserializedEntity.AddComponent<CircleCollider2DComponent>();
+			bc2d.Offset = circleCollider2DComponent["Offset"].as<glm::vec2>();
+			bc2d.Radius = circleCollider2DComponent["Radius"].as<float>();
+			bc2d.Density = circleCollider2DComponent["Density"].as<float>();
+			bc2d.Friction = circleCollider2DComponent["Friction"].as<float>();
+			bc2d.Restitution = circleCollider2DComponent["Restitution"].as<float>();
+			bc2d.RestitutionThreshold = circleCollider2DComponent["RestitutionThreshold"].as<float>();
+		}
 	}
 
-	void SceneSerializer::SerializeRuntime(const std::string& filepath)
+	template<>
+	static void SerializeEntityComponent<NativeScriptComponent>(YAML::Emitter& out, Entity entity)
 	{
-		// Not implemented
-		HZ_CORE_ASSERT(false);
+		//TODO: serialize NativeScriptComponent?
 	}
 
-	bool SceneSerializer::Deserialize(const std::string& filepath)
+	template<>
+	static void DeserializeEntryComponent<NativeScriptComponent>(YAML::detail::iterator_value&, Entity&)
 	{
-		YAML::Node data;
-		try
-		{
-			data = YAML::LoadFile(filepath);
-		}
-		catch (YAML::ParserException e)
-		{
-			HZ_CORE_ERROR("Failed to load .hazel file '{0}'\n     {1}", filepath, e.what());
-			return false;
-		}
-
-		if (!data["Scene"])
-			return false;
-
-		std::string sceneName = data["Scene"].as<std::string>();
-		HZ_CORE_TRACE("Deserializing scene '{0}'", sceneName);
-
-		auto entities = data["Entities"];
-		if (entities)
-		{
-			for (auto entity : entities)
-			{
-				uint64_t uuid = entity["Entity"].as<uint64_t>();
-
-				std::string name;
-				auto tagComponent = entity["TagComponent"];
-				if (tagComponent)
-					name = tagComponent["Tag"].as<std::string>();
+		//TODO: deserialize NativeScriptComponent?
+	}
 
-				HZ_CORE_TRACE("Deserialized entity with ID = {0}, name = {1}", uuid, name);
+	template<typename...Component>
+	static void SerializeEntityComponents(YAML::Emitter& out, Entity entity)
+	{
+		(SerializeEntityComponent<Component>(out, entity), ...);
+	}
 
-				Entity deserializedEntity = m_Scene->CreateEntityWithUUID(uuid, name);
+	template<typename...Component>
+	static void DeserializeEntryComponents(YAML::detail::iterator_value& entity, Entity& deserializedEntity)
+	{
+		(DeserializeEntryComponent<Component>(entity, deserializedEntity), ...);
+	}
 
-				auto transformComponent = entity["TransformComponent"];
-				if (transformComponent)
-				{
-					// Entities always have transforms
-					auto& tc = deserializedEntity.GetComponent<TransformComponent>();
-					tc.Translation = transformComponent["Translation"].as<glm::vec3>();
-					tc.Rotation = transformComponent["Rotation"].as<glm::vec3>();
-					tc.Scale = transformComponent["Scale"].as<glm::vec3>();
-				}
-
-				auto cameraComponent = entity["CameraComponent"];
-				if (cameraComponent)
-				{
-					auto& cc = deserializedEntity.AddComponent<CameraComponent>();
-
-					auto& cameraProps = cameraComponent["Camera"];
-					cc.Camera.SetProjectionType((SceneCamera::ProjectionType)cameraProps["ProjectionType"].as<int>());
-
-					cc.Camera.SetPerspectiveVerticalFOV(cameraProps["PerspectiveFOV"].as<float>());
-					cc.Camera.SetPerspectiveNearClip(cameraProps["PerspectiveNear"].as<float>());
-					cc.Camera.SetPerspectiveFarClip(cameraProps["PerspectiveFar"].as<float>());
-
-					cc.Camera.SetOrthographicSize(cameraProps["OrthographicSize"].as<float>());
-					cc.Camera.SetOrthographicNearClip(cameraProps["OrthographicNear"].as<float>());
-					cc.Camera.SetOrthographicFarClip(cameraProps["OrthographicFar"].as<float>());
-
-					cc.Primary = cameraComponent["Primary"].as<bool>();
-					cc.FixedAspectRatio = cameraComponent["FixedAspectRatio"].as<bool>();
-				}
-
-				auto spriteRendererComponent = entity["SpriteRendererComponent"];
-				if (spriteRendererComponent)
-				{
-					auto& src = deserializedEntity.AddComponent<SpriteRendererComponent>();
-					src.Color = spriteRendererComponent["Color"].as<glm::vec4>();
-					if (spriteRendererComponent["TexturePath"])
-						src.Texture = Texture2D::Create(spriteRendererComponent["TexturePath"].as<std::string>());
-
-					if (spriteRendererComponent["TilingFactor"])
-						src.TilingFactor = spriteRendererComponent["TilingFactor"].as<float>();
-				}
-
-				auto circleRendererComponent = entity["CircleRendererComponent"];
-				if (circleRendererComponent)
-				{
-					auto& crc = deserializedEntity.AddComponent<CircleRendererComponent>();
-					crc.Color = circleRendererComponent["Color"].as<glm::vec4>();
-					crc.Thickness = circleRendererComponent["Thickness"].as<float>();
-					crc.Fade = circleRendererComponent["Fade"].as<float>();
-				}
-
-				auto rigidbody2DComponent = entity["Rigidbody2DComponent"];
-				if (rigidbody2DComponent)
-				{
-					auto& rb2d = deserializedEntity.AddComponent<Rigidbody2DComponent>();
-					rb2d.Type = RigidBody2DBodyTypeFromString(rigidbody2DComponent["BodyType"].as<std::string>());
-					rb2d.FixedRotation = rigidbody2DComponent["FixedRotation"].as<bool>();
-				}
-
-				auto boxCollider2DComponent = entity["BoxCollider2DComponent"];
-				if (boxCollider2DComponent)
-				{
-					auto& bc2d = deserializedEntity.AddComponent<BoxCollider2DComponent>();
-					bc2d.Offset = boxCollider2DComponent["Offset"].as<glm::vec2>();
-					bc2d.Size = boxCollider2DComponent["Size"].as<glm::vec2>();
-					bc2d.Density = boxCollider2DComponent["Density"].as<float>();
-					bc2d.Friction = boxCollider2DComponent["Friction"].as<float>();
-					bc2d.Restitution = boxCollider2DComponent["Restitution"].as<float>();
-					bc2d.RestitutionThreshold = boxCollider2DComponent["RestitutionThreshold"].as<float>();
-				}
-
-				auto circleCollider2DComponent = entity["CircleCollider2DComponent"];
-				if (circleCollider2DComponent)
-				{
-					auto& cc2d = deserializedEntity.AddComponent<CircleCollider2DComponent>();
-					cc2d.Offset = circleCollider2DComponent["Offset"].as<glm::vec2>();
-					cc2d.Radius = circleCollider2DComponent["Radius"].as<float>();
-					cc2d.Density = circleCollider2DComponent["Density"].as<float>();
-					cc2d.Friction = circleCollider2DComponent["Friction"].as<float>();
-					cc2d.Restitution = circleCollider2DComponent["Restitution"].as<float>();
-					cc2d.RestitutionThreshold = circleCollider2DComponent["RestitutionThreshold"].as<float>();
-				}
-			}
-		}
+	template<typename... PrefixComponent, typename...Component>
+	static void SerializeEntityComponents(ComponentGroup<Component...>, YAML::Emitter& out, Entity entity)
+	{
+		SerializeEntityComponents<PrefixComponent..., Component...>(out, entity);
+	}
 
-		return true;
+	template<typename... PrefixComponent, typename...Component>
+	static void DeserializeEntryComponents(ComponentGroup<Component...>, YAML::detail::iterator_value& entity, Entity& deserializedEntity)
+	{
+		DeserializeEntryComponents<PrefixComponent..., Component...>(entity, deserializedEntity);
 	}
 
-	bool SceneSerializer::DeserializeRuntime(const std::string& filepath)
+	static void SerializeAllEntityComponents(YAML::Emitter& out, Entity entity)
 	{
-		// Not implemented
-		HZ_CORE_ASSERT(false);
-		return false;
+		SerializeEntityComponents<TagComponent>(AllComponents{}, out, entity);
 	}
 
+	static void DeserializeAllEntryComponents(YAML::detail::iterator_value& entity, Entity& deserializedEntity)
+	{
+		DeserializeEntryComponents(AllComponents{}, entity, deserializedEntity);
+	}
 }