diff --git a/Volt/Navigation/src/Navigation/Filesystem/NavMeshImporter.cpp b/Volt/Navigation/src/Navigation/Filesystem/NavMeshImporter.cpp
index 8d53f75e9..71d84d4a7 100644
--- a/Volt/Navigation/src/Navigation/Filesystem/NavMeshImporter.cpp
+++ b/Volt/Navigation/src/Navigation/Filesystem/NavMeshImporter.cpp
@@ -6,6 +6,9 @@
 
 #include <Volt/Asset/AssetManager.h>
 
+#include <Volt/Utility/FileIO/BinaryStreamWriter.h>
+#include <Volt/Utility/FileIO/BinaryStreamReader.h>
+
 namespace Volt
 {
 	namespace AI
@@ -16,23 +19,7 @@ namespace Volt
 		static const int TILECACHESET_MAGIC = 'T' << 24 | 'S' << 16 | 'E' << 8 | 'T'; //'TSET';
 		static const int TILECACHESET_VERSION = 2;
 
-		struct NavMeshSetHeader
-		{
-			int magic;
-			int version;
-			int numTiles;
-			dtNavMeshParams params;
-		};
-
-		struct NavMeshTileHeader
-		{
-			dtTileRef tileRef;
-			int dataSize;
-		};
-
-		VT_OPTIMIZE_OFF
-
-		bool NavMeshImporter::SaveNavMesh(std::ostream& output, Ref<NavMesh>& asset)
+		bool NavMeshImporter::SaveNavMesh(BinaryStreamWriter& output, Ref<NavMesh>& asset)
 		{
 			if (asset->GetNavMesh()->GetTileCache())
 			{
@@ -44,39 +31,30 @@ namespace Volt
 			}
 		}
 
-		bool NavMeshImporter::LoadNavMesh(std::ifstream& input, Ref<dtNavMesh>& asset)
+		bool NavMeshImporter::LoadNavMesh(BinaryStreamReader& input, Ref<dtNavMesh>& asset)
 		{
-			std::streampos currentPosition = input.tellg();
-
 			// Read header.
 			NavMeshSetHeader header;
-			if (!input.read(reinterpret_cast<char*>(&header), sizeof(NavMeshSetHeader)))
-			{
-				input.close();
-				return false;
-			}
-
-			input.seekg(currentPosition);
+			input.Read(header);
 
 			switch (header.magic)
 			{
 				case NAVMESHSET_MAGIC:
 				{
-					return LoadSingleNavMesh(input, asset);
+					return LoadSingleNavMesh(input, header, asset);
 				}
 				case TILECACHESET_MAGIC:
 				{
-					return LoadTiledNavMesh(input, asset);
+					return LoadTiledNavMesh(input, header, asset);
 				}
 				default:
 				{
-					input.close();
 					return false;
 				}
 			}
 		}
 
-		bool NavMeshImporter::SaveSingleNavMesh(std::ostream& output, Ref<NavMesh>& asset)
+		bool NavMeshImporter::SaveSingleNavMesh(BinaryStreamWriter& output, Ref<NavMesh>& asset)
 		{
 			const auto* mesh = asset->GetNavMesh()->GetNavMesh().get();
 
@@ -92,7 +70,7 @@ namespace Volt
 				header.numTiles++;
 			}
 			memcpy(&header.params, mesh->getParams(), sizeof(dtNavMeshParams));
-			output.write(reinterpret_cast<char*>(&header), sizeof(NavMeshSetHeader));
+			output.Write(header);
 
 			// Store tiles.
 			for (int i = 0; i < mesh->getMaxTiles(); ++i)
@@ -103,50 +81,37 @@ namespace Volt
 				NavMeshTileHeader tileHeader;
 				tileHeader.tileRef = mesh->getTileRef(tile);
 				tileHeader.dataSize = tile->dataSize;
-				output.write(reinterpret_cast<char*>(&tileHeader), sizeof(NavMeshTileHeader));
-
-				output.write(reinterpret_cast<const char*>(tile->data), tile->dataSize);
+				output.Write(tileHeader);
+				output.Write(tile->data);
 			}
 			return true;
 		}
 
-		bool NavMeshImporter::SaveTiledNavMesh(std::ostream& output, Ref<NavMesh>& asset)
+		bool NavMeshImporter::SaveTiledNavMesh(BinaryStreamWriter& output, Ref<NavMesh>& asset)
 		{
 			return true;
 		}
 
-		bool NavMeshImporter::LoadSingleNavMesh(std::ifstream& input, Ref<dtNavMesh>& asset)
+		bool NavMeshImporter::LoadSingleNavMesh(BinaryStreamReader& input, const NavMeshSetHeader& header, Ref<dtNavMesh>& asset)
 		{
-			// Read header.
-			NavMeshSetHeader header;
-			if (!input.read(reinterpret_cast<char*>(&header), sizeof(NavMeshSetHeader)))
-			{
-				input.close();
-				return false;
-			}
-
 			if (header.magic != NAVMESHSET_MAGIC)
 			{
-				input.close();
 				return false;
 			}
 			if (header.version != NAVMESHSET_VERSION)
 			{
-				input.close();
 				return false;
 			}
 
 			dtNavMesh* mesh = dtAllocNavMesh();
 			if (!mesh)
 			{
-				input.close();
 				dtFree(mesh);
 				return false;
 			}
 			dtStatus status = mesh->init(&header.params);
 			if (dtStatusFailed(status))
 			{
-				input.close();
 				dtFree(mesh);
 				return false;
 			}
@@ -155,12 +120,7 @@ namespace Volt
 			for (int i = 0; i < header.numTiles; ++i)
 			{
 				NavMeshTileHeader tileHeader;
-				if (!input.read(reinterpret_cast<char*>(&tileHeader), sizeof(NavMeshTileHeader)))
-				{
-					input.close();
-					dtFree(mesh);
-					return false;
-				}
+				input.Read(tileHeader);
 
 				if (!tileHeader.tileRef || !tileHeader.dataSize)
 					break;
@@ -168,14 +128,8 @@ namespace Volt
 				unsigned char* data = (unsigned char*)dtAlloc(tileHeader.dataSize, DT_ALLOC_PERM);
 				if (!data) break;
 				memset(data, 0, tileHeader.dataSize);
-				if (!input.read(reinterpret_cast<char*>(data), tileHeader.dataSize))
-				{
-					dtFree(data);
-					dtFree(mesh);
-					input.close();
-					return false;
-				}
 
+				input.Read(data);
 				mesh->addTile(data, tileHeader.dataSize, DT_TILE_FREE_DATA, tileHeader.tileRef, 0);
 			}
 
@@ -184,7 +138,7 @@ namespace Volt
 			return true;
 		}
 
-		bool NavMeshImporter::LoadTiledNavMesh(std::ifstream& input, Ref<dtNavMesh>& asset)
+		bool NavMeshImporter::LoadTiledNavMesh(BinaryStreamReader& input, const NavMeshSetHeader& header, Ref<dtNavMesh>& asset)
 		{
 			return true;
 		}
diff --git a/Volt/Navigation/src/Navigation/Filesystem/NavMeshImporter.h b/Volt/Navigation/src/Navigation/Filesystem/NavMeshImporter.h
index 4f5adc20c..2082c1a21 100644
--- a/Volt/Navigation/src/Navigation/Filesystem/NavMeshImporter.h
+++ b/Volt/Navigation/src/Navigation/Filesystem/NavMeshImporter.h
@@ -6,6 +6,9 @@
 
 namespace Volt
 {
+	class BinaryStreamReader;
+	class BinaryStreamWriter;
+
 	namespace AI
 	{
 		class NavMeshImporter
@@ -14,15 +17,29 @@ namespace Volt
 			NavMeshImporter() = delete;
 			virtual ~NavMeshImporter() = delete;
 			
-			static bool SaveNavMesh(std::ostream& output, Ref<NavMesh>& asset);
-			static bool LoadNavMesh(std::ifstream& input, Ref<dtNavMesh>& asset);
+			static bool SaveNavMesh(BinaryStreamWriter& output, Ref<NavMesh>& asset);
+			static bool LoadNavMesh(BinaryStreamReader& input, Ref<dtNavMesh>& asset);
 
 		private:
-			static bool SaveSingleNavMesh(std::ostream& output, Ref<NavMesh>& asset);
-			static bool SaveTiledNavMesh(std::ostream& output, Ref<NavMesh>& asset);
+			struct NavMeshSetHeader
+			{
+				int magic;
+				int version;
+				int numTiles;
+				dtNavMeshParams params;
+			};
+
+			struct NavMeshTileHeader
+			{
+				dtTileRef tileRef;
+				int dataSize;
+			};
+
+			static bool SaveSingleNavMesh(BinaryStreamWriter& output, Ref<NavMesh>& asset);
+			static bool SaveTiledNavMesh(BinaryStreamWriter& output, Ref<NavMesh>& asset);
 
-			static bool LoadSingleNavMesh(std::ifstream& input, Ref<dtNavMesh>& asset);
-			static bool LoadTiledNavMesh(std::ifstream& input, Ref<dtNavMesh>& asset);
+			static bool LoadSingleNavMesh(BinaryStreamReader& input, const NavMeshSetHeader& header, Ref<dtNavMesh>& asset);
+			static bool LoadTiledNavMesh(BinaryStreamReader& input, const NavMeshSetHeader& header, Ref<dtNavMesh>& asset);
 		};
 	}
 }
diff --git a/Volt/Navigation/src/Navigation/NavMesh/VTNavMesh.cpp b/Volt/Navigation/src/Navigation/NavMesh/VTNavMesh.cpp
index 63f0d54f9..fb9d12fe2 100644
--- a/Volt/Navigation/src/Navigation/NavMesh/VTNavMesh.cpp
+++ b/Volt/Navigation/src/Navigation/NavMesh/VTNavMesh.cpp
@@ -7,7 +7,7 @@ namespace Volt
 {
 	namespace AI
 	{
-		NavMesh::NavMesh(Ref<dtNavMesh> navmesh, Ref<dtTileCache> tilecache)
+		void NavMesh::Initialize(Ref<dtNavMesh> navmesh, Ref<dtTileCache> tilecache)
 		{
 			myNavMesh = CreateRef<DtNavMesh>(navmesh, tilecache);
 			myCrowd = CreateRef<DtCrowd>(myNavMesh);
diff --git a/Volt/Navigation/src/Navigation/NavMesh/VTNavMesh.h b/Volt/Navigation/src/Navigation/NavMesh/VTNavMesh.h
index bac96a977..5955b00d0 100644
--- a/Volt/Navigation/src/Navigation/NavMesh/VTNavMesh.h
+++ b/Volt/Navigation/src/Navigation/NavMesh/VTNavMesh.h
@@ -19,9 +19,10 @@ namespace Volt
 		{
 		public:
 			NavMesh() = default;
-			NavMesh(Ref<dtNavMesh> navmesh, Ref<dtTileCache> tilecache = nullptr);
 			virtual ~NavMesh() = default;
 
+			void Initialize(Ref<dtNavMesh> navmesh, Ref<dtTileCache> tilecache = nullptr);
+
 			Ref<DtNavMesh>& GetNavMesh() { return myNavMesh; }
 			Ref<DtCrowd>& GetCrowd() { return myCrowd; }
 
@@ -30,6 +31,7 @@ namespace Volt
 
 		private:
 			friend class NavigationSystem;
+
 			void Update(float deltaTime);
 
 			Ref<DtNavMesh> myNavMesh = nullptr;
diff --git a/Volt/Navigation/src/NavigationEditor/Builder/RecastBuilder.cpp b/Volt/Navigation/src/NavigationEditor/Builder/RecastBuilder.cpp
index ba6081827..9ad398879 100644
--- a/Volt/Navigation/src/NavigationEditor/Builder/RecastBuilder.cpp
+++ b/Volt/Navigation/src/NavigationEditor/Builder/RecastBuilder.cpp
@@ -762,7 +762,8 @@ Ref<Volt::AI::NavMesh> RecastBuilder::BuildSingleNavMesh()
 			return nullptr;
 		}
 
-		result = CreateRef<Volt::AI::NavMesh>(navMesh);
+		result = CreateRef<Volt::AI::NavMesh>();
+		result->Initialize(navMesh);
 
 		if (result)
 		{
@@ -948,7 +949,8 @@ Ref<Volt::AI::NavMesh> RecastBuilder::BuildTiledNavMesh()
 		}
 	}
 
-	result = CreateRef<Volt::AI::NavMesh>(navMesh, tileCache);
+	result = CreateRef<Volt::AI::NavMesh>();
+	result->Initialize(navMesh, tileCache);
 
 	auto gridSize = tw * th;
 	const float compressionRatio = (float)m_cacheCompressedSize / (float)(m_cacheRawSize + 1);
diff --git a/Volt/Sandbox/src/Sandbox/Sandbox.cpp b/Volt/Sandbox/src/Sandbox/Sandbox.cpp
index f78e58f8f..84eb642a3 100644
--- a/Volt/Sandbox/src/Sandbox/Sandbox.cpp
+++ b/Volt/Sandbox/src/Sandbox/Sandbox.cpp
@@ -90,6 +90,9 @@
 
 #include <imgui.h>
 
+#include "Volt/Asset/ImportersNew/SourceTextureSerializer.h"
+#include "Volt/Asset/ImportersNew/TextureSerializer.h"
+
 Sandbox::Sandbox()
 {
 	VT_ASSERT(!myInstance, "Sandbox already exists!");
@@ -101,6 +104,8 @@ Sandbox::~Sandbox()
 	myInstance = nullptr;
 }
 
+static Ref<Volt::Texture2D> tex;
+
 void Sandbox::OnAttach()
 {
 	SelectionManager::Init();
@@ -224,6 +229,20 @@ void Sandbox::OnAttach()
 
 	myRuntimeScene->InitializeEngineScripts();
 
+	Volt::AssetMetadata metadata;
+	Ref<Volt::SourceTextureSerializer> texSourceImporter = CreateRef<Volt::SourceTextureSerializer>();
+	metadata.filePath = "Assets/Player Test/CH_Player_01_MAT_C.dds";
+
+	Ref<Volt::Texture2D> sourceTex = CreateRef<Volt::Texture2D>();
+	texSourceImporter->Deserialize(metadata, sourceTex);
+
+	Ref<Volt::TextureSerializer> texSerializer = CreateRef<Volt::TextureSerializer>();
+	metadata.filePath = "Assets/Player Test/CH_Player_01_MAT_C.vtasset";
+	texSerializer->Serialize(metadata, sourceTex);
+
+	tex = CreateRef<Volt::Texture2D>();
+	texSerializer->Deserialize(metadata, tex);
+
 	m_isInitialized = true;
 }
 
@@ -880,6 +899,13 @@ bool Sandbox::OnImGuiUpdateEvent(Volt::AppImGuiUpdateEvent& e)
 		RenderProgressBar(buildProgess);
 	}
 
+	if (ImGui::Begin("Test"))
+	{
+		ImGui::Image(UI::GetTextureID(tex), { 512, 512 });
+
+		ImGui::End();
+	}
+
 	return false;
 }
 
diff --git a/Volt/Sandbox/src/Sandbox/Window/AssetBrowser/AssetBrowserPanel.cpp b/Volt/Sandbox/src/Sandbox/Window/AssetBrowser/AssetBrowserPanel.cpp
index 7101c3b77..53d8cd603 100644
--- a/Volt/Sandbox/src/Sandbox/Window/AssetBrowser/AssetBrowserPanel.cpp
+++ b/Volt/Sandbox/src/Sandbox/Window/AssetBrowser/AssetBrowserPanel.cpp
@@ -1638,7 +1638,9 @@ void AssetBrowserPanel::CreateNewShaderModal()
 				fout << out.c_str();
 				fout.close();
 
-				Ref<Volt::Shader> newShader = Volt::AssetManager::CreateAsset<Volt::Shader>(Volt::AssetManager::GetRelativePath(myCurrentDirectory->path), tempName + ".vtsdef", tempName, shaderPaths, false);
+				Ref<Volt::Shader> newShader = Volt::AssetManager::CreateAsset<Volt::Shader>(Volt::AssetManager::GetRelativePath(myCurrentDirectory->path), tempName + ".vtsdef");
+				newShader->Initialize(tempName, shaderPaths, false);
+
 				Volt::ShaderRegistry::Register(tempName, newShader);
 			}
 
diff --git a/Volt/Volt/src/Volt/Asset/Animation/AnimatedCharacter.h b/Volt/Volt/src/Volt/Asset/Animation/AnimatedCharacter.h
index 0936e4076..09b179fbf 100644
--- a/Volt/Volt/src/Volt/Asset/Animation/AnimatedCharacter.h
+++ b/Volt/Volt/src/Volt/Asset/Animation/AnimatedCharacter.h
@@ -67,6 +67,7 @@ namespace Volt
 
 	private:
 		friend class AnimatedCharacterImporter;
+		friend class AnimatedCharacterSerializer;
 
 		Ref<Skeleton> mySkeleton;
 		Ref<Mesh> mySkin;
diff --git a/Volt/Volt/src/Volt/Asset/Animation/Animation.h b/Volt/Volt/src/Volt/Asset/Animation/Animation.h
index 0f4d12a97..c4daeb2ae 100644
--- a/Volt/Volt/src/Volt/Asset/Animation/Animation.h
+++ b/Volt/Volt/src/Volt/Asset/Animation/Animation.h
@@ -2,6 +2,9 @@
 
 #include "Volt/Asset/Asset.h"
 
+#include "Volt/Utility/FileIO/BinaryStreamWriter.h"
+#include "Volt/Utility/FileIO/BinaryStreamReader.h"
+
 #include <glm/glm.hpp>
 
 namespace Volt
@@ -15,11 +18,35 @@ namespace Volt
 			glm::vec3 position = { 0.f };
 			glm::quat rotation = { 1.f, 0.f, 0.f, 0.f };
 			glm::vec3 scale = { 1.f };
+
+			static void Serialize(BinaryStreamWriter& streamWriter, const TRS& data)
+			{
+				streamWriter.Write(data.position);
+				streamWriter.Write(data.rotation);
+				streamWriter.Write(data.scale);
+			}
+
+			static void Deserialize(BinaryStreamReader& streamReader, TRS& outData)
+			{
+				streamReader.Read(outData.position);
+				streamReader.Read(outData.rotation);
+				streamReader.Read(outData.scale);
+			}
 		};
 
 		struct Pose
 		{
 			std::vector<TRS> localTRS;
+
+			static void Serialize(BinaryStreamWriter& streamWriter, const Pose& data)
+			{
+				streamWriter.WriteRaw(data.localTRS);
+			}
+
+			static void Deserialize(BinaryStreamReader& streamReader, Pose& outData)
+			{
+				streamReader.ReadRaw(outData.localTRS);
+			}
 		};
 
 		const std::vector<glm::mat4> Sample(float aStartTime, Ref<Skeleton> aSkeleton, bool looping);
@@ -51,6 +78,7 @@ namespace Volt
 
 		friend class FbxImporter;
 		friend class AnimationImporter;
+		friend class AnimationSerializer;
 
 		std::vector<Pose> myFrames;
 
diff --git a/Volt/Volt/src/Volt/Asset/Animation/AnimationGraphAsset.h b/Volt/Volt/src/Volt/Asset/Animation/AnimationGraphAsset.h
index 9daae894d..fecaf1006 100644
--- a/Volt/Volt/src/Volt/Asset/Animation/AnimationGraphAsset.h
+++ b/Volt/Volt/src/Volt/Asset/Animation/AnimationGraphAsset.h
@@ -42,6 +42,7 @@ namespace Volt
 		Ref<GraphKey::Node> GetRelevantAnimationNode();
 	private:
 		friend class AnimationGraphImporter;
+		friend class AnimationGraphSerializer;
 
 		AssetHandle mySkeletonHandle = Asset::Null();
 		std::string myGraphState;
diff --git a/Volt/Volt/src/Volt/Asset/Animation/Skeleton.h b/Volt/Volt/src/Volt/Asset/Animation/Skeleton.h
index 1a6b062ff..6308e6ce4 100644
--- a/Volt/Volt/src/Volt/Asset/Animation/Skeleton.h
+++ b/Volt/Volt/src/Volt/Asset/Animation/Skeleton.h
@@ -14,6 +14,18 @@ namespace Volt
 		{
 			std::string name;
 			int32_t parentIndex = -1;
+
+			static void Serialize(BinaryStreamWriter& streamWriter, const Joint& data)
+			{
+				streamWriter.Write(data.name);
+				streamWriter.Write(data.parentIndex);
+			}
+
+			static void Deserialize(BinaryStreamReader& streamReader, Joint& outData)
+			{
+				streamReader.Read(outData.name);
+				streamReader.Read(outData.parentIndex);
+			}
 		};
 
 		Skeleton() = default;
@@ -39,6 +51,7 @@ namespace Volt
 	private:
 		friend class FbxImporter;
 		friend class SkeletonImporter;
+		friend class SkeletonSerializer;
 
 		std::vector<Joint> myJoints;
 		std::vector<Animation::TRS> myRestPose;
diff --git a/Volt/Volt/src/Volt/Asset/Asset.h b/Volt/Volt/src/Volt/Asset/Asset.h
index 5522f532d..762fb01d0 100644
--- a/Volt/Volt/src/Volt/Asset/Asset.h
+++ b/Volt/Volt/src/Volt/Asset/Asset.h
@@ -14,7 +14,7 @@ namespace Volt
 {
 	using AssetHandle = UUID;
 
-	enum class AssetFlag : uint16_t
+	enum class AssetFlag : uint8_t
 	{
 		None = 0,
 		Missing = BIT(0),
@@ -22,7 +22,7 @@ namespace Volt
 		Queued = BIT(2)
 	};
 
-	enum class AssetType : uint32_t
+	enum class AssetType : uint64_t
 	{
 		None = 0,
 		Mesh = BIT(0),
@@ -206,7 +206,7 @@ namespace Volt
 	public:
 		virtual ~Asset() = default;
 
-		inline bool IsValid() const { return ((assetFlags & (uint16_t)AssetFlag::Missing) | (assetFlags & (uint16_t)AssetFlag::Invalid) | (assetFlags & (uint16_t)AssetFlag::Queued)) == 0; }
+		inline bool IsValid() const { return ((assetFlags & (uint8_t)AssetFlag::Missing) | (assetFlags & (uint8_t)AssetFlag::Invalid) | (assetFlags & (uint8_t)AssetFlag::Queued)) == 0; }
 
 		inline virtual bool operator==(const Asset& other)
 		{
@@ -218,16 +218,16 @@ namespace Volt
 			return !(*this == other);
 		}
 
-		inline bool IsFlagSet(AssetFlag flag) { return (assetFlags & (uint16_t)flag) != 0; }
+		inline bool IsFlagSet(AssetFlag flag) { return (assetFlags & (uint8_t)flag) != 0; }
 		inline void SetFlag(AssetFlag flag, bool state)
 		{
 			if (state)
 			{
-				assetFlags |= (uint16_t)flag;
+				assetFlags |= (uint8_t)flag;
 			}
 			else
 			{
-				assetFlags &= ~(uint16_t)flag;
+				assetFlags &= ~(uint8_t)flag;
 			}
 		}
 
@@ -235,8 +235,9 @@ namespace Volt
 
 		static AssetType GetStaticType() { return AssetType::None; }
 		virtual AssetType GetType() { assert(false); return AssetType::None; }
+		//virtual uint32_t GetVersion() = 0; // #TODO_Ivar: Implement
 
-		uint16_t assetFlags = (uint16_t)AssetFlag::None;
+		uint8_t assetFlags = (uint8_t)AssetFlag::None;
 		AssetHandle handle = {};
 		std::string assetName;
 	};
diff --git a/Volt/Volt/src/Volt/Asset/AssetManager.cpp b/Volt/Volt/src/Volt/Asset/AssetManager.cpp
index 98063cef0..541ffbf8d 100644
--- a/Volt/Volt/src/Volt/Asset/AssetManager.cpp
+++ b/Volt/Volt/src/Volt/Asset/AssetManager.cpp
@@ -47,22 +47,22 @@ namespace Volt
 		MeshTypeImporter::Initialize();
 		TextureImporter::Initialize();
 
-		m_assetImporters.emplace(AssetType::MeshSource, CreateScope<MeshSourceImporter>());
-		m_assetImporters.emplace(AssetType::Texture, CreateScope<TextureSourceImporter>());
-		m_assetImporters.emplace(AssetType::Shader, CreateScope<ShaderImporter>());
+		m_assetImporters.emplace(AssetType::MeshSource, CreateScope<MeshSourceImporter>()); // Done
+		m_assetImporters.emplace(AssetType::Texture, CreateScope<TextureSourceImporter>()); // Done
+		m_assetImporters.emplace(AssetType::Shader, CreateScope<ShaderImporter>()); // Done
 		m_assetImporters.emplace(AssetType::Material, CreateScope<MaterialImporter>());
-		m_assetImporters.emplace(AssetType::Mesh, CreateScope<MeshSourceImporter>());
-		m_assetImporters.emplace(AssetType::NavMesh, CreateScope<VTNavMeshImporter>());
-		m_assetImporters.emplace(AssetType::Scene, CreateScope<SceneImporter>());
-		m_assetImporters.emplace(AssetType::Skeleton, CreateScope<SkeletonImporter>());
-		m_assetImporters.emplace(AssetType::AnimationGraph, CreateScope<AnimationGraphImporter>());
-		m_assetImporters.emplace(AssetType::Animation, CreateScope<AnimationImporter>());
-		m_assetImporters.emplace(AssetType::AnimatedCharacter, CreateScope<AnimatedCharacterImporter>());
-		m_assetImporters.emplace(AssetType::ParticlePreset, CreateScope<ParticlePresetImporter>());
-		m_assetImporters.emplace(AssetType::Prefab, CreateScope<PrefabImporter>());
-		m_assetImporters.emplace(AssetType::Font, CreateScope<FontImporter>());
-		m_assetImporters.emplace(AssetType::PhysicsMaterial, CreateScope<PhysicsMaterialImporter>());
-		m_assetImporters.emplace(AssetType::Video, CreateScope<VideoImporter>());
+		m_assetImporters.emplace(AssetType::Mesh, CreateScope<MeshSourceImporter>()); // Done
+		m_assetImporters.emplace(AssetType::NavMesh, CreateScope<VTNavMeshImporter>()); // Done
+		m_assetImporters.emplace(AssetType::Scene, CreateScope<SceneImporter>()); // Done
+		m_assetImporters.emplace(AssetType::Skeleton, CreateScope<SkeletonImporter>()); // Done
+		m_assetImporters.emplace(AssetType::AnimationGraph, CreateScope<AnimationGraphImporter>()); // Done
+		m_assetImporters.emplace(AssetType::Animation, CreateScope<AnimationImporter>()); // Done
+		m_assetImporters.emplace(AssetType::AnimatedCharacter, CreateScope<AnimatedCharacterImporter>()); // Done
+		m_assetImporters.emplace(AssetType::ParticlePreset, CreateScope<ParticlePresetImporter>()); // Done
+		m_assetImporters.emplace(AssetType::Prefab, CreateScope<PrefabImporter>()); // Done
+		m_assetImporters.emplace(AssetType::Font, CreateScope<FontImporter>()); // Done
+		m_assetImporters.emplace(AssetType::PhysicsMaterial, CreateScope<PhysicsMaterialImporter>()); // Done
+		m_assetImporters.emplace(AssetType::Video, CreateScope<VideoImporter>()); // Done
 		m_assetImporters.emplace(AssetType::BehaviorGraph, CreateScope<BehaviorTreeImporter>());
 		m_assetImporters.emplace(AssetType::BlendSpace, CreateScope<BlendSpaceImporter>());
 		m_assetImporters.emplace(AssetType::PostProcessingStack, CreateScope<PostProcessingStackImporter>());
diff --git a/Volt/Volt/src/Volt/Asset/Importers/AssetImporter.cpp b/Volt/Volt/src/Volt/Asset/Importers/AssetImporter.cpp
index 93546a5a8..136d40427 100644
--- a/Volt/Volt/src/Volt/Asset/Importers/AssetImporter.cpp
+++ b/Volt/Volt/src/Volt/Asset/Importers/AssetImporter.cpp
@@ -602,7 +602,8 @@ namespace Volt
 			return false;
 		}
 
-		asset = CreateRef<Font>(filePath);
+		asset = CreateRef<Font>();
+		std::reinterpret_pointer_cast<Font>(asset)->Initialize(filePath);
 		return true;
 	}
 
@@ -685,7 +686,8 @@ namespace Volt
 			return false;
 		}
 
-		asset = CreateRef<Video>(filePath);
+		asset = CreateRef<Video>();
+		std::reinterpret_pointer_cast<Video>(asset)->Initialize(filePath);
 		return true;
 	}
 
diff --git a/Volt/Volt/src/Volt/Asset/Importers/VTNavMeshImporter.cpp b/Volt/Volt/src/Volt/Asset/Importers/VTNavMeshImporter.cpp
index 3857eef15..3be9662d8 100644
--- a/Volt/Volt/src/Volt/Asset/Importers/VTNavMeshImporter.cpp
+++ b/Volt/Volt/src/Volt/Asset/Importers/VTNavMeshImporter.cpp
@@ -28,14 +28,14 @@ namespace Volt
 		}
 
 		auto dtnm = CreateRef<dtNavMesh>();
-		if (!AI::NavMeshImporter::LoadNavMesh(file, dtnm))
-		{
-			return false;
-		}
+		//if (!AI::NavMeshImporter::LoadNavMesh(file, dtnm))
+		//{
+		//	return false;
+		//}
 
 		file.close();
 
-		asset = CreateRef<AI::NavMesh>(dtnm);
+		asset = CreateRef<AI::NavMesh>();
 		return true;
 	}
 
@@ -56,7 +56,7 @@ namespace Volt
 			return;
 		}
 
-		AI::NavMeshImporter::SaveNavMesh(output, navmesh);
+		//AI::NavMeshImporter::SaveNavMesh(output, navmesh);
 
 		output.close();
 	}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/AnimatedCharacterSerializer.cpp b/Volt/Volt/src/Volt/Asset/ImportersNew/AnimatedCharacterSerializer.cpp
new file mode 100644
index 000000000..0d461afcd
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/AnimatedCharacterSerializer.cpp
@@ -0,0 +1,206 @@
+#include "vtpch.h"
+#include "AnimatedCharacterSerializer.h"
+
+#include "Volt/Asset/AssetManager.h"
+#include "Volt/Asset/Animation/AnimatedCharacter.h"
+#include "Volt/Asset/Animation/Skeleton.h"
+
+namespace Volt
+{
+	constexpr uint32_t CURRENT_ASSET_VERSION = 1;
+
+	struct SerializedAnimationEvent
+	{
+		uint32_t frameIndex;
+		std::string name;
+
+		static void Serialize(BinaryStreamWriter& streamWriter, const SerializedAnimationEvent& data)
+		{
+			streamWriter.Write(data.frameIndex);
+			streamWriter.Write(data.name);
+		}
+
+		static void Deserialize(BinaryStreamReader& streamReader, SerializedAnimationEvent& outData)
+		{
+			streamReader.Read(outData.frameIndex);
+			streamReader.Read(outData.name);
+		}
+	};
+
+	struct SerializedJointAttachment
+	{
+		std::string name;
+		int32_t jointIndex;
+		UUID id;
+		glm::vec3 positionOffset;
+		glm::quat rotationOffset;
+
+		static void Serialize(BinaryStreamWriter& streamWriter, const SerializedJointAttachment& data)
+		{
+			streamWriter.Write(data.name);
+			streamWriter.Write(data.jointIndex);
+			streamWriter.Write(data.id);
+			streamWriter.Write(data.positionOffset);
+			streamWriter.Write(data.rotationOffset);
+		}
+
+		static void Deserialize(BinaryStreamReader& streamReader, SerializedJointAttachment& outData)
+		{
+			streamReader.Read(outData.name);
+			streamReader.Read(outData.jointIndex);
+			streamReader.Read(outData.id);
+			streamReader.Read(outData.positionOffset);
+			streamReader.Read(outData.rotationOffset);
+		}
+	};
+
+	struct SerializedAnimation
+	{
+		uint32_t index;
+		AssetHandle animationHandle;
+
+		std::vector<SerializedAnimationEvent> events;
+
+		static void Serialize(BinaryStreamWriter& streamWriter, const SerializedAnimation& data)
+		{
+			streamWriter.Write(data.index);
+			streamWriter.Write(data.animationHandle);
+			streamWriter.Write(data.events);
+		}
+
+		static void Deserialize(BinaryStreamReader& streamReader, SerializedAnimation& outData)
+		{
+			streamReader.Read(outData.index);
+			streamReader.Read(outData.animationHandle);
+			streamReader.Read(outData.events);
+		}
+	};
+
+	struct AnimatedCharacterSerializationData
+	{
+		AssetHandle skeletonHandle;
+		AssetHandle skinHandle;
+
+		std::vector<SerializedAnimation> animations;
+		std::vector<SerializedJointAttachment> jointAttachments;
+
+		static void Serialize(BinaryStreamWriter& streamWriter, const AnimatedCharacterSerializationData& data)
+		{
+			streamWriter.Write(data.skeletonHandle);
+			streamWriter.Write(data.skinHandle);
+			streamWriter.Write(data.animations);
+			streamWriter.Write(data.jointAttachments);
+		}
+
+		static void Deserialize(BinaryStreamReader& streamReader, AnimatedCharacterSerializationData& outData)
+		{
+			streamReader.Read(outData.skeletonHandle);
+			streamReader.Read(outData.skinHandle);
+			streamReader.Read(outData.animations);
+			streamReader.Read(outData.jointAttachments);
+		}
+	};
+
+	void AnimatedCharacterSerializer::Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const
+	{
+		Ref<AnimatedCharacter> character = std::reinterpret_pointer_cast<AnimatedCharacter>(asset);
+
+		AnimatedCharacterSerializationData serializationData{};
+		serializationData.skeletonHandle = character->mySkeleton ? character->mySkeleton->handle : Asset::Null();
+		serializationData.skinHandle = character->mySkin ? character->mySkin->handle : Asset::Null();
+		
+		serializationData.animations.reserve(character->myAnimations.size());
+		for (const auto& [index, anim] : character->myAnimations)
+		{
+			auto& serAnim = serializationData.animations.emplace_back();
+			serAnim.index = index;
+			serAnim.animationHandle = anim ? anim->handle : Asset::Null();
+
+			if (character->myAnimationEvents.contains(index))
+			{
+				serAnim.events.reserve(character->myAnimationEvents.at(index).size());
+				for (const auto& event : character->myAnimationEvents.at(index))
+				{
+					auto& serEvent = serAnim.events.emplace_back();
+					serEvent.name = event.name;
+					serEvent.frameIndex = event.frame;
+				}
+			}
+		}
+
+		serializationData.jointAttachments.reserve(character->myJointAttachments.size());
+		for (const auto& jntAttachment : character->myJointAttachments)
+		{
+			auto& serAttachment = serializationData.jointAttachments.emplace_back();
+			serAttachment.name = jntAttachment.name;
+			serAttachment.jointIndex = jntAttachment.jointIndex;
+			serAttachment.id = jntAttachment.id;
+			serAttachment.positionOffset = jntAttachment.positionOffset;
+			serAttachment.rotationOffset = jntAttachment.rotationOffset;
+		}
+
+		BinaryStreamWriter streamWriter{};
+		const size_t compressedDataOffset = AssetSerializer::WriteMetadata(metadata, CURRENT_ASSET_VERSION, streamWriter);
+		streamWriter.Write(serializationData);
+
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+		streamWriter.WriteToDisk(filePath, true, compressedDataOffset);
+	}
+
+	bool AnimatedCharacterSerializer::Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const
+	{
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+
+		if (!std::filesystem::exists(filePath))
+		{
+			VT_CORE_ERROR("File {0} not found!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Missing, true);
+			return false;
+		}
+
+		BinaryStreamReader streamReader{ filePath };
+
+		if (!streamReader.IsStreamValid())
+		{
+			VT_CORE_ERROR("Failed to open file: {0}!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Invalid, true);
+			return false;
+		}
+
+		SerializedAssetMetadata serializedMetadata = AssetSerializer::ReadMetadata(streamReader);
+
+		AnimatedCharacterSerializationData serializationData{};
+		streamReader.Read(serializationData);
+
+		Ref<AnimatedCharacter> character = std::reinterpret_pointer_cast<AnimatedCharacter>(destinationAsset);
+		character->mySkeleton = AssetManager::QueueAsset<Skeleton>(serializationData.skeletonHandle);
+		character->mySkin = AssetManager::QueueAsset<Mesh>(serializationData.skinHandle);
+
+		for (const auto& serAnim : serializationData.animations)
+		{
+			for (const auto& serEvent : serAnim.events)
+			{
+				auto& newEvent = character->myAnimationEvents[serAnim.index].emplace_back();
+				newEvent.name = serEvent.name;
+				newEvent.frame = serEvent.frameIndex;
+			}
+
+			if (serAnim.index != std::numeric_limits<uint32_t>::max() && serAnim.animationHandle != Asset::Null())
+			{
+				character->myAnimations[serAnim.index] = AssetManager::QueueAsset<Animation>(serAnim.animationHandle);
+			}
+		}
+
+		for (const auto& serJntAttachment : serializationData.jointAttachments)
+		{
+			auto& newAttachment = character->myJointAttachments.emplace_back();
+			newAttachment.name = serJntAttachment.name;
+			newAttachment.jointIndex = serJntAttachment.jointIndex;
+			newAttachment.id = serJntAttachment.id;
+			newAttachment.positionOffset = serJntAttachment.positionOffset;
+			newAttachment.rotationOffset = serJntAttachment.rotationOffset;
+		}
+
+		return true;
+	}
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/AnimatedCharacterSerializer.h b/Volt/Volt/src/Volt/Asset/ImportersNew/AnimatedCharacterSerializer.h
new file mode 100644
index 000000000..c275464b0
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/AnimatedCharacterSerializer.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Volt/Asset/ImportersNew/AssetSerializer.h"
+
+namespace Volt
+{
+	class AnimatedCharacterSerializer : public AssetSerializer
+	{
+	public:
+		void Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const override;
+		bool Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const override;
+	};
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/AnimationGraphSerializer.cpp b/Volt/Volt/src/Volt/Asset/ImportersNew/AnimationGraphSerializer.cpp
new file mode 100644
index 000000000..e0c3229f4
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/AnimationGraphSerializer.cpp
@@ -0,0 +1,85 @@
+#include "vtpch.h"
+#include "AnimationGraphSerializer.h"
+
+#include "Volt/Asset/Animation/AnimationGraphAsset.h"
+#include "Volt/Asset/AssetManager.h"
+#include "Volt/Utility/FileIO/YAMLMemoryStreamWriter.h"
+#include "Volt/Utility/FileIO/YAMLMemoryStreamReader.h"
+
+namespace Volt
+{
+	constexpr uint32_t CURRENT_ASSET_VERSION = 1;
+
+	void AnimationGraphSerializer::Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const
+	{
+		const Ref<AnimationGraphAsset> animGraph = std::reinterpret_pointer_cast<AnimationGraphAsset>(asset);
+
+		YAMLMemoryStreamWriter yamlStreamWriter;
+		yamlStreamWriter.BeginMap();
+		yamlStreamWriter.BeginMapNamned("AnimationGraph");
+
+		yamlStreamWriter.SetKey("state", animGraph->myGraphState);
+		yamlStreamWriter.SetKey("skeleton", animGraph->mySkeletonHandle);
+
+		GraphKey::Graph::Serialize(animGraph, yamlStreamWriter.GetEmitter());
+
+		yamlStreamWriter.EndMap();
+		yamlStreamWriter.EndMap();
+
+		BinaryStreamWriter streamWriter{};
+		const size_t compressedDataOffset = AssetSerializer::WriteMetadata(metadata, CURRENT_ASSET_VERSION, streamWriter);
+
+		Buffer buffer = yamlStreamWriter.WriteAndGetBuffer();
+		streamWriter.Write(buffer);
+		buffer.Release();
+
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+		streamWriter.WriteToDisk(filePath, true, compressedDataOffset);
+	}
+
+	bool AnimationGraphSerializer::Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const
+	{
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+
+		if (!std::filesystem::exists(filePath))
+		{
+			VT_CORE_ERROR("File {0} not found!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Missing, true);
+			return false;
+		}
+
+		BinaryStreamReader streamReader{ filePath };
+
+		if (!streamReader.IsStreamValid())
+		{
+			VT_CORE_ERROR("Failed to open file: {0}!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Invalid, true);
+			return false;
+		}
+
+		SerializedAssetMetadata serializedMetadata = AssetSerializer::ReadMetadata(streamReader);
+
+		Buffer yamlBuffer{};
+		streamReader.Read(yamlBuffer);
+
+		YAMLMemoryStreamReader yamlStreamReader{};
+		yamlStreamReader.ConsumeBuffer(yamlBuffer);
+
+		Ref<AnimationGraphAsset> animGraph = std::reinterpret_pointer_cast<AnimationGraphAsset>(destinationAsset);
+		
+		yamlStreamReader.EnterScope("AnimationGraph");
+		animGraph->myGraphState = yamlStreamReader.ReadKey("state", std::string(""));
+		animGraph->mySkeletonHandle = yamlStreamReader.ReadKey("skeleton", AssetHandle(0));
+
+		yamlStreamReader.EnterScope("Graph");
+		GraphKey::Graph::Deserialize(animGraph, yamlStreamReader.GetCurrentNode());
+		yamlStreamReader.ExitScope();
+
+		yamlStreamReader.ExitScope();
+
+		// Necessary to set up the skeleton correctly
+		animGraph->SetSkeletonHandle(animGraph->mySkeletonHandle);
+
+		return true;
+	}
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/AnimationGraphSerializer.h b/Volt/Volt/src/Volt/Asset/ImportersNew/AnimationGraphSerializer.h
new file mode 100644
index 000000000..585fbaaa4
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/AnimationGraphSerializer.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Volt/Asset/ImportersNew/AnimationSerializer.h"
+
+namespace Volt
+{
+	class AnimationGraphSerializer : public AssetSerializer
+	{
+	public:
+		void Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const override;
+		bool Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const override;
+	};
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/AnimationSerializer.cpp b/Volt/Volt/src/Volt/Asset/ImportersNew/AnimationSerializer.cpp
new file mode 100644
index 000000000..f00333bd2
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/AnimationSerializer.cpp
@@ -0,0 +1,83 @@
+#include "vtpch.h"
+#include "AnimationSerializer.h"
+
+#include "Volt/Asset/AssetManager.h"
+#include "Volt/Asset/Animation/Animation.h"
+
+namespace Volt
+{
+	constexpr uint32_t CURRENT_ASSET_VERSION = 1;
+
+	struct AnimationSerializationData
+	{
+		float duration;
+		uint32_t framesPerSecond;
+		std::vector<Animation::Pose> frames;
+
+		static void Serialize(BinaryStreamWriter& streamWriter, const AnimationSerializationData& data)
+		{
+			streamWriter.Write(data.duration);
+			streamWriter.Write(data.framesPerSecond);
+			streamWriter.Write(data.frames);
+		}
+
+		static void Deserialize(BinaryStreamReader& streamReader, AnimationSerializationData& outData)
+		{
+			streamReader.Read(outData.duration);
+			streamReader.Read(outData.framesPerSecond);
+			streamReader.Read(outData.frames);
+		}
+	};
+
+	void AnimationSerializer::Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const
+	{
+		Ref<Animation> animation = std::reinterpret_pointer_cast<Animation>(asset);
+
+		BinaryStreamWriter streamWriter{};
+
+		AnimationSerializationData serializationData{};
+		serializationData.duration = animation->myDuration;
+		serializationData.framesPerSecond = animation->myFramesPerSecond;
+		serializationData.frames = animation->myFrames;
+	
+		const size_t compressedDataOffset = AssetSerializer::WriteMetadata(metadata, CURRENT_ASSET_VERSION, streamWriter);
+		streamWriter.Write(serializationData);
+
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+		streamWriter.WriteToDisk(filePath, true, compressedDataOffset);
+	}
+
+	bool AnimationSerializer::Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const
+	{
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+
+		if (!std::filesystem::exists(filePath))
+		{
+			VT_CORE_ERROR("File {0} not found!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Missing, true);
+			return false;
+		}
+
+		BinaryStreamReader streamReader{ filePath };
+
+		if (!streamReader.IsStreamValid())
+		{
+			VT_CORE_ERROR("Failed to open file: {0}!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Invalid, true);
+			return false;
+		}
+
+		SerializedAssetMetadata serializedMetadata = AssetSerializer::ReadMetadata(streamReader);
+
+		AnimationSerializationData serializationData{};
+		streamReader.Read(serializationData);
+
+		Ref<Animation> animation = std::reinterpret_pointer_cast<Animation>(destinationAsset);
+
+		animation->myDuration = serializationData.duration;
+		animation->myFramesPerSecond = serializationData.framesPerSecond;
+		animation->myFrames = serializationData.frames;
+
+		return true;
+	}
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/AnimationSerializer.h b/Volt/Volt/src/Volt/Asset/ImportersNew/AnimationSerializer.h
new file mode 100644
index 000000000..1285f2e77
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/AnimationSerializer.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Volt/Asset/ImportersNew/AssetSerializer.h"
+
+namespace Volt
+{
+	class AnimationSerializer : public AssetSerializer
+	{
+	public:
+		void Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const override;
+		bool Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const override;
+	};
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/FontSerializer.cpp b/Volt/Volt/src/Volt/Asset/ImportersNew/FontSerializer.cpp
new file mode 100644
index 000000000..2b5b9bb4a
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/FontSerializer.cpp
@@ -0,0 +1,30 @@
+#include "vtpch.h"
+#include "FontSerializer.h"
+
+#include "Volt/Asset/AssetManager.h"
+#include "Volt/Asset/Text/Font.h"
+
+namespace Volt
+{
+	void FontSerializer::Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const
+	{
+		VT_CORE_ASSERT(false, "[FontSerializer]: Asset it not serializable");
+	}
+
+	bool FontSerializer::Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const
+	{
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+
+		if (!std::filesystem::exists(filePath))
+		{
+			VT_CORE_ERROR("File {0} not found!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Missing, true);
+			return false;
+		}
+
+		Ref<Font> font = std::reinterpret_pointer_cast<Font>(destinationAsset);
+		font->Initialize(filePath);
+
+		return true;
+	}
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/FontSerializer.h b/Volt/Volt/src/Volt/Asset/ImportersNew/FontSerializer.h
new file mode 100644
index 000000000..e3ddbfa03
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/FontSerializer.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Volt/Asset/ImportersNew/AssetSerializer.h"
+
+namespace Volt
+{
+	class FontSerializer : public AssetSerializer
+	{
+	public:
+		void Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const override;
+		bool Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const override;
+	};
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/MeshSerializer.cpp b/Volt/Volt/src/Volt/Asset/ImportersNew/MeshSerializer.cpp
index 58b5977bf..6ea4023ae 100644
--- a/Volt/Volt/src/Volt/Asset/ImportersNew/MeshSerializer.cpp
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/MeshSerializer.cpp
@@ -62,7 +62,7 @@ namespace Volt
 		streamWriter.Write(serializationData);
 
 		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
-		streamWriter.WriteToDisk(filePath, false, compressedDataOffset);
+		streamWriter.WriteToDisk(filePath, true, compressedDataOffset);
 	}
 
 	bool MeshSerializer::Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/NavigationMeshSerializer.cpp b/Volt/Volt/src/Volt/Asset/ImportersNew/NavigationMeshSerializer.cpp
new file mode 100644
index 000000000..b048f25c0
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/NavigationMeshSerializer.cpp
@@ -0,0 +1,56 @@
+#include "vtpch.h"
+#include "NavigationMeshSerializer.h"
+
+#include "Volt/Asset/AssetManager.h"
+
+#include <Navigation/Core/NavigationSystem.h>
+#include <Navigation/Filesystem/NavMeshImporter.h>
+
+namespace Volt
+{
+	constexpr uint32_t CURRENT_ASSET_VERSION = 1;
+
+	void NavigationMeshSerializer::Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const
+	{
+		Ref<AI::NavMesh> navMesh = std::reinterpret_pointer_cast<AI::NavMesh>(asset);
+
+		BinaryStreamWriter streamWriter{};
+		const size_t compressedDataOffset = AssetSerializer::WriteMetadata(metadata, CURRENT_ASSET_VERSION, streamWriter);
+
+		AI::NavMeshImporter::SaveNavMesh(streamWriter, navMesh);
+
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+		streamWriter.WriteToDisk(filePath, true, compressedDataOffset);
+	}
+
+	bool NavigationMeshSerializer::Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const
+	{
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+
+		if (!std::filesystem::exists(filePath))
+		{
+			VT_CORE_ERROR("File {0} not found!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Missing, true);
+			return false;
+		}
+
+		BinaryStreamReader streamReader{ filePath };
+
+		if (!streamReader.IsStreamValid())
+		{
+			VT_CORE_ERROR("Failed to open file: {0}!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Invalid, true);
+			return false;
+		}
+
+		SerializedAssetMetadata serializedMetadata = AssetSerializer::ReadMetadata(streamReader);
+
+		auto dtnm = CreateRef<dtNavMesh>();
+		AI::NavMeshImporter::LoadNavMesh(streamReader, dtnm);
+
+		Ref<AI::NavMesh> navMesh = std::reinterpret_pointer_cast<AI::NavMesh>(destinationAsset);
+		navMesh->Initialize(dtnm);
+
+		return true;
+	}
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/NavigationMeshSerializer.h b/Volt/Volt/src/Volt/Asset/ImportersNew/NavigationMeshSerializer.h
new file mode 100644
index 000000000..9d3931655
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/NavigationMeshSerializer.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Volt/Asset/ImportersNew/AssetSerializer.h"
+
+namespace Volt
+{
+	class NavigationMeshSerializer : public AssetSerializer
+	{
+	public:
+		void Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const override;
+		bool Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const override;
+	};
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/ParticlePresetSerializer.cpp b/Volt/Volt/src/Volt/Asset/ImportersNew/ParticlePresetSerializer.cpp
new file mode 100644
index 000000000..f1bbb59ec
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/ParticlePresetSerializer.cpp
@@ -0,0 +1,232 @@
+#include "vtpch.h"
+#include "ParticlePresetSerializer.h"
+
+#include "Volt/Asset/AssetManager.h"
+#include "Volt/Asset/ParticlePreset.h"
+
+namespace Volt
+{
+	constexpr uint32_t CURRENT_ASSET_VERSION = 1;
+
+	struct ParticlePresetSerializationData
+	{
+		bool looping;
+		float emittionTime;
+		float intensity;
+		float minLifetime;
+		float maxLifetime;
+
+		AssetHandle textureHandle;
+		AssetHandle materialHandle;
+
+		glm::vec3 direction;
+		glm::vec3 gravity;
+
+		uint32_t shape;
+		float coneInnerRadius;
+		float coneOuterRadius;
+		bool coneSpawnOnEdge;
+
+		float sphereRadius;
+		bool sphereSpawnOnEdge;
+
+		float startVelocity;
+		float endVelocity;
+
+		std::vector<glm::vec3> sizes;
+
+		bool isBurst;
+		float burstInterval;
+		float burstLength;
+
+		AssetHandle meshHandle;
+		AssetHandle meshMaterial;
+		ParticlePreset::eType type;
+
+		std::vector<glm::vec4> colors;
+	
+		static void Serialize(BinaryStreamWriter& streamWriter, const ParticlePresetSerializationData& data)
+		{
+			streamWriter.Write(data.looping);
+			streamWriter.Write(data.emittionTime);
+			streamWriter.Write(data.intensity);
+			streamWriter.Write(data.minLifetime);
+			streamWriter.Write(data.maxLifetime);
+			streamWriter.Write(data.textureHandle);
+			streamWriter.Write(data.materialHandle);
+			streamWriter.Write(data.direction);
+			streamWriter.Write(data.gravity);
+			streamWriter.Write(data.shape);
+			streamWriter.Write(data.coneInnerRadius);
+			streamWriter.Write(data.coneOuterRadius);
+			streamWriter.Write(data.coneSpawnOnEdge);
+			streamWriter.Write(data.sphereRadius);
+			streamWriter.Write(data.sphereSpawnOnEdge);
+			streamWriter.Write(data.startVelocity);
+			streamWriter.Write(data.endVelocity);
+			streamWriter.Write(data.sizes);
+			streamWriter.Write(data.isBurst);
+			streamWriter.Write(data.burstInterval);
+			streamWriter.Write(data.burstLength);
+			streamWriter.Write(data.meshHandle);
+			streamWriter.Write(data.meshMaterial);
+			streamWriter.Write(data.type);
+			streamWriter.Write(data.colors);
+		}
+
+		static void Deserialize(BinaryStreamReader& streamReader, ParticlePresetSerializationData& outData)
+		{
+			streamReader.Read(outData.looping);
+			streamReader.Read(outData.emittionTime);
+			streamReader.Read(outData.intensity);
+			streamReader.Read(outData.minLifetime);
+			streamReader.Read(outData.maxLifetime);
+			streamReader.Read(outData.textureHandle);
+			streamReader.Read(outData.materialHandle);
+			streamReader.Read(outData.direction);
+			streamReader.Read(outData.gravity);
+			streamReader.Read(outData.shape);
+			streamReader.Read(outData.coneInnerRadius);
+			streamReader.Read(outData.coneOuterRadius);
+			streamReader.Read(outData.coneSpawnOnEdge);
+			streamReader.Read(outData.sphereRadius);
+			streamReader.Read(outData.sphereSpawnOnEdge);
+			streamReader.Read(outData.startVelocity);
+			streamReader.Read(outData.endVelocity);
+			streamReader.Read(outData.sizes);
+			streamReader.Read(outData.isBurst);
+			streamReader.Read(outData.burstInterval);
+			streamReader.Read(outData.burstLength);
+			streamReader.Read(outData.meshHandle);
+			streamReader.Read(outData.meshMaterial);
+			streamReader.Read(outData.type);
+			streamReader.Read(outData.colors);
+		}
+	};
+
+	void ParticlePresetSerializer::Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const
+	{
+		Ref<ParticlePreset> particlePreset = std::reinterpret_pointer_cast<ParticlePreset>(asset);
+
+		ParticlePresetSerializationData serializationData{};
+		serializationData.looping = particlePreset->isLooping;
+		serializationData.emittionTime = particlePreset->emittionTime;
+
+		serializationData.intensity = particlePreset->intensity;
+		serializationData.minLifetime = particlePreset->minLifeTime;
+		serializationData.maxLifetime = particlePreset->maxLifeTime;
+
+		serializationData.textureHandle = particlePreset->texture;
+		serializationData.materialHandle = particlePreset->material;
+
+		serializationData.direction = particlePreset->direction;
+		serializationData.gravity = particlePreset->gravity;
+		
+		serializationData.shape = particlePreset->shape;
+		serializationData.coneInnerRadius = particlePreset->coneInnerRadius;
+		serializationData.coneOuterRadius = particlePreset->coneOuterRadius;
+		serializationData.coneSpawnOnEdge = particlePreset->coneSpawnOnEdge;
+
+		serializationData.sphereRadius = particlePreset->sphereRadius;
+		serializationData.sphereSpawnOnEdge = particlePreset->sphereSpawnOnEdge;
+
+		serializationData.startVelocity = particlePreset->startVelocity;
+		serializationData.endVelocity = particlePreset->endVelocity;
+
+		serializationData.sizes = particlePreset->sizes;
+
+		serializationData.isBurst = particlePreset->isBurst;
+		serializationData.burstInterval = particlePreset->burstInterval;
+		serializationData.burstLength = particlePreset->burstLength;
+		
+		serializationData.meshHandle = particlePreset->mesh;
+		serializationData.meshMaterial = particlePreset->material;
+		serializationData.type = particlePreset->type;
+
+		serializationData.colors = particlePreset->colors;
+
+		BinaryStreamWriter streamWriter{};
+		const size_t compressedDataOffset = AssetSerializer::WriteMetadata(metadata, CURRENT_ASSET_VERSION, streamWriter);
+
+		streamWriter.Write(serializationData);
+
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+		streamWriter.WriteToDisk(filePath, true, compressedDataOffset);
+	}
+
+	bool ParticlePresetSerializer::Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const
+	{
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+
+		if (!std::filesystem::exists(filePath))
+		{
+			VT_CORE_ERROR("File {0} not found!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Missing, true);
+			return false;
+		}
+
+		BinaryStreamReader streamReader{ filePath };
+
+		if (!streamReader.IsStreamValid())
+		{
+			VT_CORE_ERROR("Failed to open file: {0}!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Invalid, true);
+			return false;
+		}
+
+		SerializedAssetMetadata serializedMetadata = AssetSerializer::ReadMetadata(streamReader);
+
+		ParticlePresetSerializationData serializationData{};
+		streamReader.Read(serializationData);
+
+		Ref<ParticlePreset> preset = std::reinterpret_pointer_cast<ParticlePreset>(destinationAsset);
+
+		preset->isLooping = serializationData.looping;
+		preset->emittionTime = serializationData.emittionTime;
+
+		preset->intensity = serializationData.intensity;
+		preset->minLifeTime = serializationData.minLifetime;
+		preset->maxLifeTime = serializationData.maxLifetime;
+
+		preset->texture = serializationData.textureHandle;
+		preset->material = serializationData.materialHandle;
+		
+		preset->direction = serializationData.direction;
+		preset->gravity = serializationData.gravity;
+		
+		preset->shape = serializationData.shape;
+		preset->coneInnerRadius = serializationData.coneInnerRadius;
+		preset->coneOuterRadius = serializationData.coneOuterRadius;
+		preset->coneSpawnOnEdge = serializationData.coneSpawnOnEdge;
+		
+		preset->sphereRadius = serializationData.sphereRadius;
+		preset->sphereSpawnOnEdge = serializationData.sphereSpawnOnEdge;
+		
+		preset->startVelocity = serializationData.startVelocity;
+		preset->endVelocity = serializationData.endVelocity;
+
+		preset->colors = serializationData.colors;
+
+		preset->isBurst = serializationData.isBurst;
+		preset->burstInterval = serializationData.burstInterval;
+		preset->burstLength = serializationData.burstLength;
+
+		preset->mesh = serializationData.meshHandle;
+		preset->material = serializationData.materialHandle;
+
+		preset->type = serializationData.type;
+
+		preset->sizes = serializationData.sizes;
+
+		if (preset->colors.size() == 0)
+		{
+			preset->colors.push_back({ 1, 0, 0, 1 });
+		}
+		if (preset->sizes.size() == 0)
+		{
+			preset->sizes.push_back({ 0.1f, 0.1f, 0.1f });
+		}
+
+		return true;
+	}
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/ParticlePresetSerializer.h b/Volt/Volt/src/Volt/Asset/ImportersNew/ParticlePresetSerializer.h
new file mode 100644
index 000000000..b0e04f84a
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/ParticlePresetSerializer.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Volt/Asset/ImportersNew/AssetSerializer.h"
+
+namespace Volt
+{
+	class ParticlePresetSerializer : public AssetSerializer
+	{
+	public:
+		void Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const override;
+		bool Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const override;
+	};
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/PhysicsMaterialSerializer.cpp b/Volt/Volt/src/Volt/Asset/ImportersNew/PhysicsMaterialSerializer.cpp
new file mode 100644
index 000000000..8b86a050c
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/PhysicsMaterialSerializer.cpp
@@ -0,0 +1,68 @@
+#include "vtpch.h"
+#include "PhysicsMaterialSerializer.h"
+
+#include "Volt/Asset/AssetManager.h"
+#include "Volt/Physics/PhysicsMaterial.h"
+
+namespace Volt
+{
+	constexpr uint32_t CURRENT_ASSET_VERSION = 1;
+
+	struct PhysicsMaterialSerializationData
+	{
+		float staticFriction;
+		float dynamicFriction;
+		float bounciness;
+	};
+
+	void PhysicsMaterialSerializer::Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const
+	{
+		Ref<PhysicsMaterial> material = std::reinterpret_pointer_cast<PhysicsMaterial>(asset);
+
+		BinaryStreamWriter streamWriter{};
+		const size_t compressedDataOffset = AssetSerializer::WriteMetadata(metadata, CURRENT_ASSET_VERSION, streamWriter);
+
+		PhysicsMaterialSerializationData serializationData{};
+		serializationData.staticFriction = material->staticFriction;
+		serializationData.dynamicFriction = material->dynamicFriction;
+		serializationData.bounciness = material->bounciness;
+
+		streamWriter.Write(serializationData);
+
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+		streamWriter.WriteToDisk(filePath, true, compressedDataOffset);
+	}
+
+	bool PhysicsMaterialSerializer::Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const
+	{
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+
+		if (!std::filesystem::exists(filePath))
+		{
+			VT_CORE_ERROR("File {0} not found!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Missing, true);
+			return false;
+		}
+
+		BinaryStreamReader streamReader{ filePath };
+
+		if (!streamReader.IsStreamValid())
+		{
+			VT_CORE_ERROR("Failed to open file: {0}!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Invalid, true);
+			return false;
+		}
+
+		SerializedAssetMetadata serializedMetadata = AssetSerializer::ReadMetadata(streamReader);
+
+		PhysicsMaterialSerializationData serializationData{};
+		streamReader.Read(serializationData);
+
+		Ref<PhysicsMaterial> physicsMat = std::reinterpret_pointer_cast<PhysicsMaterial>(destinationAsset);
+		physicsMat->staticFriction = serializationData.staticFriction;
+		physicsMat->dynamicFriction = serializationData.dynamicFriction;
+		physicsMat->bounciness = serializationData.bounciness;
+
+		return true;
+	}
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/PhysicsMaterialSerializer.h b/Volt/Volt/src/Volt/Asset/ImportersNew/PhysicsMaterialSerializer.h
new file mode 100644
index 000000000..fe9f36ccc
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/PhysicsMaterialSerializer.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Volt/Asset/ImportersNew/AssetSerializer.h"
+
+namespace Volt
+{
+	class PhysicsMaterialSerializer : public AssetSerializer
+	{
+	public:
+		void Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const override;
+		bool Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const override;
+	};
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/PrefabSerializer.cpp b/Volt/Volt/src/Volt/Asset/ImportersNew/PrefabSerializer.cpp
new file mode 100644
index 000000000..ef858aa09
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/PrefabSerializer.cpp
@@ -0,0 +1,134 @@
+#include "vtpch.h"
+#include "PrefabSerializer.h"
+
+#include "Volt/Asset/AssetManager.h"
+#include "Volt/Asset/Prefab.h"
+
+#include "Volt/Asset/ImportersNew/SceneSerializer.h"
+
+#include "Volt/Utility/FileIO/YAMLMemoryStreamWriter.h"
+#include "Volt/Utility/FileIO/YAMLMemoryStreamReader.h"
+
+namespace Volt
+{
+	constexpr uint32_t CURRENT_ASSET_VERSION = 1;
+
+	PrefabSerializer::PrefabSerializer()
+	{
+		s_instance = this;
+	}
+
+	PrefabSerializer::~PrefabSerializer()
+	{
+		s_instance = nullptr;
+	}
+
+	void PrefabSerializer::Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const
+	{
+		const Ref<Prefab> prefab = std::reinterpret_pointer_cast<Prefab>(asset);
+
+		YAMLMemoryStreamWriter yamlStreamWriter{};
+		yamlStreamWriter.BeginMap();
+		yamlStreamWriter.BeginMapNamned("Prefab");
+
+		yamlStreamWriter.SetKey("version", prefab->m_version);
+		yamlStreamWriter.SetKey("rootEntityId", prefab->m_rootEntityId);
+
+		yamlStreamWriter.BeginSequence("Entities");
+		{
+			for (const auto id : prefab->m_prefabScene->GetAllEntities())
+			{
+				SceneSerializer::Get().SerializeEntity(id, metadata, prefab->m_prefabScene, yamlStreamWriter);
+			}
+		}
+		yamlStreamWriter.EndSequence();
+
+		yamlStreamWriter.BeginSequence("PrefabReferences");
+		{
+			for (const auto& ref : prefab->m_prefabReferencesMap)
+			{
+				yamlStreamWriter.BeginMap();
+				yamlStreamWriter.SetKey("entity", ref.first);
+				yamlStreamWriter.SetKey("prefabHandle", ref.second.prefabAsset);
+				yamlStreamWriter.SetKey("orefabEntityReference", ref.second.prefabReferenceEntity);
+				yamlStreamWriter.EndMap();
+			}
+		}
+		yamlStreamWriter.EndSequence();
+
+		yamlStreamWriter.EndMap();
+		yamlStreamWriter.EndMap();
+
+		BinaryStreamWriter streamWriter{};
+		const size_t compressedDataOffset = AssetSerializer::WriteMetadata(metadata, CURRENT_ASSET_VERSION, streamWriter);
+
+		Buffer buffer = yamlStreamWriter.WriteAndGetBuffer();
+		streamWriter.Write(buffer);
+		buffer.Release();
+
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+		streamWriter.WriteToDisk(filePath, true, compressedDataOffset);
+	}
+
+	bool PrefabSerializer::Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const
+	{
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+
+		if (!std::filesystem::exists(filePath))
+		{
+			VT_CORE_ERROR("File {0} not found!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Missing, true);
+			return false;
+		}
+
+		BinaryStreamReader streamReader{ filePath };
+
+		if (!streamReader.IsStreamValid())
+		{
+			VT_CORE_ERROR("Failed to open file: {0}!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Invalid, true);
+			return false;
+		}
+
+		SerializedAssetMetadata serializedMetadata = AssetSerializer::ReadMetadata(streamReader);
+
+		Buffer buffer{};
+		streamReader.Read(buffer);
+
+		YAMLMemoryStreamReader yamlStreamReader{};
+		if (!yamlStreamReader.ConsumeBuffer(buffer))
+		{
+			destinationAsset->SetFlag(AssetFlag::Invalid, true);
+			return false;
+		}
+
+		Ref<Prefab> prefab = std::reinterpret_pointer_cast<Prefab>(destinationAsset);
+		Ref<Scene> prefabScene = CreateRef<Scene>();
+
+		yamlStreamReader.EnterScope("Prefab");
+		{
+			prefab->m_version = yamlStreamReader.ReadKey("version", uint32_t(0));
+			prefab->m_rootEntityId = yamlStreamReader.ReadKey("rootEntityId", Entity::NullID());
+
+			yamlStreamReader.ForEach("Entities", [&]() 
+			{
+				SceneSerializer::Get().DeserializeEntity(prefabScene, metadata, yamlStreamReader);
+			});
+
+			yamlStreamReader.ForEach("PrefabReferences", [&]() 
+			{
+				EntityID entityId = yamlStreamReader.ReadKey("entity", Entity::NullID());
+				AssetHandle prefabHandle = yamlStreamReader.ReadKey("prefabHandle", Asset::Null());
+				EntityID prefabEntityReference = yamlStreamReader.ReadKey("prefabEntityReferences", Entity::NullID());
+
+				auto& prefabRefData = prefab->m_prefabReferencesMap[entityId];
+				prefabRefData.prefabAsset = prefabHandle;
+				prefabRefData.prefabReferenceEntity = prefabEntityReference;
+			});
+		}
+		yamlStreamReader.ExitScope();
+
+		prefab->m_prefabScene = prefabScene;
+		return true;
+	}
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/PrefabSerializer.h b/Volt/Volt/src/Volt/Asset/ImportersNew/PrefabSerializer.h
new file mode 100644
index 000000000..b9aadd646
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/PrefabSerializer.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "Volt/Asset/ImportersNew/AssetSerializer.h"
+
+namespace Volt
+{
+	class PrefabSerializer : public	AssetSerializer
+	{
+	public:
+		PrefabSerializer();
+		~PrefabSerializer() override;
+
+		void Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const override;
+		bool Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const override;
+
+	private:
+		inline static PrefabSerializer* s_instance = nullptr;
+	};
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/SceneSerializer.cpp b/Volt/Volt/src/Volt/Asset/ImportersNew/SceneSerializer.cpp
index 7cf5be0b0..69e7f2b9c 100644
--- a/Volt/Volt/src/Volt/Asset/ImportersNew/SceneSerializer.cpp
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/SceneSerializer.cpp
@@ -20,7 +20,7 @@
 #include "Volt/Utility/FileSystem.h"
 
 #include "Volt/Utility/FileIO/YAMLMemoryStreamWriter.h"
-#include "Volt/Utility/FileIO/YAMLFileStreamReader.h"
+#include "Volt/Utility/FileIO/YAMLMemoryStreamReader.h"
 
 namespace Volt
 {
@@ -40,11 +40,11 @@ namespace Volt
 	}
 
 	template<typename T>
-	void RegisterDeserializationFunction(std::unordered_map<std::type_index, std::function<void(YAMLFileStreamReader&, uint8_t*, const size_t)>>& outTypes)
+	void RegisterDeserializationFunction(std::unordered_map<std::type_index, std::function<void(YAMLMemoryStreamReader&, uint8_t*, const size_t)>>& outTypes)
 	{
 		VT_PROFILE_FUNCTION();
 
-		outTypes[std::type_index{ typeid(T) }] = [](YAMLFileStreamReader& streamReader, uint8_t* data, const size_t offset)
+		outTypes[std::type_index{ typeid(T) }] = [](YAMLMemoryStreamReader& streamReader, uint8_t* data, const size_t offset)
 		{
 			*reinterpret_cast<T*>(&data[offset]) = streamReader.ReadKey("data", T());
 		};
@@ -172,10 +172,7 @@ namespace Volt
 			sceneFileWriter.WriteToDisk(scenePath, true, compressedDataOffset);
 		}
 
-		if (scene->m_sceneSettings.useWorldEngine)
-		{
-			SerializeEntities(metadata, scene, directoryPath);
-		}
+		SerializeEntities(metadata, scene, directoryPath);
 	}
 
 	bool SceneSerializer::Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const
@@ -199,7 +196,43 @@ namespace Volt
 			return false;
 		}
 
+		SerializedAssetMetadata serializedMetadata = AssetSerializer::ReadMetadata(streamReader);
+
+		// Scene File
+		{
+			Buffer buffer{};
+			streamReader.Read(buffer);
+
+			YAMLMemoryStreamReader yamlStreamReader{};
+			if (!yamlStreamReader.ConsumeBuffer(buffer))
+			{
+				destinationAsset->SetFlag(AssetFlag::Invalid, true);
+				return false;
+			}
+
+			yamlStreamReader.EnterScope("Scene");
+			scene->m_name = yamlStreamReader.ReadKey("name", std::string("New Scene"));
+
+			yamlStreamReader.EnterScope("Settings");
+			{
+				scene->m_sceneSettings.useWorldEngine = yamlStreamReader.ReadKey("useWorldEngine", true);
+			}
+			yamlStreamReader.ExitScope();
+
+			if (scene->m_sceneSettings.useWorldEngine)
+			{
+				DeserializeWorldEngine(scene, yamlStreamReader);
+			}
 
+			yamlStreamReader.ExitScope();
+		}
+
+		const std::filesystem::path& scenePath = filePath;
+		std::filesystem::path directoryPath = scenePath.parent_path();
+
+		LoadCellEntities(metadata, scene, directoryPath);
+
+		scene->SortScene();
 		return true;
 	}
 
@@ -265,6 +298,160 @@ namespace Volt
 		streamWriter.EndMap();
 	}
 
+	void SceneSerializer::DeserializeEntity(const Ref<Scene>& scene, const AssetMetadata& metadata, YAMLMemoryStreamReader& streamReader) const
+	{
+		streamReader.EnterScope("Entity");
+
+		EntityID entityId = streamReader.ReadKey("id", Entity::NullID());
+
+		if (entityId == Entity::NullID())
+		{
+			return;
+		}
+
+		auto entity = CreateEntityFromUUIDThreadSafe(entityId, scene);
+
+		streamReader.ForEach("components", [&]()
+		{
+			VT_PROFILE_SCOPE("Component");
+
+			VoltGUID compGuid = streamReader.ReadKey("guid", VoltGUID::Null());
+			if (compGuid == VoltGUID::Null())
+			{
+				return;
+			}
+
+			const ICommonTypeDesc* typeDesc = ComponentRegistry::GetTypeDescFromGUID(compGuid);
+			if (!typeDesc)
+			{
+				return;
+			}
+
+			switch (typeDesc->GetValueType())
+			{
+				case ValueType::Component:
+				{
+					if (!ComponentRegistry::Helpers::HasComponentWithGUID(compGuid, scene->GetRegistry(), entity))
+					{
+						ComponentRegistry::Helpers::AddComponentWithGUID(compGuid, scene->GetRegistry(), entity);
+					}
+
+					void* voidCompPtr = ComponentRegistry::Helpers::GetComponentWithGUID(compGuid, scene->GetRegistry(), entity);
+					uint8_t* componentData = reinterpret_cast<uint8_t*>(voidCompPtr);
+
+					const IComponentTypeDesc* componentDesc = reinterpret_cast<const IComponentTypeDesc*>(typeDesc);
+					DeserializeClass(componentData, 0, componentDesc, streamReader);
+					break;
+				}
+			}
+
+		});
+
+		if (scene->GetRegistry().any_of<MonoScriptComponent>(entity))
+		{
+			DeserializeMono(entity, scene, streamReader);
+		}
+
+		if (scene->GetRegistry().any_of<VertexPaintedComponent>(entity))
+		{
+			std::filesystem::path vpPath = metadata.filePath.parent_path();
+			vpPath = ProjectManager::GetDirectory() / vpPath / "Layers" / ("ent_" + std::to_string((uint32_t)entityId) + ".entVp");
+
+			if (std::filesystem::exists(vpPath))
+			{
+				auto& vpComp = scene->GetRegistry().get<VertexPaintedComponent>(entity);
+
+				std::ifstream vpFile(vpPath, std::ios::in | std::ios::binary);
+				if (!vpFile.is_open())
+				{
+					VT_CORE_ERROR("Could not open entVp file!");
+				}
+
+				std::vector<uint8_t> totalData;
+				const size_t srcSize = vpFile.seekg(0, std::ios::end).tellg();
+				totalData.resize(srcSize);
+				vpFile.seekg(0, std::ios::beg);
+				vpFile.read(reinterpret_cast<char*>(totalData.data()), totalData.size());
+				vpFile.close();
+
+				memcpy_s(&vpComp.meshHandle, sizeof(vpComp.meshHandle), totalData.data() + totalData.size() - sizeof(vpComp.meshHandle), sizeof(vpComp.meshHandle));
+				totalData.resize(totalData.size() - sizeof(vpComp.meshHandle));
+
+				vpComp.vertexColors.reserve(totalData.size() / sizeof(uint32_t));
+				for (size_t offset = 0; offset < totalData.size(); offset += sizeof(uint32_t))
+				{
+					uint32_t vpColor;
+					memcpy_s(&vpColor, sizeof(uint32_t), totalData.data() + offset, sizeof(uint32_t));
+					vpComp.vertexColors.push_back(vpColor);
+				}
+			}
+		}
+
+		streamReader.ExitScope();
+	}
+
+	void SceneSerializer::DeserializeMono(entt::entity id, const Ref<Scene>& scene, YAMLMemoryStreamReader& streamReader) const
+	{
+		Entity entity{ id, scene };
+
+		streamReader.ForEach("MonoScripts", [&]()
+		{
+			streamReader.EnterScope("ScriptEntry");
+
+			if (!entity.HasComponent<MonoScriptComponent>())
+			{
+				entity.AddComponent<MonoScriptComponent>();
+			}
+
+			const std::string scriptName = streamReader.ReadKey("name", std::string(""));
+			const UUID scriptId = streamReader.ReadKey("id", UUID(0));
+
+			auto scriptClass = MonoScriptEngine::GetScriptClass(scriptName);
+			if (!scriptClass)
+			{
+				streamReader.ExitScope();
+				return;
+			}
+
+			auto& scriptComp = entity.GetComponent<MonoScriptComponent>();
+			scriptComp.scriptIds.emplace_back(scriptId);
+			scriptComp.scriptNames.emplace_back(scriptName);
+
+			const auto& classFields = scriptClass->GetFields();
+			auto& fieldCache = scene->GetScriptFieldCache().GetCache()[scriptId];
+
+			streamReader.ForEach("members", [&]()
+			{
+				const std::string memberName = streamReader.ReadKey("name", std::string(""));
+
+				if (!classFields.contains(memberName))
+				{
+					return;
+				}
+
+				fieldCache[memberName] = CreateRef<MonoScriptFieldInstance>();
+
+				auto field = fieldCache[memberName];
+				field->field = classFields.at(memberName);
+
+				if (field->field.type.IsString())
+				{
+					const std::string str = streamReader.ReadKey("data", std::string(""));
+					field->SetValue(str, str.size());
+				}
+				else
+				{
+					if (s_typeDeserializers.contains(field->field.type.typeIndex))
+					{
+						field->data.Allocate(field->field.type.typeSize);
+						s_typeDeserializers.at(field->field.type.typeIndex)(streamReader, field->data.As<uint8_t>(), 0);
+					}
+				}
+			});
+			streamReader.ExitScope();
+		});
+	}
+
 	void SceneSerializer::SerializeWorldEngine(const Ref<Scene>& scene, YAMLMemoryStreamWriter& streamWriter) const
 	{
 		auto& worldEngine = scene->m_worldEngine;
@@ -276,6 +463,17 @@ namespace Volt
 		streamWriter.EndMap();
 	}
 
+	void SceneSerializer::DeserializeWorldEngine(const Ref<Scene>& scene, YAMLMemoryStreamReader& streamReader) const
+	{
+		auto& worldEngine = scene->m_worldEngine;
+
+		streamReader.EnterScope("WorldEngine");
+		worldEngine.GetSettingsMutable().cellSize = streamReader.ReadKey("cellSize", 256);
+		worldEngine.GetSettingsMutable().worldSize = streamReader.ReadKey("worldSize", glm::uvec2{ 1280 });
+		worldEngine.GenerateCells();
+		streamReader.ExitScope();
+	}
+
 	void SceneSerializer::SerializeEntities(const AssetMetadata& metadata, const Ref<Scene>& scene, const std::filesystem::path& sceneDirectory) const
 	{
 		std::filesystem::path entitiesDirectoryPath = sceneDirectory / "Entities";
@@ -315,7 +513,7 @@ namespace Volt
 			{
 				EntityID id = removedEntities.at(i);
 
-				const std::filesystem::path entityFilePath = entitiesDirectoryPath / (std::to_string(id) + ".entity");
+				const std::filesystem::path entityFilePath = entitiesDirectoryPath / (std::to_string(id) + ".vtasset");
 				if (std::filesystem::exists(entityFilePath))
 				{
 					FileSystem::MoveToRecycleBin(entityFilePath);
@@ -329,6 +527,106 @@ namespace Volt
 
 		scene->ClearEditedEntities();
 	}
+
+	void SceneSerializer::LoadCellEntities(const AssetMetadata& metadata, const Ref<Scene>& scene, const std::filesystem::path& sceneDirectory) const
+	{
+		std::filesystem::path layersFolderPath = sceneDirectory / "Entities";
+		if (!std::filesystem::exists(layersFolderPath))
+		{
+			return;
+		}
+
+		std::vector<std::filesystem::path> entityPaths;
+
+		for (const auto& it : std::filesystem::directory_iterator(layersFolderPath))
+		{
+			if (!it.is_directory() && it.path().extension().string() == ".vtasset")
+			{
+				entityPaths.emplace_back(it.path());
+			}
+		}
+
+		if (entityPaths.empty())
+		{
+			return;
+		}
+
+		const uint32_t iterationCount = static_cast<uint32_t>(entityPaths.size());
+
+		std::vector<std::unordered_map<WorldCellID, std::vector<EntityID>>> threadCellEntities{};
+		threadCellEntities.resize(Algo::GetThreadCountFromIterationCount(iterationCount));
+
+		auto futures = Algo::ForEachParallelLockable([&threadCellEntities, entityPaths, metadata, this](uint32_t threadIdx, uint32_t i)
+		{
+			const auto& path = entityPaths.at(i);
+
+			BinaryStreamReader streamReader{ path };
+			if (!streamReader.IsStreamValid())
+			{
+				return;
+			}
+
+			uint32_t magicVal = 0;
+			streamReader.Read(magicVal);
+
+			if (magicVal != ENTITY_MAGIC_VAL)
+			{
+				VT_CORE_ERROR("[SceneSerializer]: File is not a valid entity!");
+				return;
+			}
+
+			Buffer buffer{};
+			streamReader.Read(buffer);
+
+			YAMLMemoryStreamReader yamlStreamReader{};
+			if (!yamlStreamReader.ConsumeBuffer(buffer))
+			{
+				return;
+			}
+
+			yamlStreamReader.EnterScope("Entity");
+
+			EntityID entityId = yamlStreamReader.ReadKey("id", Entity::NullID());
+			WorldCellID cellId = yamlStreamReader.ReadKey("cellId", INVALID_WORLD_CELL_ID);
+
+			if (entityId == Entity::NullID())
+			{
+				return;
+			}
+
+			if (cellId == INVALID_WORLD_CELL_ID)
+			{
+				cellId = 0;
+			}
+
+			yamlStreamReader.ExitScope();
+
+			threadCellEntities[threadIdx][cellId].push_back(entityId);
+		},
+		iterationCount);
+
+		for (auto& f : futures)
+		{
+			f.wait();
+		}
+
+		auto& worldEngine = scene->m_worldEngine;
+		for (const auto& tCellEntities : threadCellEntities)
+		{
+			for (const auto& [cellId, entities] : tCellEntities)
+			{
+				worldEngine.AddEntitiesToCell(cellId, entities);
+			}
+		}
+	}
+
+	Entity SceneSerializer::CreateEntityFromUUIDThreadSafe(EntityID entityId, const Ref<Scene>& scene) const
+	{
+		static std::mutex createEntityMutex;
+		std::scoped_lock lock{ createEntityMutex };
+
+		return scene->CreateEntityWithUUID(entityId);
+	}
 	
 	void SceneSerializer::SerializeClass(const uint8_t* data, const size_t offset, const IComponentTypeDesc* compDesc, YAMLMemoryStreamWriter& streamWriter, bool isSubComponent) const
 	{
@@ -497,4 +795,110 @@ namespace Volt
 		}
 		streamWriter.EndSequence();
 	}
+
+	void SceneSerializer::DeserializeClass(uint8_t* data, const size_t offset, const IComponentTypeDesc* compDesc, YAMLMemoryStreamReader& streamReader) const
+	{
+		streamReader.ForEach("members", [&]()
+		{
+			const std::string memberName = streamReader.ReadKey("name", std::string(""));
+			if (memberName.empty())
+			{
+				return;
+			}
+
+			const ComponentMember* componentMember = const_cast<IComponentTypeDesc*>(compDesc)->FindMemberByName(memberName);
+			if (!componentMember)
+			{
+				return;
+			}
+
+			if (componentMember->typeDesc != nullptr)
+			{
+				switch (componentMember->typeDesc->GetValueType())
+				{
+					case ValueType::Component:
+					{
+						const IComponentTypeDesc* memberCompType = reinterpret_cast<const IComponentTypeDesc*>(componentMember->typeDesc);
+						DeserializeClass(data, offset + componentMember->offset, memberCompType, streamReader);
+						break;
+					}
+
+					case ValueType::Enum:
+					{
+						*reinterpret_cast<int32_t*>(&data[offset + componentMember->offset]) = streamReader.ReadKey("enumValue", int32_t(0));
+						break;
+					}
+
+					case ValueType::Array:
+					{
+						const IArrayTypeDesc* arrayTypeDesc = reinterpret_cast<const IArrayTypeDesc*>(componentMember->typeDesc);
+						DeserializeArray(data, offset + componentMember->offset, arrayTypeDesc, streamReader);
+						break;
+					}
+				}
+			}
+			else
+			{
+				if (s_typeDeserializers.contains(componentMember->typeIndex))
+				{
+					s_typeDeserializers.at(componentMember->typeIndex)(streamReader, data, offset + componentMember->offset);
+				}
+			}
+		});
+	}
+
+	void SceneSerializer::DeserializeArray(uint8_t* data, const size_t offset, const IArrayTypeDesc* arrayDesc, YAMLMemoryStreamReader& streamReader) const
+	{
+		void* arrayPtr = &data[offset];
+
+		const bool isNonDefaultType = arrayDesc->GetElementTypeDesc() != nullptr;
+		const auto& typeIndex = arrayDesc->GetElementTypeIndex();
+
+		if (!isNonDefaultType && !s_typeSerializers.contains(typeIndex))
+		{
+			return;
+		}
+
+		streamReader.ForEach("values", [&]()
+		{
+			void* tempDataStorage = nullptr;
+			arrayDesc->DefaultConstructElement(tempDataStorage);
+
+			uint8_t* tempBytePtr = reinterpret_cast<uint8_t*>(tempDataStorage);
+
+			if (isNonDefaultType)
+			{
+				switch (arrayDesc->GetElementTypeDesc()->GetValueType())
+				{
+					case ValueType::Component:
+					{
+						const IComponentTypeDesc* compType = reinterpret_cast<const IComponentTypeDesc*>(arrayDesc->GetElementTypeDesc());
+						DeserializeClass(tempBytePtr, 0, compType, streamReader);
+						break;
+					}
+
+					case ValueType::Enum:
+						*reinterpret_cast<int32_t*>(&tempDataStorage) = streamReader.ReadKey("enumValue", int32_t(0));
+						break;
+
+					case ValueType::Array:
+					{
+						const IArrayTypeDesc* arrayTypeDesc = reinterpret_cast<const IArrayTypeDesc*>(arrayDesc->GetElementTypeDesc());
+						DeserializeArray(tempBytePtr, 0, arrayTypeDesc, streamReader);
+						break;
+					}
+				}
+			}
+			else
+			{
+				if (s_typeDeserializers.contains(typeIndex))
+				{
+					s_typeDeserializers.at(typeIndex)(streamReader, tempBytePtr, 0);
+				}
+			}
+
+			arrayDesc->PushBack(arrayPtr, tempDataStorage);
+			arrayDesc->DestroyElement(tempDataStorage);
+		});
+	}
 }
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/SceneSerializer.h b/Volt/Volt/src/Volt/Asset/ImportersNew/SceneSerializer.h
index 5886f1604..13d4dd8ff 100644
--- a/Volt/Volt/src/Volt/Asset/ImportersNew/SceneSerializer.h
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/SceneSerializer.h
@@ -9,7 +9,7 @@
 namespace Volt
 {
 	class YAMLMemoryStreamWriter;
-	class YAMLFileStreamReader;
+	class YAMLMemoryStreamReader;
 
 	class Scene;
 	class IArrayTypeDesc;
@@ -26,17 +26,18 @@ namespace Volt
 		bool Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const override;
 
 		void SerializeEntity(entt::entity id, const AssetMetadata& metadata, const Ref<Scene>& scene, YAMLMemoryStreamWriter& streamWriter) const;
-		void DeserializeEntity(const Ref<Scene>& scene, const AssetMetadata& metadata, YAMLFileStreamReader& streamReader) const;
-		void DeserializeMono(entt::entity id, const Ref<Scene>& scene, YAMLFileStreamReader& streamReader) const;
+		void DeserializeEntity(const Ref<Scene>& scene, const AssetMetadata& metadata, YAMLMemoryStreamReader& streamReader) const;
+		void DeserializeMono(entt::entity id, const Ref<Scene>& scene, YAMLMemoryStreamReader& streamReader) const;
+
+		static SceneSerializer& Get() { return *s_instance; }
 
 	private:
 		inline static SceneSerializer* s_instance = nullptr;
 
 		void SerializeWorldEngine(const Ref<Scene>& scene, YAMLMemoryStreamWriter& streamWriter) const;
-		void DeserializeWorldEngine(const Ref<Scene>& scene, YAMLFileStreamReader& streamReader) const;
+		void DeserializeWorldEngine(const Ref<Scene>& scene, YAMLMemoryStreamReader& streamReader) const;
 
 		void SerializeEntities(const AssetMetadata& metadata, const Ref<Scene>& scene, const std::filesystem::path& sceneDirectory) const;
-
 		void LoadCellEntities(const AssetMetadata& metadata, const Ref<Scene>& scene, const std::filesystem::path& sceneDirectory) const;
 
 		Entity CreateEntityFromUUIDThreadSafe(EntityID entityId, const Ref<Scene>& scene) const;
@@ -45,10 +46,10 @@ namespace Volt
 		void SerializeArray(const uint8_t* data, const size_t offset, const IArrayTypeDesc* arrayDesc, YAMLMemoryStreamWriter& streamWriter) const;
 		void SerializeMono(entt::entity id, const Ref<Scene>& scene, YAMLMemoryStreamWriter& streamWriter) const;
 
-		void DeserializeClass(uint8_t* data, const size_t offset, const IComponentTypeDesc* compDesc, YAMLFileStreamReader& streamReader) const;
-		void DeserializeArray(uint8_t* data, const size_t offset, const IArrayTypeDesc* arrayDesc, YAMLFileStreamReader& streamReader) const;
+		void DeserializeClass(uint8_t* data, const size_t offset, const IComponentTypeDesc* compDesc, YAMLMemoryStreamReader& streamReader) const;
+		void DeserializeArray(uint8_t* data, const size_t offset, const IArrayTypeDesc* arrayDesc, YAMLMemoryStreamReader& streamReader) const;
 
 		inline static std::unordered_map<std::type_index, std::function<void(YAMLMemoryStreamWriter&, const uint8_t*, const size_t)>> s_typeSerializers;
-		inline static std::unordered_map<std::type_index, std::function<void(YAMLFileStreamReader&, uint8_t*, const size_t)>> s_typeDeserializers;
+		inline static std::unordered_map<std::type_index, std::function<void(YAMLMemoryStreamReader&, uint8_t*, const size_t)>> s_typeDeserializers;
 	};
 }
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/ShaderSerializer.cpp b/Volt/Volt/src/Volt/Asset/ImportersNew/ShaderSerializer.cpp
new file mode 100644
index 000000000..0126a1044
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/ShaderSerializer.cpp
@@ -0,0 +1,115 @@
+#include "vtpch.h"
+#include "ShaderSerializer.h"
+
+#include "Volt/Asset/AssetManager.h"
+
+#include "Volt/Rendering/Shader/Shader.h"
+
+#include "Volt/Utility/FileIO/YAMLMemoryStreamWriter.h"
+#include "Volt/Utility/FileIO/YAMLMemoryStreamReader.h"
+
+namespace Volt
+{
+	constexpr uint32_t CURRENT_ASSET_VERSION = 1;
+
+	void ShaderSerializer::Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const
+	{
+		Ref<Shader> shader = std::reinterpret_pointer_cast<Shader>(asset);
+		
+		YAMLMemoryStreamWriter yamlStreamWriter{};
+		yamlStreamWriter.BeginMap();
+		yamlStreamWriter.SetKey("name", shader->GetName());
+		yamlStreamWriter.SetKey("internal", shader->IsInternal());
+
+		yamlStreamWriter.BeginSequence("paths");
+		for (const auto& path : shader->GetSourcePaths())
+		{
+			yamlStreamWriter.GetEmitter() << path;
+		}
+		yamlStreamWriter.EndSequence();
+
+		yamlStreamWriter.BeginSequence("inputTextures");
+		for (const auto& [shaderName, editorName] : shader->GetResources().shaderTextureDefinitions)
+		{
+			yamlStreamWriter.BeginMap();
+			yamlStreamWriter.SetKey("shaderName", shaderName);
+			yamlStreamWriter.SetKey("editorName", editorName);
+			yamlStreamWriter.EndMap();
+		}
+		yamlStreamWriter.EndSequence();
+		yamlStreamWriter.EndMap();
+	
+		BinaryStreamWriter streamWriter{};
+		const size_t compressedDataOffset = AssetSerializer::WriteMetadata(metadata, CURRENT_ASSET_VERSION, streamWriter);
+		
+		Buffer buffer = yamlStreamWriter.WriteAndGetBuffer();
+		streamWriter.Write(buffer);
+		buffer.Release();
+
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+		streamWriter.WriteToDisk(filePath, true, compressedDataOffset);
+	}
+
+	bool ShaderSerializer::Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const
+	{
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+
+		if (!std::filesystem::exists(filePath))
+		{
+			VT_CORE_ERROR("File {0} not found!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Missing, true);
+			return false;
+		}
+
+		BinaryStreamReader streamReader{ filePath };
+
+		if (!streamReader.IsStreamValid())
+		{
+			VT_CORE_ERROR("Failed to open file: {0}!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Invalid, true);
+			return false;
+		}
+
+		SerializedAssetMetadata serializedMetadata = AssetSerializer::ReadMetadata(streamReader);
+
+		Buffer buffer{};
+		streamReader.Read(buffer);
+
+		YAMLMemoryStreamReader yamlStreamReader{};
+		if (!yamlStreamReader.ConsumeBuffer(buffer))
+		{
+			destinationAsset->SetFlag(AssetFlag::Invalid, true);
+			return false;
+		}
+
+		const std::string name = yamlStreamReader.ReadKey("name", std::string("Unnamed"));
+		const bool isInternal = yamlStreamReader.ReadKey("internal", false);
+
+		std::vector<std::filesystem::path> paths;
+		yamlStreamReader.ForEach("paths", [&]() 
+		{
+			paths.emplace_back(yamlStreamReader.GetCurrentNode().as<std::string>());
+		});
+
+		if (paths.empty())
+		{
+			VT_CORE_ERROR("No shaders defined in shader definition {0}!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Invalid, true);
+			return false;
+		}
+
+		std::vector<ShaderTexture> inputTextures;
+		yamlStreamReader.ForEach("inputTextures", [&]() 
+		{
+			inputTextures.emplace_back(yamlStreamReader.ReadKey("shaderName", std::string("Empty")), yamlStreamReader.ReadKey("editorName", std::string("Null")));
+		});
+
+		Ref<Shader> shader = std::reinterpret_pointer_cast<Shader>(destinationAsset);
+		shader->Initialize(name, paths, false);
+
+		const_cast<std::vector<ShaderTexture>&>(shader->GetResources().shaderTextureDefinitions) = inputTextures; // #TODO_Ivar: Add checking
+		shader->myIsInternal = isInternal;
+
+		return true;
+	}
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/ShaderSerializer.h b/Volt/Volt/src/Volt/Asset/ImportersNew/ShaderSerializer.h
new file mode 100644
index 000000000..a22599e2a
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/ShaderSerializer.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Volt/Asset/ImportersNew/AssetSerializer.h"
+
+namespace Volt
+{
+	class ShaderSerializer : public AssetSerializer
+	{ 
+	public:
+		void Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const override;
+		bool Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const override;
+	};
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/SkeletonSerializer.cpp b/Volt/Volt/src/Volt/Asset/ImportersNew/SkeletonSerializer.cpp
new file mode 100644
index 000000000..7899fe538
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/SkeletonSerializer.cpp
@@ -0,0 +1,87 @@
+#include "vtpch.h"
+#include "SkeletonSerializer.h"
+
+#include "Volt/Asset/Animation/Skeleton.h"
+#include "Volt/Asset/AssetManager.h"
+
+namespace Volt
+{
+	constexpr uint32_t CURRENT_ASSET_VERSION = 1;
+
+	struct SkeletonSerializationData
+	{
+		std::string name;
+		std::vector<Skeleton::Joint> joints;
+		std::vector<glm::mat4> inverseBindPose;
+		std::vector<Animation::TRS> restPose;
+
+		static void Serialize(BinaryStreamWriter& streamWriter, const SkeletonSerializationData& data)
+		{
+			streamWriter.Write(data.name);
+			streamWriter.Write(data.joints);
+			streamWriter.Write(data.inverseBindPose);
+			streamWriter.WriteRaw(data.restPose);
+		}
+
+		static void Deserialize(BinaryStreamReader& streamReader, SkeletonSerializationData& outData)
+		{
+			streamReader.Read(outData.name);
+			streamReader.Read(outData.joints);
+			streamReader.Read(outData.inverseBindPose);
+			streamReader.ReadRaw(outData.restPose);
+		}
+	};
+
+	void SkeletonSerializer::Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const
+	{
+		Ref<Skeleton> skeleton = std::reinterpret_pointer_cast<Skeleton>(asset);
+		BinaryStreamWriter streamWriter{};
+	
+		SkeletonSerializationData serializationData{};
+		serializationData.name = skeleton->myName;
+		serializationData.joints = skeleton->myJoints;
+		serializationData.inverseBindPose = skeleton->myInverseBindPose;
+		serializationData.restPose = skeleton->myRestPose;
+
+		const size_t compressedDataOffset = AssetSerializer::WriteMetadata(metadata, CURRENT_ASSET_VERSION, streamWriter);
+		streamWriter.Write(serializationData);
+
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+		streamWriter.WriteToDisk(filePath, true, compressedDataOffset);
+	}
+
+	bool SkeletonSerializer::Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const
+	{
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+
+		if (!std::filesystem::exists(filePath))
+		{
+			VT_CORE_ERROR("File {0} not found!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Missing, true);
+			return false;
+		}
+
+		BinaryStreamReader streamReader{ filePath };
+
+		if (!streamReader.IsStreamValid())
+		{
+			VT_CORE_ERROR("Failed to open file: {0}!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Invalid, true);
+			return false;
+		}
+
+		SerializedAssetMetadata serializedMetadata = AssetSerializer::ReadMetadata(streamReader);
+
+		SkeletonSerializationData serializationData{};
+		streamReader.Read(serializationData);
+
+		Ref<Skeleton> skeleton = std::reinterpret_pointer_cast<Skeleton>(destinationAsset);
+
+		skeleton->myName = serializationData.name;
+		skeleton->myJoints = serializationData.joints;
+		skeleton->myInverseBindPose = serializationData.inverseBindPose;
+		skeleton->myRestPose = serializationData.restPose;
+
+		return true;
+	}
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/SkeletonSerializer.h b/Volt/Volt/src/Volt/Asset/ImportersNew/SkeletonSerializer.h
new file mode 100644
index 000000000..0d90133d8
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/SkeletonSerializer.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Volt/Asset/ImportersNew/AssetSerializer.h"
+
+namespace Volt
+{
+	class SkeletonSerializer : public AssetSerializer
+	{
+	public:
+		void Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const override;
+		bool Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const override;
+	};
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/TextureSerializer.cpp b/Volt/Volt/src/Volt/Asset/ImportersNew/TextureSerializer.cpp
index 0db349a4f..fc481edf9 100644
--- a/Volt/Volt/src/Volt/Asset/ImportersNew/TextureSerializer.cpp
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/TextureSerializer.cpp
@@ -1,6 +1,8 @@
 #include "vtpch.h"
 #include "TextureSerializer.h"
 
+#include "Volt/Asset/AssetManager.h"
+
 #include "Volt/Rendering/Texture/Texture2D.h"
 #include "Volt/Rendering/Texture/Image2D.h"
 
@@ -37,20 +39,65 @@ namespace Volt
 		uint32_t width;
 		uint32_t height;
 		size_t dataSize;
+		size_t dataOffset;
 	};
 
 	struct TextureHeader
 	{
-		ImageFormat encoding; // Should be one of the BC formats
+		ImageFormat format; // Should be one of the BC formats
 		std::vector<TextureMip> mips;
+
+		static void Serialize(BinaryStreamWriter& streamWriter, const TextureHeader& data)
+		{
+			streamWriter.Write(data.format);
+			streamWriter.Write(data.mips);
+		}
+
+		static void Deserialize(BinaryStreamReader& streamReader, TextureHeader& outData)
+		{
+			streamReader.Read(outData.format);
+			streamReader.Read(outData.mips);
+		}
+	};
+
+	struct TextureData
+	{
+		struct Mip 
+		{
+			uint32_t width;
+			uint32_t height;
+			size_t dataSize;
+			size_t dataOffset;
+			const void* dataPtr = nullptr;
+		};
+
+		void SetupMips(const TextureHeader& header, const Buffer& buffer)
+		{
+			for (const auto& mip : header.mips)
+			{
+				auto& newMip = mips.emplace_back();
+				newMip.width = mip.width;
+				newMip.height = mip.height;
+				newMip.dataSize = mip.dataSize;
+				newMip.dataOffset = mip.dataOffset;
+				newMip.dataPtr = buffer.As<const void>(newMip.dataOffset);
+			}
+		}
+
+		std::vector<Mip> mips;
 	};
 
+	constexpr uint32_t CURRENT_ASSET_VERSION = 1;
+
 	void TextureSerializer::Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const
 	{
 		Ref<Texture2D> texture = std::reinterpret_pointer_cast<Texture2D>(asset);
 		Ref<Image2D> image = texture->GetImage();
 
-		std::vector<uint8_t> data;
+		TextureHeader header{};
+		header.format = image->GetFormat();
+
+		Buffer dataBuffer{};
 
 		if (!Utility::IsEncodedFormat(texture->GetImage()->GetFormat()))
 		{
@@ -58,50 +105,140 @@ namespace Volt
 		}
 		else
 		{
-			VkBuffer hostBuffer{};
-			VmaAllocation hostAllocation{};
+			for (uint32_t i = 0; i < image->GetSpecification().mips; i++)
+			{
+				auto& newMip = header.mips.emplace_back();
+				newMip.width = image->GetWidth() >> i;
+				newMip.height = image->GetHeight() >> i;
+				newMip.dataOffset = dataBuffer.GetSize();
+
+				newMip.dataSize = image->CopyToBuffer(dataBuffer, i, dataBuffer.GetSize());
+			}
+		}
+
+		BinaryStreamWriter streamWriter{};
+		const size_t compressedDataOffset = AssetSerializer::WriteMetadata(metadata, CURRENT_ASSET_VERSION, streamWriter);
+
+		streamWriter.Write(header);
+		streamWriter.Write(dataBuffer);
+
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+		streamWriter.WriteToDisk(filePath, true, compressedDataOffset);
+	}
+
+	bool TextureSerializer::Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const
+	{
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+
+		if (!std::filesystem::exists(filePath))
+		{
+			VT_CORE_ERROR("File {0} not found!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Missing, true);
+			return false;
+		}
+
+		BinaryStreamReader streamReader{ filePath };
+
+		if (!streamReader.IsStreamValid())
+		{
+			VT_CORE_ERROR("Failed to open file: {0}!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Invalid, true);
+			return false;
+		}
+
+		SerializedAssetMetadata serializedMetadata = AssetSerializer::ReadMetadata(streamReader);
+
+		TextureHeader textureHeader{};
+		streamReader.Read(textureHeader);
+		
+		Buffer textureDataBuffer{};
+		streamReader.Read(textureDataBuffer);
+
+		Ref<Texture2D> texture = std::reinterpret_pointer_cast<Texture2D>(destinationAsset);
+
+		// Create image
+		{
+			VkBuffer stagingBuffer;
+			VmaAllocation stagingAllocation;
 
-			VulkanAllocator allocator{ "Texture - Serialize" };
+			VulkanAllocator allocator{};
 
-			// Create host buffer
+			const size_t size = textureHeader.mips.front().dataSize;
+
+			// Create staging buffer
 			{
 				VkBufferCreateInfo info{};
 				info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
-				info.size = texture->GetImage()->GetAllocationSize();
-				info.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+				info.size = size;
+				info.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
 				info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 
-				hostAllocation = allocator.AllocateBuffer(info, VMA_MEMORY_USAGE_GPU_TO_CPU, hostBuffer);
+				stagingAllocation = allocator.AllocateBuffer(info, VMA_MEMORY_USAGE_CPU_TO_GPU, stagingBuffer);
 			}
 
-			Utility::TransitionImageLayout(image->GetHandle(), image->GetLayout(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
+			// Map memory
+			{
+				void* bufferPtr = allocator.MapMemory<void>(stagingAllocation);
+				memcpy_s(bufferPtr, size, textureDataBuffer.As<void>(), size);
+				allocator.UnmapMemory(stagingAllocation);
+			}
 
-			size_t bufferOffset = 0;
+			ImageSpecification specification{};
+			specification.format = textureHeader.format;
+			specification.usage = ImageUsage::Texture;
+			specification.width = textureHeader.mips.front().width;
+			specification.height = textureHeader.mips.front().height;
+			specification.mips = static_cast<uint32_t>(textureHeader.mips.size());
+			specification.generateMips = false;
+			specification.debugName = filePath.stem().string();
 
-			Utility::CopyImageToBuffer(hostBuffer, bufferOffset, image->GetHandle(), image->GetWidth(), image->GetHeight(), 0);
-			Utility::TransitionImageLayout(image->GetHandle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, image->GetLayout());
-		
-			auto* imageData = allocator.MapMemory<uint8_t>(hostAllocation);
-			data.resize(image->GetAllocationSize());
+			Ref<Image2D> image = Image2D::Create(specification);
 
-			memcpy_s(data.data(), data.size(), imageData, image->GetAllocationSize());
-			allocator.UnmapMemory(hostAllocation);
-		
-			allocator.DestroyBuffer(hostBuffer, hostAllocation);
-		}
+			TextureData texData{};
+			texData.SetupMips(textureHeader, textureDataBuffer);
 
-		TextureHeader header{};
-		header.encoding = image->GetFormat();
-	
-		{
-			auto& firstMip = header.mips.emplace_back();
-			firstMip.width = image->GetWidth();
-			firstMip.height = image->GetHeight();
+			Utility::TransitionImageLayout(image->GetHandle(), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+			Utility::CopyBufferToImage(stagingBuffer, image->GetHandle(), specification.width, specification.height);
+
+			allocator.DestroyBuffer(stagingBuffer, stagingAllocation);
+
+			for (size_t i = 1; i < texData.mips.size(); i++)
+			{
+				VmaAllocation mipStagingAllocation;
+				VkBuffer mipStagingBuffer;
+
+				auto mipData = texData.mips.at(i);
+				const VkDeviceSize mipSize = mipData.dataSize;
+
+				// Create mip staging buffer
+				{
+					VkBufferCreateInfo info{};
+					info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+					info.size = mipSize;
+					info.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+					info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+
+					mipStagingAllocation = allocator.AllocateBuffer(info, VMA_MEMORY_USAGE_CPU_TO_GPU, mipStagingBuffer);
+				}
+
+				// Map mip memory
+				{
+					void* bufferPtr = allocator.MapMemory<void>(mipStagingAllocation);
+					memcpy_s(bufferPtr, mipSize, mipData.dataPtr, mipSize);
+					allocator.UnmapMemory(mipStagingAllocation);
+				}
+
+				Utility::CopyBufferToImage(mipStagingBuffer, image->GetHandle(), mipData.width, mipData.height, static_cast<uint32_t>(i));
+				allocator.DestroyBuffer(mipStagingBuffer, mipStagingAllocation);
+			}
+
+			Utility::TransitionImageLayout(image->GetHandle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+			image->OverrideLayout(VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+
+			textureDataBuffer.Release();
+			texture->myImage = image;
 		}
-	}
 
-	bool TextureSerializer::Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const
-	{
-		return false;
+		return true;
 	}
 }
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/VideoSerializer.cpp b/Volt/Volt/src/Volt/Asset/ImportersNew/VideoSerializer.cpp
new file mode 100644
index 000000000..725d2d8c7
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/VideoSerializer.cpp
@@ -0,0 +1,30 @@
+#include "vtpch.h"
+#include "VideoSerializer.h"
+
+#include "Volt/Asset/AssetManager.h"
+#include "Volt/Asset/Video/Video.h"
+
+namespace Volt
+{
+	void VideoSerializer::Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const
+	{
+
+	}
+
+	bool VideoSerializer::Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const
+	{
+		const auto filePath = AssetManager::GetFilesystemPath(metadata.filePath);
+
+		if (!std::filesystem::exists(filePath))
+		{
+			VT_CORE_ERROR("File {0} not found!", metadata.filePath);
+			destinationAsset->SetFlag(AssetFlag::Missing, true);
+			return false;
+		}
+
+		Ref<Video> video = std::reinterpret_pointer_cast<Video>(destinationAsset);
+		video->Initialize(filePath);
+
+		return true;
+	}
+}
diff --git a/Volt/Volt/src/Volt/Asset/ImportersNew/VideoSerializer.h b/Volt/Volt/src/Volt/Asset/ImportersNew/VideoSerializer.h
new file mode 100644
index 000000000..87c17e622
--- /dev/null
+++ b/Volt/Volt/src/Volt/Asset/ImportersNew/VideoSerializer.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Volt/Asset/ImportersNew/AssetSerializer.h"
+
+namespace Volt
+{
+	class VideoSerializer : public AssetSerializer
+	{
+	public:
+		void Serialize(const AssetMetadata& metadata, const Ref<Asset>& asset) const override;
+		bool Deserialize(const AssetMetadata& metadata, Ref<Asset> destinationAsset) const override;
+	};
+}
diff --git a/Volt/Volt/src/Volt/Asset/Prefab.h b/Volt/Volt/src/Volt/Asset/Prefab.h
index 93597b93e..a5f9d8317 100644
--- a/Volt/Volt/src/Volt/Asset/Prefab.h
+++ b/Volt/Volt/src/Volt/Asset/Prefab.h
@@ -42,6 +42,7 @@ namespace Volt
 
 	private:
 		friend class PrefabImporter;
+		friend class PrefabSerializer;
 
 		[[nodiscard]] const Entity GetRootEntity() const;
 
diff --git a/Volt/Volt/src/Volt/Asset/Text/Font.cpp b/Volt/Volt/src/Volt/Asset/Text/Font.cpp
index ba9503b33..9c03f5f87 100644
--- a/Volt/Volt/src/Volt/Asset/Text/Font.cpp
+++ b/Volt/Volt/src/Volt/Asset/Text/Font.cpp
@@ -100,7 +100,12 @@ namespace Volt
 		return texture;
 	}
 
-	Font::Font(const std::filesystem::path& aPath)
+	Font::~Font()
+	{
+		delete myMSDFData;
+	}
+
+	void Font::Initialize(const std::filesystem::path& filePath)
 	{
 		myMSDFData = new MSDFData();
 
@@ -109,7 +114,7 @@ namespace Volt
 
 		fontInput.glyphType = msdf_atlas::GlyphIdentifierType::UNICODE_CODEPOINT;
 		fontInput.scale = -1.f;
-		fontInput.filename = aPath.string();
+		fontInput.filename = filePath.string();
 
 		config.imageType = msdf_atlas::ImageType::MTSDF;
 		config.imageFormat = msdf_atlas::ImageFormat::BINARY_FLOAT;
@@ -225,18 +230,18 @@ namespace Volt
 
 		switch (fontInput.glyphType)
 		{
-			case msdf_atlas::GlyphIdentifierType::GLYPH_INDEX:
-			{
-				glyphsLoaded = myMSDFData->fontGeometry.loadGlyphset(font, (double)fontInput.scale, charset);
-				break;
-			}
+		case msdf_atlas::GlyphIdentifierType::GLYPH_INDEX:
+		{
+			glyphsLoaded = myMSDFData->fontGeometry.loadGlyphset(font, (double)fontInput.scale, charset);
+			break;
+		}
 
-			case msdf_atlas::GlyphIdentifierType::UNICODE_CODEPOINT:
-			{
-				glyphsLoaded = myMSDFData->fontGeometry.loadCharset(font, (double)fontInput.scale, charset);
-				anyCodepointsAvailable |= glyphsLoaded > 0;
-				break;
-			}
+		case msdf_atlas::GlyphIdentifierType::UNICODE_CODEPOINT:
+		{
+			glyphsLoaded = myMSDFData->fontGeometry.loadCharset(font, (double)fontInput.scale, charset);
+			anyCodepointsAvailable |= glyphsLoaded > 0;
+			break;
+		}
 		}
 
 		VT_CORE_ASSERT(glyphsLoaded >= 0, "Unable to load glyphs!");
@@ -299,11 +304,11 @@ namespace Volt
 			if (config.expensiveColoring)
 			{
 				msdf_atlas::Workload([&glyphs = myMSDFData->glyphs, &config](int i, int) -> bool
-				{
-					uint64_t glyphSeed = (LCG_MULTIPLIER * (config.coloringSeed ^ i) + LCG_INCREMENT) * !!config.coloringSeed;
-					glyphs[i].edgeColoring(config.edgeColoring, config.angleThreshold, glyphSeed);
-					return true;
-				}, (int)myMSDFData->glyphs.size()).finish(THREADS);
+					{
+						uint64_t glyphSeed = (LCG_MULTIPLIER * (config.coloringSeed ^ i) + LCG_INCREMENT) * !!config.coloringSeed;
+						glyphs[i].edgeColoring(config.edgeColoring, config.angleThreshold, glyphSeed);
+						return true;
+					}, (int)myMSDFData->glyphs.size()).finish(THREADS);
 			}
 			else
 			{
@@ -337,44 +342,39 @@ namespace Volt
 			bool floatingPointFormat = true;
 			switch (config.imageType)
 			{
-				case msdf_atlas::ImageType::MSDF:
+			case msdf_atlas::ImageType::MSDF:
+			{
+				if (floatingPointFormat)
 				{
-					if (floatingPointFormat)
-					{
-						texture = CreateAndCacheAtlas<float, float, 3, msdf_atlas::msdfGenerator>(fontName, (float)config.emSize, myMSDFData->glyphs, myMSDFData->fontGeometry, config);
-					}
-					else
-					{
-						texture = CreateAndCacheAtlas<uint8_t, float, 3, msdf_atlas::msdfGenerator>(fontName, (float)config.emSize, myMSDFData->glyphs, myMSDFData->fontGeometry, config);
-					}
-
-					break;
+					texture = CreateAndCacheAtlas<float, float, 3, msdf_atlas::msdfGenerator>(fontName, (float)config.emSize, myMSDFData->glyphs, myMSDFData->fontGeometry, config);
 				}
-
-				case msdf_atlas::ImageType::MTSDF:
+				else
 				{
-					if (floatingPointFormat)
-					{
-						texture = CreateAndCacheAtlas<float, float, 4, msdf_atlas::mtsdfGenerator>(fontName, (float)config.emSize, myMSDFData->glyphs, myMSDFData->fontGeometry, config);
-					}
-					else
-					{
-						texture = CreateAndCacheAtlas<uint8_t, float, 4, msdf_atlas::mtsdfGenerator>(fontName, (float)config.emSize, myMSDFData->glyphs, myMSDFData->fontGeometry, config);
-					}
+					texture = CreateAndCacheAtlas<uint8_t, float, 3, msdf_atlas::msdfGenerator>(fontName, (float)config.emSize, myMSDFData->glyphs, myMSDFData->fontGeometry, config);
+				}
+
+				break;
+			}
 
-					break;
+			case msdf_atlas::ImageType::MTSDF:
+			{
+				if (floatingPointFormat)
+				{
+					texture = CreateAndCacheAtlas<float, float, 4, msdf_atlas::mtsdfGenerator>(fontName, (float)config.emSize, myMSDFData->glyphs, myMSDFData->fontGeometry, config);
 				}
+				else
+				{
+					texture = CreateAndCacheAtlas<uint8_t, float, 4, msdf_atlas::mtsdfGenerator>(fontName, (float)config.emSize, myMSDFData->glyphs, myMSDFData->fontGeometry, config);
+				}
+
+				break;
+			}
 			}
 
 		}
 		myAtlas = texture;
 	}
 
-	Font::~Font()
-	{
-		delete myMSDFData;
-	}
-
 	static bool NextLine(int32_t aIndex, const std::vector<int32_t>& aLines)
 	{
 		for (int32_t line : aLines)
diff --git a/Volt/Volt/src/Volt/Asset/Text/Font.h b/Volt/Volt/src/Volt/Asset/Text/Font.h
index 4d6869bd3..68e5e11f5 100644
--- a/Volt/Volt/src/Volt/Asset/Text/Font.h
+++ b/Volt/Volt/src/Volt/Asset/Text/Font.h
@@ -17,9 +17,10 @@ namespace Volt
 		};
 
 		Font() = default;
-		Font(const std::filesystem::path& aPath);
 		~Font() override;
 
+		void Initialize(const std::filesystem::path& filePath);
+
 		float GetStringWidth(const std::string& string, const glm::vec2& scale, float maxWidth);
 		float GetStringHeight(const std::string& string, const glm::vec2& scale, float maxWidth);
 
diff --git a/Volt/Volt/src/Volt/Asset/Video/Video.cpp b/Volt/Volt/src/Volt/Asset/Video/Video.cpp
index b773c5877..49780ba8d 100644
--- a/Volt/Volt/src/Volt/Asset/Video/Video.cpp
+++ b/Volt/Volt/src/Volt/Asset/Video/Video.cpp
@@ -36,11 +36,16 @@ namespace Volt
 		}
 	}
 
-	Video::Video(const std::filesystem::path& path)
+	Video::~Video()
+	{
+		Release();
+	}
+
+	void Video::Initialize(const std::filesystem::path& filePath)
 	{
 		av_register_all();
 
-		int32_t result = avformat_open_input(&myReaderState.formatContext, path.string().c_str(), nullptr, nullptr);
+		int32_t result = avformat_open_input(&myReaderState.formatContext, filePath.string().c_str(), nullptr, nullptr);
 		if (result < 0)
 		{
 			VT_CORE_ERROR("Error when opening video!");
@@ -119,11 +124,6 @@ namespace Volt
 		myStatus = VideoStatus::Playing;
 	}
 
-	Video::~Video()
-	{
-		Release();
-	}
-
 	void Video::Play(bool shouldLoop)
 	{
 		myIsPlaying = true;
diff --git a/Volt/Volt/src/Volt/Asset/Video/Video.h b/Volt/Volt/src/Volt/Asset/Video/Video.h
index 68704aca6..f719ad01f 100644
--- a/Volt/Volt/src/Volt/Asset/Video/Video.h
+++ b/Volt/Volt/src/Volt/Asset/Video/Video.h
@@ -50,9 +50,10 @@ namespace Volt
 
 	public:
 		Video() = default;
-		Video(const std::filesystem::path& aPath);
 		~Video();
 
+		void Initialize(const std::filesystem::path& filePath);
+
 		void Play(bool aLoop = false);
 		void Pause();
 		void Stop();
diff --git a/Volt/Volt/src/Volt/Core/Application.cpp b/Volt/Volt/src/Volt/Core/Application.cpp
index 74e2cc20d..59dee99fa 100644
--- a/Volt/Volt/src/Volt/Core/Application.cpp
+++ b/Volt/Volt/src/Volt/Core/Application.cpp
@@ -156,6 +156,11 @@ namespace Volt
 
 		metadata.filePath = "Assets/TestScene/TestScene.vtasset";
 		sceneSerializer->Serialize(metadata, scene);
+
+		std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+		Ref<Scene> testScene = CreateRef<Scene>();
+		sceneSerializer->Deserialize(metadata, testScene);
 	}
 
 	Application::~Application()
diff --git a/Volt/Volt/src/Volt/Rendering/Shader/Shader.cpp b/Volt/Volt/src/Volt/Rendering/Shader/Shader.cpp
index eefc78590..c06363288 100644
--- a/Volt/Volt/src/Volt/Rendering/Shader/Shader.cpp
+++ b/Volt/Volt/src/Volt/Rendering/Shader/Shader.cpp
@@ -216,9 +216,15 @@ namespace Volt
 		}
 	}
 
-	Shader::Shader(const std::string& name, const std::vector<std::filesystem::path>& shaderFiles, bool forceCompile)
-		: myName(name), myShaderFiles(shaderFiles)
+	Shader::~Shader()
+	{
+		Release();
+	}
+
+	void Shader::Initialize(const std::string& name, const std::vector<std::filesystem::path>& shaderFiles, bool forceCompile)
 	{
+		myName = name;
+		myShaderFiles = shaderFiles;
 
 		if (shaderFiles.empty())
 		{
@@ -230,11 +236,6 @@ namespace Volt
 		GenerateHash();
 	}
 
-	Shader::~Shader()
-	{
-		Release();
-	}
-
 	const bool Shader::Reload(bool forceCompile)
 	{
 		Utility::CreateCacheDirectoryIfNeeded();
@@ -319,7 +320,9 @@ namespace Volt
 
 	Ref<Shader> Shader::Create(const std::string& name, std::vector<std::filesystem::path> paths, bool forceCompile)
 	{
-		return CreateRef<Shader>(name, paths, forceCompile);
+		auto shader =  CreateRef<Shader>();
+		shader->Initialize(name, paths, forceCompile);
+		return shader;
 	}
 
 	void Shader::GenerateHash()
diff --git a/Volt/Volt/src/Volt/Rendering/Shader/Shader.h b/Volt/Volt/src/Volt/Rendering/Shader/Shader.h
index 8b89cffe0..57dccec41 100644
--- a/Volt/Volt/src/Volt/Rendering/Shader/Shader.h
+++ b/Volt/Volt/src/Volt/Rendering/Shader/Shader.h
@@ -191,10 +191,10 @@ namespace Volt
 			HLSL
 		};
 
-		Shader(const std::string& name, const std::vector<std::filesystem::path>& shaderFiles, bool forceCompile);
 		Shader() = default;
 		~Shader();
 
+		void Initialize(const std::string& name, const std::vector<std::filesystem::path>& shaderFiles, bool forceCompile);
 		const bool Reload(bool forceCompile);
 
 		VkDescriptorSet AllocateDescriptorSet(uint32_t set, VkDescriptorPool pool);
@@ -216,6 +216,7 @@ namespace Volt
 
 	private:
 		friend class ShaderImporter;
+		friend class ShaderSerializer;
 
 		struct TypeCount
 		{
diff --git a/Volt/Volt/src/Volt/Rendering/Texture/Image2D.cpp b/Volt/Volt/src/Volt/Rendering/Texture/Image2D.cpp
index 9e7905911..bd727ab3d 100644
--- a/Volt/Volt/src/Volt/Rendering/Texture/Image2D.cpp
+++ b/Volt/Volt/src/Volt/Rendering/Texture/Image2D.cpp
@@ -484,6 +484,39 @@ namespace Volt
 		TransitionToLayout(commandBuffer, dstOriginalLayout);
 	}
 
+	size_t Image2D::CopyToBuffer(Buffer& buffer, uint32_t mip, size_t bufferOffset) const
+	{
+		const size_t mipSize = glm::max((mySpecification.width >> mip) * (mySpecification.height >> mip) * Utility::PerPixelSizeFromFormat(mySpecification.format), Utility::GetFormatMinimumSize(mySpecification.format));
+
+		VkBuffer hostBuffer{};
+		VmaAllocation hostAllocation{};
+
+		VulkanAllocator allocator{};
+
+		{
+			VkBufferCreateInfo info{};
+			info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+			info.size = mipSize;
+			info.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+			info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+
+			hostAllocation = allocator.AllocateBuffer(info, VMA_MEMORY_USAGE_GPU_TO_CPU, hostBuffer);
+		}
+
+		Utility::TransitionImageLayout(myImage, myImageData.layout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
+		Utility::CopyImageToBuffer(hostBuffer, 0, myImage, mySpecification.width >> mip, mySpecification.height >> mip, mip);
+		Utility::TransitionImageLayout(myImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, myImageData.layout);
+
+		auto* imageData = allocator.MapMemory<uint8_t>(hostAllocation);
+		buffer.Resize(mipSize + bufferOffset);
+		buffer.Copy(imageData, mipSize, bufferOffset);
+		allocator.UnmapMemory(hostAllocation);
+
+		allocator.DestroyBuffer(hostBuffer, hostAllocation);
+
+		return mipSize;
+	}
+
 	VkImageView Image2D::CreateMipView(const uint32_t mip)
 	{
 		if (myImageViews.find(mip) != myImageViews.end())
diff --git a/Volt/Volt/src/Volt/Rendering/Texture/Image2D.h b/Volt/Volt/src/Volt/Rendering/Texture/Image2D.h
index 2b0acffbb..e5185b96e 100644
--- a/Volt/Volt/src/Volt/Rendering/Texture/Image2D.h
+++ b/Volt/Volt/src/Volt/Rendering/Texture/Image2D.h
@@ -47,6 +47,7 @@ namespace Volt
 		const VkDescriptorImageInfo& GetDescriptorInfo(VkImageLayout targetLayout);
 
 		void CopyFromImage(VkCommandBuffer commandBuffer, Ref<Image2D> srcImage);
+		size_t CopyToBuffer(Buffer& buffer, uint32_t mip = 0, size_t bufferOffset = 0) const;
 
 		template<typename T>
 		inline T ReadPixel(uint32_t x, uint32_t y);
diff --git a/Volt/Volt/src/Volt/Rendering/Texture/Texture2D.h b/Volt/Volt/src/Volt/Rendering/Texture/Texture2D.h
index 2f6346618..c86e8856b 100644
--- a/Volt/Volt/src/Volt/Rendering/Texture/Texture2D.h
+++ b/Volt/Volt/src/Volt/Rendering/Texture/Texture2D.h
@@ -30,6 +30,7 @@ namespace Volt
 	private:
 		friend class DDSTextureImporter;
 		friend class DefaultTextureImporter;
+		friend class TextureSerializer;
 
 		Ref<Image2D> myImage;
 	};
diff --git a/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamReader.cpp b/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamReader.cpp
index b04f81cc3..81ffa0b9e 100644
--- a/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamReader.cpp
+++ b/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamReader.cpp
@@ -131,6 +131,15 @@ namespace Volt
 		return m_streamValid;
 	}
 
+	void BinaryStreamReader::Read(void* data)
+	{
+		TypeHeader typeHeader{};
+		typeHeader.baseTypeSize = sizeof(void*);
+
+		TypeHeader serializedTypeHeader = ReadTypeHeader();
+		ReadData(data, serializedTypeHeader, typeHeader);
+	}
+
 	TypeHeader BinaryStreamReader::ReadTypeHeader()
 	{
 		constexpr size_t typeHeaderSize = sizeof(TypeHeader);
diff --git a/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamReader.h b/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamReader.h
index 76023850c..cf9724d34 100644
--- a/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamReader.h
+++ b/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamReader.h
@@ -43,6 +43,8 @@ namespace Volt
 		template<typename Key, typename Value>
 		void Read(std::unordered_map<Key, Value>& data);
 
+		void Read(void* data);
+
 	private:
 		TypeHeader ReadTypeHeader();
 		void ReadData(void* outData, const TypeHeader& serializedTypeHeader, const TypeHeader& constructedTypeHeader);
diff --git a/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamWriter.cpp b/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamWriter.cpp
index d2deea77c..c95ec6fd3 100644
--- a/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamWriter.cpp
+++ b/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamWriter.cpp
@@ -119,4 +119,16 @@ namespace Volt
 
 		memcpy_s(&m_data[currentOffset], writeSize, data, size);
 	}
+
+	size_t BinaryStreamWriter::Write(const void* data, const size_t size)
+	{
+		TypeHeader header{};
+		header.baseTypeSize = sizeof(void*);
+		header.totalTypeSize = static_cast<uint32_t>(size);
+
+		WriteTypeHeader(header);
+		WriteData(data, size);
+
+		return m_data.size();
+	}
 }
diff --git a/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamWriter.h b/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamWriter.h
index bc783cc2d..29d608bf6 100644
--- a/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamWriter.h
+++ b/Volt/Volt/src/Volt/Utility/FileIO/BinaryStreamWriter.h
@@ -50,6 +50,8 @@ namespace Volt
 		template<typename Key, typename Value>
 		size_t Write(const std::unordered_map<Key, Value>& data);
 
+		size_t Write(const void* data, const size_t size);
+
 	private:
 		bool GetCompressed(std::vector<uint8_t>& result, size_t compressedDataOffset = 0);
 
@@ -170,7 +172,7 @@ namespace Volt
 
 		if constexpr (std::is_trivial_v<F>)
 		{
-			WriteData(data.data(), data.size() * sizeof(F), header);
+			WriteData(data.data(), data.size() * sizeof(F));
 		}
 		else
 		{
diff --git a/Volt/Volt/src/Volt/Utility/FileIO/YAMLMemoryStreamReader.cpp b/Volt/Volt/src/Volt/Utility/FileIO/YAMLMemoryStreamReader.cpp
index dee0086e9..ff676c122 100644
--- a/Volt/Volt/src/Volt/Utility/FileIO/YAMLMemoryStreamReader.cpp
+++ b/Volt/Volt/src/Volt/Utility/FileIO/YAMLMemoryStreamReader.cpp
@@ -31,4 +31,12 @@ namespace Volt
 
 		return true;
 	}
+
+	const bool YAMLMemoryStreamReader::ConsumeBuffer(Buffer& buffer)
+	{
+		const bool success = ReadBuffer(buffer);
+		buffer.Release();
+
+		return success;
+	}
 }
diff --git a/Volt/Volt/src/Volt/Utility/FileIO/YAMLMemoryStreamReader.h b/Volt/Volt/src/Volt/Utility/FileIO/YAMLMemoryStreamReader.h
index 4ab5d728b..673df06ec 100644
--- a/Volt/Volt/src/Volt/Utility/FileIO/YAMLMemoryStreamReader.h
+++ b/Volt/Volt/src/Volt/Utility/FileIO/YAMLMemoryStreamReader.h
@@ -12,5 +12,6 @@ namespace Volt
 		~YAMLMemoryStreamReader() override = default;
 
 		const bool ReadBuffer(const Buffer& buffer);
+		const bool ConsumeBuffer(Buffer& buffer);
 	};
 }
diff --git a/Volt/Volt/src/Volt/Utility/FileIO/YAMLStreamReader.h b/Volt/Volt/src/Volt/Utility/FileIO/YAMLStreamReader.h
index ddf792391..c7ee92ae0 100644
--- a/Volt/Volt/src/Volt/Utility/FileIO/YAMLStreamReader.h
+++ b/Volt/Volt/src/Volt/Utility/FileIO/YAMLStreamReader.h
@@ -12,7 +12,6 @@ namespace Volt
 		YAMLStreamReader();
 		virtual ~YAMLStreamReader() = default;
 
-
 		const bool HasKey(const std::string& key);
 		const bool IsSequenceEmpty(const std::string& key);
 
@@ -24,6 +23,8 @@ namespace Volt
 
 		void ForEach(const std::string& key, std::function<void()> function);
 
+		inline YAML::Node& GetCurrentNode() { return m_currentNode; }
+
 	protected:
 		YAML::Node m_currentNode;
 		std::vector<YAML::Node> m_nodeStack;
diff --git a/Volt/Volt/src/Volt/Utility/FileIO/YAMLStreamWriter.h b/Volt/Volt/src/Volt/Utility/FileIO/YAMLStreamWriter.h
index b249ecbe0..c4b3b832c 100644
--- a/Volt/Volt/src/Volt/Utility/FileIO/YAMLStreamWriter.h
+++ b/Volt/Volt/src/Volt/Utility/FileIO/YAMLStreamWriter.h
@@ -24,6 +24,8 @@ namespace Volt
 		template<typename K, typename T>
 		void SetKey(const K& key, const T& value);
 
+		inline YAML::Emitter& GetEmitter() { return m_emitter; }
+
 	protected:
 		YAML::Emitter m_emitter;
 	};
diff --git a/Volt/Volt/src/Volt/Utility/ImageUtility.h b/Volt/Volt/src/Volt/Utility/ImageUtility.h
index 16d33deb2..8d63f5b7f 100644
--- a/Volt/Volt/src/Volt/Utility/ImageUtility.h
+++ b/Volt/Volt/src/Volt/Utility/ImageUtility.h
@@ -789,6 +789,55 @@ namespace Volt
 			return 0;
 		}
 
+		inline uint32_t GetFormatMinimumSize(ImageFormat format)
+		{
+			switch (format)
+			{
+				case ImageFormat::None: return 0;
+
+				case ImageFormat::R8U: return 1 * 1;
+
+				case ImageFormat::R16F: return 1 * 2;
+
+				case ImageFormat::R32F: return 1 * 4;
+				case ImageFormat::R32SI: return 1 * 4;
+				case ImageFormat::R32UI: return 1 * 4;
+
+				case ImageFormat::RGBA: return 4 * 1;
+				case ImageFormat::RGBA16F: return 4 * 2;
+				case ImageFormat::RGBA32F: return 4 * 4;
+				case ImageFormat::SRGB: return 4 * 1;
+
+				case ImageFormat::RG32UI: return 2 * 4;
+				case ImageFormat::RG16F: return 2 * 2;
+				case ImageFormat::RG32F: return 2 * 4;
+
+				case ImageFormat::DEPTH32F: return 1 * 4;
+				case ImageFormat::DEPTH24STENCIL8: return 4;
+
+				case ImageFormat::BC1: return 8;
+				case ImageFormat::BC1SRGB: return 8;
+
+				case ImageFormat::BC2: return 16;
+				case ImageFormat::BC2SRGB: return 16;
+
+				case ImageFormat::BC3: return 16;
+				case ImageFormat::BC3SRGB: return 16;
+
+				case ImageFormat::BC4: return 8;
+
+				case ImageFormat::BC5: return 16;
+
+				case ImageFormat::BC6H_SF16: return 16;
+				case ImageFormat::BC6H_UF16: return 16;
+
+				case ImageFormat::BC7: return 16;
+				case ImageFormat::BC7SRGB: return 16;
+			}
+
+			return 1;
+		}
+
 		inline static uint32_t CalculateMipCount(uint32_t width, uint32_t height)
 		{
 			return static_cast<uint32_t>(std::floor(std::log2(std::min(width, height)))) + 1;