diff --git a/ChangeLog.md b/ChangeLog.md
index 023f486a3..f4d1f40bb 100644
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -72,6 +72,7 @@ Nazara Engine:
 - ⚠️ Removed array/pointer constructor from Vector classes
 - Fixed Platform module not being classified as client-only
 - ⚠️ Renamed Bitset::Read to Bitset::Write
+- ⚠️ Added a type tag parameter to Serialize and Unserialize functions, to prevent implicit conversions with overloads
 
 Nazara Development Kit:
 - Added ImageWidget (#139)
diff --git a/include/Nazara/Core/Algorithm.hpp b/include/Nazara/Core/Algorithm.hpp
index 1425c6220..faf80e6cb 100644
--- a/include/Nazara/Core/Algorithm.hpp
+++ b/include/Nazara/Core/Algorithm.hpp
@@ -10,6 +10,7 @@
 #include <Nazara/Prerequisites.hpp>
 #include <Nazara/Core/Enums.hpp>
 #include <Nazara/Core/SerializationContext.hpp>
+#include <Nazara/Core/TypeTag.hpp>
 #include <functional>
 #include <string>
 #include <tuple>
@@ -37,19 +38,22 @@ namespace Nz
 	};
 
 	template<typename T>
-	struct TypeTag {};
+	bool Serialize(SerializationContext& context, T&& value);
 
-	inline bool Serialize(SerializationContext& context, bool value);
-	inline bool Serialize(SerializationContext& context, const std::string& value);
+	inline bool Serialize(SerializationContext& context, bool value, TypeTag<bool>);
+	inline bool Serialize(SerializationContext& context, const std::string& value, TypeTag<std::string>);
 
 	template<typename T>
-	std::enable_if_t<std::is_arithmetic<T>::value, bool> Serialize(SerializationContext& context, T value);
-
-	inline bool Unserialize(SerializationContext& context, bool* value);
-	inline bool Unserialize(SerializationContext& context, std::string* value);
+	std::enable_if_t<std::is_arithmetic<T>::value, bool> Serialize(SerializationContext& context, T value, TypeTag<T>);
 
 	template<typename T>
-	std::enable_if_t<std::is_arithmetic<T>::value, bool> Unserialize(SerializationContext& context, T* value);
+	bool Unserialize(SerializationContext& context, T* value);
+
+	inline bool Unserialize(SerializationContext& context, bool* value, TypeTag<bool>);
+	inline bool Unserialize(SerializationContext& context, std::string* value, TypeTag<std::string>);
+
+	template<typename T>
+	std::enable_if_t<std::is_arithmetic<T>::value, bool> Unserialize(SerializationContext& context, T* value, TypeTag<T>);
 }
 
 #include <Nazara/Core/Algorithm.inl>
diff --git a/include/Nazara/Core/Algorithm.inl b/include/Nazara/Core/Algorithm.inl
index 095ef3710..0c549c44a 100644
--- a/include/Nazara/Core/Algorithm.inl
+++ b/include/Nazara/Core/Algorithm.inl
@@ -12,6 +12,7 @@
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/Stream.hpp>
 #include <climits>
+#include <utility>
 #include <Nazara/Core/Debug.hpp>
 
 namespace Nz
@@ -199,6 +200,13 @@ namespace Nz
 	template<typename T> struct PointedType<T* volatile>       {typedef T type;};
 	template<typename T> struct PointedType<T* const volatile> {typedef T type;};
 
+
+	template<typename T>
+	bool Serialize(SerializationContext& context, T&& value)
+	{
+		return Serialize(context, std::forward<T>(value), TypeTag<std::decay_t<T>>());
+	}
+
 	/*!
 	* \ingroup core
 	* \brief Serializes a boolean
@@ -209,7 +217,7 @@ namespace Nz
 	*
 	* \see Serialize, Unserialize
 	*/
-	inline bool Serialize(SerializationContext& context, bool value)
+	inline bool Serialize(SerializationContext& context, bool value, TypeTag<bool>)
 	{
 		if (context.currentBitPos == 8)
 		{
@@ -221,7 +229,7 @@ namespace Nz
 			context.currentByte |= 1 << context.currentBitPos;
 
 		if (++context.currentBitPos >= 8)
-			return Serialize<UInt8>(context, context.currentByte);
+			return Serialize(context, context.currentByte, TypeTag<UInt8>());
 		else
 			return true;
 	}
@@ -234,9 +242,9 @@ namespace Nz
 	* \param context Context for the serialization
 	* \param value String to serialize
 	*/
-	bool Serialize(SerializationContext& context, const std::string& value)
+	bool Serialize(SerializationContext& context, const std::string& value, TypeTag<std::string>)
 	{
-		if (!Serialize(context, UInt32(value.size())))
+		if (!Serialize(context, UInt32(value.size()), TypeTag<UInt32>()))
 			return false;
 
 		return context.stream->Write(value.data(), value.size()) == value.size();
@@ -253,7 +261,7 @@ namespace Nz
 	* \see Serialize, Unserialize
 	*/
 	template<typename T>
-	std::enable_if_t<std::is_arithmetic<T>::value, bool> Serialize(SerializationContext& context, T value)
+	std::enable_if_t<std::is_arithmetic<T>::value, bool> Serialize(SerializationContext& context, T value, TypeTag<T>)
 	{
 		// Flush bits in case a writing is in progress
 		context.FlushBits();
@@ -264,6 +272,13 @@ namespace Nz
 		return context.stream->Write(&value, sizeof(T)) == sizeof(T);
 	}
 
+
+	template<typename T>
+	bool Unserialize(SerializationContext& context, T* value)
+	{
+		return Unserialize(context, value, TypeTag<T>());
+	}
+
 	/*!
 	* \ingroup core
 	* \brief Unserializes a boolean
@@ -274,11 +289,11 @@ namespace Nz
 	*
 	* \see Serialize, Unserialize
 	*/
-	inline bool Unserialize(SerializationContext& context, bool* value)
+	inline bool Unserialize(SerializationContext& context, bool* value, TypeTag<bool>)
 	{
 		if (context.currentBitPos == 8)
 		{
-			if (!Unserialize(context, &context.currentByte))
+			if (!Unserialize(context, &context.currentByte, TypeTag<UInt8>()))
 				return false;
 
 			context.currentBitPos = 0;
@@ -299,10 +314,10 @@ namespace Nz
 	* \param context Context of unserialization
 	* \param string std::string to unserialize
 	*/
-	bool Unserialize(SerializationContext& context, std::string* string)
+	bool Unserialize(SerializationContext& context, std::string* string, TypeTag<std::string>)
 	{
 		UInt32 size;
-		if (!Unserialize(context, &size))
+		if (!Unserialize(context, &size, TypeTag<UInt32>()))
 			return false;
 
 		string->resize(size);
@@ -322,7 +337,7 @@ namespace Nz
 	* \see Serialize, Unserialize
 	*/
 	template<typename T>
-	std::enable_if_t<std::is_arithmetic<T>::value, bool> Unserialize(SerializationContext& context, T* value)
+	std::enable_if_t<std::is_arithmetic<T>::value, bool> Unserialize(SerializationContext& context, T* value, TypeTag<T>)
 	{
 		NazaraAssert(value, "Invalid data pointer");
 
diff --git a/include/Nazara/Core/ByteStream.inl b/include/Nazara/Core/ByteStream.inl
index 49d51b7d6..0b32215e7 100644
--- a/include/Nazara/Core/ByteStream.inl
+++ b/include/Nazara/Core/ByteStream.inl
@@ -90,7 +90,7 @@ namespace Nz
 		{
 			m_context.currentBitPos = 8; //< To prevent Serialize to flush bits itself
 
-			if (!Serialize<UInt8>(m_context, m_context.currentByte))
+			if (!Serialize(m_context, m_context.currentByte))
 				return false;
 		}
 
diff --git a/include/Nazara/Core/Color.hpp b/include/Nazara/Core/Color.hpp
index 3f3447710..16977c2e0 100644
--- a/include/Nazara/Core/Color.hpp
+++ b/include/Nazara/Core/Color.hpp
@@ -71,8 +71,8 @@ namespace Nz
 			static float Hue2RGB(float v1, float v2, float vH);
 	};
 
-	inline bool Serialize(SerializationContext& context, const Color& color);
-	inline bool Unserialize(SerializationContext& context, Color* color);
+	inline bool Serialize(SerializationContext& context, const Color& color, TypeTag<Color>);
+	inline bool Unserialize(SerializationContext& context, Color* color, TypeTag<Color>);
 }
 
 std::ostream& operator<<(std::ostream& out, const Nz::Color& color);
diff --git a/include/Nazara/Core/Color.inl b/include/Nazara/Core/Color.inl
index f391f0c76..ace951dd0 100644
--- a/include/Nazara/Core/Color.inl
+++ b/include/Nazara/Core/Color.inl
@@ -617,7 +617,7 @@ namespace Nz
 	* \param context Serialization context
 	* \param color Input color
 	*/
-	inline bool Serialize(SerializationContext& context, const Color& color)
+	inline bool Serialize(SerializationContext& context, const Color& color, TypeTag<Color>)
 	{
 		if (!Serialize(context, color.r))
 			return false;
@@ -641,7 +641,7 @@ namespace Nz
 	* \param context Serialization context
 	* \param color Output color
 	*/
-	inline bool Unserialize(SerializationContext& context, Color* color)
+	inline bool Unserialize(SerializationContext& context, Color* color, TypeTag<Color>)
 	{
 		if (!Unserialize(context, &color->r))
 			return false;
diff --git a/include/Nazara/Core/SerializationContext.hpp b/include/Nazara/Core/SerializationContext.hpp
index 102e82850..94951666d 100644
--- a/include/Nazara/Core/SerializationContext.hpp
+++ b/include/Nazara/Core/SerializationContext.hpp
@@ -10,6 +10,7 @@
 #include <Nazara/Prerequisites.hpp>
 #include <Nazara/Core/Config.hpp>
 #include <Nazara/Core/Endianness.hpp>
+#include <Nazara/Core/TypeTag.hpp>
 
 namespace Nz
 {
diff --git a/include/Nazara/Core/String.hpp b/include/Nazara/Core/String.hpp
index 0c8f2c7f8..4aa11a81e 100644
--- a/include/Nazara/Core/String.hpp
+++ b/include/Nazara/Core/String.hpp
@@ -9,6 +9,7 @@
 
 #include <Nazara/Prerequisites.hpp>
 #include <Nazara/Core/Endianness.hpp>
+#include <Nazara/Core/TypeTag.hpp>
 #include <cstdarg>
 #include <iosfwd>
 #include <memory>
@@ -328,8 +329,8 @@ namespace Nz
 	class AbstractHash;
 
 	inline bool HashAppend(AbstractHash* hash, const String& string);
-	NAZARA_CORE_API bool Serialize(SerializationContext& context, const String& string);
-	NAZARA_CORE_API bool Unserialize(SerializationContext& context, String* string);
+	NAZARA_CORE_API bool Serialize(SerializationContext& context, const String& string, TypeTag<String>);
+	NAZARA_CORE_API bool Unserialize(SerializationContext& context, String* string, TypeTag<String>);
 }
 
 namespace std
diff --git a/include/Nazara/Core/TypeTag.hpp b/include/Nazara/Core/TypeTag.hpp
new file mode 100644
index 000000000..150802b01
--- /dev/null
+++ b/include/Nazara/Core/TypeTag.hpp
@@ -0,0 +1,16 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Core module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_TYPETAG_HPP
+#define NAZARA_TYPETAG_HPP
+
+namespace Nz
+{
+	template<typename T>
+	struct TypeTag {};
+}
+
+#endif // NAZARA_TYPETAG_HPP
diff --git a/include/Nazara/Math/BoundingVolume.hpp b/include/Nazara/Math/BoundingVolume.hpp
index b5c4e8b9e..1faea4eb7 100644
--- a/include/Nazara/Math/BoundingVolume.hpp
+++ b/include/Nazara/Math/BoundingVolume.hpp
@@ -72,8 +72,8 @@ namespace Nz
 	typedef BoundingVolume<double> BoundingVolumed;
 	typedef BoundingVolume<float> BoundingVolumef;
 
-	template<typename T> bool Serialize(SerializationContext& context, const BoundingVolume<T>& boundingVolume);
-	template<typename T> bool Unserialize(SerializationContext& context, BoundingVolume<T>* boundingVolume);
+	template<typename T> bool Serialize(SerializationContext& context, const BoundingVolume<T>& boundingVolume, TypeTag<BoundingVolume<T>>);
+	template<typename T> bool Unserialize(SerializationContext& context, BoundingVolume<T>* boundingVolume, TypeTag<BoundingVolume<T>>);
 }
 
 template<typename T>
diff --git a/include/Nazara/Math/BoundingVolume.inl b/include/Nazara/Math/BoundingVolume.inl
index 5bbd83f31..b7defeec2 100644
--- a/include/Nazara/Math/BoundingVolume.inl
+++ b/include/Nazara/Math/BoundingVolume.inl
@@ -603,9 +603,9 @@ namespace Nz
 	* \remark Does not save OBB corners
 	*/
 	template<typename T>
-	bool Serialize(SerializationContext& context, const BoundingVolume<T>& boundingVolume)
+	bool Serialize(SerializationContext& context, const BoundingVolume<T>& boundingVolume, TypeTag<BoundingVolume<T>>)
 	{
-		if (!Serialize(context, static_cast<UInt8>(boundingVolume.extend)))
+		if (!Serialize(context, static_cast<UInt8>(boundingVolume.extend)>))
 			return false;
 
 		if (!Serialize(context, boundingVolume.aabb))
@@ -627,7 +627,7 @@ namespace Nz
 	* \remark The resulting oriented box corners will *not* be updated, a call to Update is required
 	*/
 	template<typename T>
-	bool Unserialize(SerializationContext& context, BoundingVolume<T>* boundingVolume)
+	bool Unserialize(SerializationContext& context, BoundingVolume<T>* boundingVolume, TypeTag<BoundingVolume<T>>)
 	{
 		UInt8 extend;
 		if (!Unserialize(context, &extend))
diff --git a/include/Nazara/Math/Box.hpp b/include/Nazara/Math/Box.hpp
index 9434cda27..df7216eed 100644
--- a/include/Nazara/Math/Box.hpp
+++ b/include/Nazara/Math/Box.hpp
@@ -100,8 +100,8 @@ namespace Nz
 	typedef Box<Int32> Boxi32;
 	typedef Box<UInt32> Boxui32;
 
-	template<typename T> bool Serialize(SerializationContext& context, const Box<T>& box);
-	template<typename T> bool Unserialize(SerializationContext& context, Box<T>* box);
+	template<typename T> bool Serialize(SerializationContext& context, const Box<T>& box, TypeTag<Box<T>>);
+	template<typename T> bool Unserialize(SerializationContext& context, Box<T>* box, TypeTag<Box<T>>);
 }
 
 template<typename T>
diff --git a/include/Nazara/Math/Box.inl b/include/Nazara/Math/Box.inl
index 60275b206..6b0ed9112 100644
--- a/include/Nazara/Math/Box.inl
+++ b/include/Nazara/Math/Box.inl
@@ -912,7 +912,7 @@ namespace Nz
 	* \param box Input Box
 	*/
 	template<typename T>
-	bool Serialize(SerializationContext& context, const Box<T>& box)
+	bool Serialize(SerializationContext& context, const Box<T>& box, TypeTag<Box<T>>)
 	{
 		if (!Serialize(context, box.x))
 			return false;
@@ -943,7 +943,7 @@ namespace Nz
 	* \param box Output Box
 	*/
 	template<typename T>
-	bool Unserialize(SerializationContext& context, Box<T>* box)
+	bool Unserialize(SerializationContext& context, Box<T>* box, TypeTag<Box<T>>)
 	{
 		if (!Unserialize(context, &box->x))
 			return false;
diff --git a/include/Nazara/Math/EulerAngles.hpp b/include/Nazara/Math/EulerAngles.hpp
index b55adc4dd..f7984dd7a 100644
--- a/include/Nazara/Math/EulerAngles.hpp
+++ b/include/Nazara/Math/EulerAngles.hpp
@@ -65,8 +65,8 @@ namespace Nz
 	typedef EulerAngles<double> EulerAnglesd;
 	typedef EulerAngles<float> EulerAnglesf;
 
-	template<typename T> bool Serialize(SerializationContext& context, const EulerAngles<T>& eulerAngles);
-	template<typename T> bool Unserialize(SerializationContext& context, EulerAngles<T>* eulerAngles);
+	template<typename T> bool Serialize(SerializationContext& context, const EulerAngles<T>& eulerAngles, TypeTag<EulerAngles<T>>);
+	template<typename T> bool Unserialize(SerializationContext& context, EulerAngles<T>* eulerAngles, TypeTag<EulerAngles<T>>);
 }
 
 template<typename T> std::ostream& operator<<(std::ostream& out, const Nz::EulerAngles<T>& angles);
diff --git a/include/Nazara/Math/EulerAngles.inl b/include/Nazara/Math/EulerAngles.inl
index 0fc972164..2c35503ec 100644
--- a/include/Nazara/Math/EulerAngles.inl
+++ b/include/Nazara/Math/EulerAngles.inl
@@ -340,7 +340,7 @@ namespace Nz
 	* \param angles Input euler angles
 	*/
 	template<typename T>
-	bool Serialize(SerializationContext& context, const EulerAngles<T>& angles)
+	bool Serialize(SerializationContext& context, const EulerAngles<T>& angles, TypeTag<EulerAngles<T>>)
 	{
 		if (!Serialize(context, angles.pitch))
 			return false;
@@ -362,7 +362,7 @@ namespace Nz
 	* \param angles Output euler angles
 	*/
 	template<typename T>
-	bool Unserialize(SerializationContext& context, EulerAngles<T>* angles)
+	bool Unserialize(SerializationContext& context, EulerAngles<T>* angles, TypeTag<EulerAngles<T>>)
 	{
 		if (!Unserialize(context, &angles->pitch))
 			return false;
diff --git a/include/Nazara/Math/Frustum.hpp b/include/Nazara/Math/Frustum.hpp
index 26242caef..497cf9f97 100644
--- a/include/Nazara/Math/Frustum.hpp
+++ b/include/Nazara/Math/Frustum.hpp
@@ -58,9 +58,9 @@ namespace Nz
 			String ToString() const;
 
 			template<typename U>
-			friend bool Serialize(SerializationContext& context, const Frustum<U>& frustum);
+			friend bool Serialize(SerializationContext& context, const Frustum<U>& frustum, TypeTag<Frustum<T>>);
 			template<typename U>
-			friend bool Unserialize(SerializationContext& context, Frustum<U>* frustum);
+			friend bool Unserialize(SerializationContext& context, Frustum<U>* frustum, TypeTag<Frustum<T>>);
 
 		private:
 			Vector3<T> m_corners[BoxCorner_Max+1];
diff --git a/include/Nazara/Math/Frustum.inl b/include/Nazara/Math/Frustum.inl
index f459a0526..6d6d38500 100644
--- a/include/Nazara/Math/Frustum.inl
+++ b/include/Nazara/Math/Frustum.inl
@@ -684,7 +684,7 @@ namespace Nz
 	* \param matrix Input frustum
 	*/
 	template<typename T>
-	bool Serialize(SerializationContext& context, const Frustum<T>& frustum)
+	bool Serialize(SerializationContext& context, const Frustum<T>& frustum, TypeTag<Frustum<T>>)
 	{
 		for (unsigned int i = 0; i <= BoxCorner_Max; ++i)
 		{
@@ -709,7 +709,7 @@ namespace Nz
 	* \param matrix Output frustum
 	*/
 	template<typename T>
-	bool Unserialize(SerializationContext& context, Frustum<T>* frustum)
+	bool Unserialize(SerializationContext& context, Frustum<T>* frustum, TypeTag<Frustum<T>>)
 	{
 		for (unsigned int i = 0; i <= BoxCorner_Max; ++i)
 		{
diff --git a/include/Nazara/Math/Matrix4.hpp b/include/Nazara/Math/Matrix4.hpp
index c90439de4..70a72c593 100644
--- a/include/Nazara/Math/Matrix4.hpp
+++ b/include/Nazara/Math/Matrix4.hpp
@@ -141,8 +141,8 @@ namespace Nz
 	typedef Matrix4<double> Matrix4d;
 	typedef Matrix4<float> Matrix4f;
 
-	template<typename T> bool Serialize(SerializationContext& context, const Matrix4<T>& matrix);
-	template<typename T> bool Unserialize(SerializationContext& context, Matrix4<T>* matrix);
+	template<typename T> bool Serialize(SerializationContext& context, const Matrix4<T>& matrix, TypeTag<Matrix4<T>>);
+	template<typename T> bool Unserialize(SerializationContext& context, Matrix4<T>* matrix, TypeTag<Matrix4<T>>);
 }
 
 template<typename T> std::ostream& operator<<(std::ostream& out, const Nz::Matrix4<T>& matrix);
diff --git a/include/Nazara/Math/Matrix4.inl b/include/Nazara/Math/Matrix4.inl
index 07eb86182..297edf8a8 100644
--- a/include/Nazara/Math/Matrix4.inl
+++ b/include/Nazara/Math/Matrix4.inl
@@ -1767,7 +1767,7 @@ namespace Nz
 	* \param matrix Input matrix
 	*/
 	template<typename T>
-	bool Serialize(SerializationContext& context, const Matrix4<T>& matrix)
+	bool Serialize(SerializationContext& context, const Matrix4<T>& matrix, TypeTag<Matrix4<T>>)
 	{
 		for (unsigned int i = 0; i < 16; ++i)
 		{
@@ -1786,7 +1786,7 @@ namespace Nz
 	* \param matrix Output matrix
 	*/
 	template<typename T>
-	bool Unserialize(SerializationContext& context, Matrix4<T>* matrix)
+	bool Unserialize(SerializationContext& context, Matrix4<T>* matrix, TypeTag<Matrix4<T>>)
 	{
 		T* head = matrix->operator T*();
 		for (unsigned int i = 0; i < 16; ++i)
diff --git a/include/Nazara/Math/OrientedBox.hpp b/include/Nazara/Math/OrientedBox.hpp
index dfd8f6b28..3e0b36922 100644
--- a/include/Nazara/Math/OrientedBox.hpp
+++ b/include/Nazara/Math/OrientedBox.hpp
@@ -71,8 +71,8 @@ namespace Nz
 	typedef OrientedBox<double> OrientedBoxd;
 	typedef OrientedBox<float> OrientedBoxf;
 
-	template<typename T> bool Serialize(SerializationContext& context, const OrientedBox<T>& obb);
-	template<typename T> bool Unserialize(SerializationContext& context, OrientedBox<T>* obb);
+	template<typename T> bool Serialize(SerializationContext& context, const OrientedBox<T>& obb, TypeTag<OrientedBox<T>>);
+	template<typename T> bool Unserialize(SerializationContext& context, OrientedBox<T>* obb, TypeTag<OrientedBox<T>>);
 }
 
 template<typename T>
diff --git a/include/Nazara/Math/OrientedBox.inl b/include/Nazara/Math/OrientedBox.inl
index 92ebada1d..df864fe26 100644
--- a/include/Nazara/Math/OrientedBox.inl
+++ b/include/Nazara/Math/OrientedBox.inl
@@ -442,7 +442,7 @@ namespace Nz
 	* \remark Does not save OBB corners
 	*/
 	template<typename T>
-	bool Serialize(SerializationContext& context, const OrientedBox<T>& obb)
+	bool Serialize(SerializationContext& context, const OrientedBox<T>& obb, TypeTag<OrientedBox<T>>)
 	{
 		if (!Serialize(context, obb.localBox))
 			return false;
@@ -460,7 +460,7 @@ namespace Nz
 	* \remark The resulting oriented box corners will *not* be updated, a call to Update is required
 	*/
 	template<typename T>
-	bool Unserialize(SerializationContext& context, OrientedBox<T>* obb)
+	bool Unserialize(SerializationContext& context, OrientedBox<T>* obb, TypeTag<OrientedBox<T>>)
 	{
 		if (!Unserialize(context, &obb->localBox))
 			return false;
diff --git a/include/Nazara/Math/Plane.hpp b/include/Nazara/Math/Plane.hpp
index 0970b5a6d..8db8d9d82 100644
--- a/include/Nazara/Math/Plane.hpp
+++ b/include/Nazara/Math/Plane.hpp
@@ -62,8 +62,8 @@ namespace Nz
 	typedef Plane<double> Planed;
 	typedef Plane<float> Planef;
 
-	template<typename T> bool Serialize(SerializationContext& context, const Plane<T>& plane);
-	template<typename T> bool Unserialize(SerializationContext& context, Plane<T>* plane);
+	template<typename T> bool Serialize(SerializationContext& context, const Plane<T>& plane, TypeTag<Plane<T>>);
+	template<typename T> bool Unserialize(SerializationContext& context, Plane<T>* plane, TypeTag<Plane<T>>);
 }
 
 template<typename T>
diff --git a/include/Nazara/Math/Plane.inl b/include/Nazara/Math/Plane.inl
index d80809988..4c2adc90c 100644
--- a/include/Nazara/Math/Plane.inl
+++ b/include/Nazara/Math/Plane.inl
@@ -434,7 +434,7 @@ namespace Nz
 	* \param plane Input Vector2
 	*/
 	template<typename T>
-	bool Serialize(SerializationContext& context, const Plane<T>& plane)
+	bool Serialize(SerializationContext& context, const Plane<T>& plane, TypeTag<Plane<T>>)
 	{
 		if (!Serialize(context, plane.normal))
 			return false;
@@ -453,7 +453,7 @@ namespace Nz
 	* \param plane Output Plane
 	*/
 	template<typename T>
-	bool Unserialize(SerializationContext& context, Plane<T>* plane)
+	bool Unserialize(SerializationContext& context, Plane<T>* plane, TypeTag<Plane<T>>)
 	{
 		if (!Unserialize(context, &plane->normal))
 			return false;
diff --git a/include/Nazara/Math/Quaternion.hpp b/include/Nazara/Math/Quaternion.hpp
index 27adb8b36..93308aa5c 100644
--- a/include/Nazara/Math/Quaternion.hpp
+++ b/include/Nazara/Math/Quaternion.hpp
@@ -91,8 +91,8 @@ namespace Nz
 	typedef Quaternion<double> Quaterniond;
 	typedef Quaternion<float> Quaternionf;
 
-	template<typename T> bool Serialize(SerializationContext& context, const Quaternion<T>& quat);
-	template<typename T> bool Unserialize(SerializationContext& context, Quaternion<T>* quat);
+	template<typename T> bool Serialize(SerializationContext& context, const Quaternion<T>& quat, TypeTag<Quaternion<T>>);
+	template<typename T> bool Unserialize(SerializationContext& context, Quaternion<T>* quat, TypeTag<Quaternion<T>>);
 }
 
 template<typename T> std::ostream& operator<<(std::ostream& out, const Nz::Quaternion<T>& quat);
diff --git a/include/Nazara/Math/Quaternion.inl b/include/Nazara/Math/Quaternion.inl
index f07524c0f..e65be083a 100644
--- a/include/Nazara/Math/Quaternion.inl
+++ b/include/Nazara/Math/Quaternion.inl
@@ -826,7 +826,7 @@ namespace Nz
 	* \param quat Input Quaternion
 	*/
 	template<typename T>
-	bool Serialize(SerializationContext& context, const Quaternion<T>& quat)
+	bool Serialize(SerializationContext& context, const Quaternion<T>& quat, TypeTag<Quaternion<T>>)
 	{
 		if (!Serialize(context, quat.x))
 			return false;
@@ -851,7 +851,7 @@ namespace Nz
 	* \param quat Output Quaternion
 	*/
 	template<typename T>
-	bool Unserialize(SerializationContext& context, Quaternion<T>* quat)
+	bool Unserialize(SerializationContext& context, Quaternion<T>* quat, TypeTag<Quaternion<T>>)
 	{
 		if (!Unserialize(context, &quat->x))
 			return false;
diff --git a/include/Nazara/Math/Ray.hpp b/include/Nazara/Math/Ray.hpp
index 01e86afaf..90f1a290b 100644
--- a/include/Nazara/Math/Ray.hpp
+++ b/include/Nazara/Math/Ray.hpp
@@ -77,8 +77,8 @@ namespace Nz
 	typedef Ray<double> Rayd;
 	typedef Ray<float> Rayf;
 
-	template<typename T> bool Serialize(SerializationContext& context, const Ray<T>& ray);
-	template<typename T> bool Unserialize(SerializationContext& context, Ray<T>* ray);
+	template<typename T> bool Serialize(SerializationContext& context, const Ray<T>& ray, TypeTag<Ray<T>>);
+	template<typename T> bool Unserialize(SerializationContext& context, Ray<T>* ray, TypeTag<Ray<T>>);
 }
 
 template<typename T> std::ostream& operator<<(std::ostream& out, const Nz::Ray<T>& vec);
diff --git a/include/Nazara/Math/Ray.inl b/include/Nazara/Math/Ray.inl
index 813226bb1..673dca796 100644
--- a/include/Nazara/Math/Ray.inl
+++ b/include/Nazara/Math/Ray.inl
@@ -772,7 +772,7 @@ namespace Nz
 	* \param ray Input Ray
 	*/
 	template<typename T>
-	bool Serialize(SerializationContext& context, const Ray<T>& ray)
+	bool Serialize(SerializationContext& context, const Ray<T>& ray, TypeTag<Ray<T>>)
 	{
 		if (!Serialize(context, ray.origin))
 			return false;
@@ -791,7 +791,7 @@ namespace Nz
 	* \param ray Output Ray
 	*/
 	template<typename T>
-	bool Unserialize(SerializationContext& context, Ray<T>* ray)
+	bool Unserialize(SerializationContext& context, Ray<T>* ray, TypeTag<Ray<T>>)
 	{
 		if (!Unserialize(context, &ray->origin))
 			return false;
diff --git a/include/Nazara/Math/Rect.hpp b/include/Nazara/Math/Rect.hpp
index 9ca7f2ef5..fa61abe05 100644
--- a/include/Nazara/Math/Rect.hpp
+++ b/include/Nazara/Math/Rect.hpp
@@ -94,8 +94,8 @@ namespace Nz
 	typedef Rect<Int32> Recti32;
 	typedef Rect<UInt32> Rectui32;
 
-	template<typename T> bool Serialize(SerializationContext& context, const Rect<T>& rect);
-	template<typename T> bool Unserialize(SerializationContext& context, Rect<T>* rect);
+	template<typename T> bool Serialize(SerializationContext& context, const Rect<T>& rect, TypeTag<Rect<T>>);
+	template<typename T> bool Unserialize(SerializationContext& context, Rect<T>* rect, TypeTag<Rect<T>>);
 }
 
 template<typename T>
diff --git a/include/Nazara/Math/Rect.inl b/include/Nazara/Math/Rect.inl
index f5d96c249..93b6e6d79 100644
--- a/include/Nazara/Math/Rect.inl
+++ b/include/Nazara/Math/Rect.inl
@@ -808,7 +808,7 @@ namespace Nz
 	* \param rect Input Rect
 	*/
 	template<typename T>
-	bool Serialize(SerializationContext& context, const Rect<T>& rect)
+	bool Serialize(SerializationContext& context, const Rect<T>& rect, TypeTag<Rect<T>>)
 	{
 		if (!Serialize(context, rect.x))
 			return false;
@@ -833,7 +833,7 @@ namespace Nz
 	* \param rect Output Rect
 	*/
 	template<typename T>
-	bool Unserialize(SerializationContext& context, Rect<T>* rect)
+	bool Unserialize(SerializationContext& context, Rect<T>* rect, TypeTag<Rect<T>>)
 	{
 		if (!Unserialize(context, &rect->x))
 			return false;
diff --git a/include/Nazara/Math/Sphere.hpp b/include/Nazara/Math/Sphere.hpp
index cfa693507..938da93be 100644
--- a/include/Nazara/Math/Sphere.hpp
+++ b/include/Nazara/Math/Sphere.hpp
@@ -81,8 +81,8 @@ namespace Nz
 	typedef Sphere<double> Sphered;
 	typedef Sphere<float> Spheref;
 
-	template<typename T> bool Serialize(SerializationContext& context, const Sphere<T>& sphere);
-	template<typename T> bool Unserialize(SerializationContext& context, Sphere<T>* sphere);
+	template<typename T> bool Serialize(SerializationContext& context, const Sphere<T>& sphere, TypeTag<Sphere<T>>);
+	template<typename T> bool Unserialize(SerializationContext& context, Sphere<T>* sphere, TypeTag<Sphere<T>>);
 }
 
 template<typename T>
diff --git a/include/Nazara/Math/Sphere.inl b/include/Nazara/Math/Sphere.inl
index 48930be94..643fcee82 100644
--- a/include/Nazara/Math/Sphere.inl
+++ b/include/Nazara/Math/Sphere.inl
@@ -623,7 +623,7 @@ namespace Nz
 	* \param sphere Input Sphere
 	*/
 	template<typename T>
-	bool Serialize(SerializationContext& context, const Sphere<T>& sphere)
+	bool Serialize(SerializationContext& context, const Sphere<T>& sphere, TypeTag<Sphere<T>>)
 	{
 		if (!Serialize(context, sphere.x))
 			return false;
@@ -648,7 +648,7 @@ namespace Nz
 	* \param sphere Output Sphere
 	*/
 	template<typename T>
-	bool Unserialize(SerializationContext& context, Sphere<T>* sphere)
+	bool Unserialize(SerializationContext& context, Sphere<T>* sphere, TypeTag<Sphere<T>>)
 	{
 		if (!Unserialize(context, &sphere->x))
 			return false;
diff --git a/include/Nazara/Math/Vector2.hpp b/include/Nazara/Math/Vector2.hpp
index d68268dbf..b3ef521de 100644
--- a/include/Nazara/Math/Vector2.hpp
+++ b/include/Nazara/Math/Vector2.hpp
@@ -103,15 +103,15 @@ namespace Nz
 			T x, y;
 	};
 
-	typedef Vector2<double> Vector2d;
-	typedef Vector2<float> Vector2f;
-	typedef Vector2<int> Vector2i;
-	typedef Vector2<unsigned int> Vector2ui;
-	typedef Vector2<Int32> Vector2i32;
-	typedef Vector2<UInt32> Vector2ui32;
-
 	template<typename T> bool Serialize(SerializationContext& context, const Vector2<T>& vector);
 	template<typename T> bool Unserialize(SerializationContext& context, Vector2<T>* vector);
+	using Vector2d = Vector2<double>;
+	using Vector2f = Vector2<float>;
+	using Vector2i = Vector2<int>;
+	using Vector2ui = Vector2<unsigned int>;
+	using Vector2i32 = Vector2<Int32>;
+	using Vector2ui32 = Vector2<UInt32>;
+
 }
 
 template<typename T> std::ostream& operator<<(std::ostream& out, const Nz::Vector2<T>& vec);
diff --git a/include/Nazara/Math/Vector2.inl b/include/Nazara/Math/Vector2.inl
index f88a82dbd..c33af8102 100644
--- a/include/Nazara/Math/Vector2.inl
+++ b/include/Nazara/Math/Vector2.inl
@@ -961,7 +961,7 @@ namespace Nz
 	* \param vector Input Vector2
 	*/
 	template<typename T> 
-	bool Serialize(SerializationContext& context, const Vector2<T>& vector)
+	bool Serialize(SerializationContext& context, const Vector2<T>& vector, TypeTag<Vector2<T>>)
 	{
 		if (!Serialize(context, vector.x))
 			return false;
@@ -980,7 +980,7 @@ namespace Nz
 	* \param vector Output Vector2
 	*/
 	template<typename T>
-	bool Unserialize(SerializationContext& context, Vector2<T>* vector)
+	bool Unserialize(SerializationContext& context, Vector2<T>* vector, TypeTag<Vector2<T>>)
 	{
 		if (!Unserialize(context, &vector->x))
 			return false;
diff --git a/include/Nazara/Math/Vector3.hpp b/include/Nazara/Math/Vector3.hpp
index bbc65cede..6f535b9c9 100644
--- a/include/Nazara/Math/Vector3.hpp
+++ b/include/Nazara/Math/Vector3.hpp
@@ -132,8 +132,8 @@ namespace Nz
 	typedef Vector3<Int32> Vector3i32;
 	typedef Vector3<UInt32> Vector3ui32;
 
-	template<typename T> bool Serialize(SerializationContext& context, const Vector3<T>& vector);
-	template<typename T> bool Unserialize(SerializationContext& context, Vector3<T>* vector);
+	template<typename T> bool Serialize(SerializationContext& context, const Vector3<T>& vector, TypeTag<Vector3<T>>);
+	template<typename T> bool Unserialize(SerializationContext& context, Vector3<T>* vector, TypeTag<Vector3<T>>);
 }
 
 template<typename T> std::ostream& operator<<(std::ostream& out, const Nz::Vector3<T>& vec);
diff --git a/include/Nazara/Math/Vector3.inl b/include/Nazara/Math/Vector3.inl
index 38291fc12..8ed7c6977 100644
--- a/include/Nazara/Math/Vector3.inl
+++ b/include/Nazara/Math/Vector3.inl
@@ -1248,7 +1248,7 @@ namespace Nz
 	* \param vector Input Vector3
 	*/
 	template<typename T>
-	bool Serialize(SerializationContext& context, const Vector3<T>& vector)
+	bool Serialize(SerializationContext& context, const Vector3<T>& vector, TypeTag<Vector3<T>>)
 	{
 		if (!Serialize(context, vector.x))
 			return false;
@@ -1270,7 +1270,7 @@ namespace Nz
 	* \param vector Output Vector3
 	*/
 	template<typename T>
-	bool Unserialize(SerializationContext& context, Vector3<T>* vector)
+	bool Unserialize(SerializationContext& context, Vector3<T>* vector, TypeTag<Vector3<T>>)
 	{
 		if (!Unserialize(context, &vector->x))
 			return false;
diff --git a/include/Nazara/Math/Vector4.hpp b/include/Nazara/Math/Vector4.hpp
index 2c8005fc0..5c419fc15 100644
--- a/include/Nazara/Math/Vector4.hpp
+++ b/include/Nazara/Math/Vector4.hpp
@@ -108,8 +108,8 @@ namespace Nz
 	typedef Vector4<Int32> Vector4i32;
 	typedef Vector4<UInt32> Vector4ui32;
 
-	template<typename T> bool Serialize(SerializationContext& context, const Vector4<T>& vector);
-	template<typename T> bool Unserialize(SerializationContext& context, Vector4<T>* vector);
+	template<typename T> bool Serialize(SerializationContext& context, const Vector4<T>& vector, TypeTag<Vector4<T>>);
+	template<typename T> bool Unserialize(SerializationContext& context, Vector4<T>* vector, TypeTag<Vector4<T>>);
 }
 
 template<typename T> std::ostream& operator<<(std::ostream& out, const Nz::Vector4<T>& vec);
diff --git a/include/Nazara/Math/Vector4.inl b/include/Nazara/Math/Vector4.inl
index ffaf284d2..69d0b513f 100644
--- a/include/Nazara/Math/Vector4.inl
+++ b/include/Nazara/Math/Vector4.inl
@@ -1011,7 +1011,7 @@ namespace Nz
 	* \param vector Input Vector3
 	*/
 	template<typename T>
-	bool Serialize(SerializationContext& context, const Vector4<T>& vector)
+	bool Serialize(SerializationContext& context, const Vector4<T>& vector, TypeTag<Vector4<T>>)
 	{
 		if (!Serialize(context, vector.x))
 			return false;
@@ -1036,7 +1036,7 @@ namespace Nz
 	* \param vector Output Vector3
 	*/
 	template<typename T>
-	bool Unserialize(SerializationContext& context, Vector4<T>* vector)
+	bool Unserialize(SerializationContext& context, Vector4<T>* vector, TypeTag<Vector4<T>>)
 	{
 		if (!Unserialize(context, &vector->x))
 			return false;
diff --git a/src/Nazara/Core/SerializationContext.cpp b/src/Nazara/Core/SerializationContext.cpp
index e1665a416..5949281e3 100644
--- a/src/Nazara/Core/SerializationContext.cpp
+++ b/src/Nazara/Core/SerializationContext.cpp
@@ -28,7 +28,7 @@ namespace Nz
 			ResetBitPosition();
 
 			// Serialize will reset the bit position
-			if (!Serialize<UInt8>(*this, currentByte))
+			if (!Serialize(*this, currentByte))
 				NazaraWarning("Failed to flush bits");
 		}
 	}
diff --git a/src/Nazara/Core/String.cpp b/src/Nazara/Core/String.cpp
index 7a5b01d19..9e4e2ae32 100644
--- a/src/Nazara/Core/String.cpp
+++ b/src/Nazara/Core/String.cpp
@@ -5932,7 +5932,7 @@ namespace Nz
 	* \param context Context of serialization
 	* \param string String to serialize
 	*/
-	bool Serialize(SerializationContext& context, const String& string)
+	bool Serialize(SerializationContext& context, const String& string, TypeTag<String>)
 	{
 		if (!Serialize(context, UInt32(string.GetSize())))
 			return false;
@@ -5947,7 +5947,7 @@ namespace Nz
 	* \param context Context of unserialization
 	* \param string String to unserialize
 	*/
-	bool Unserialize(SerializationContext& context, String* string)
+	bool Unserialize(SerializationContext& context, String* string, TypeTag<String>)
 	{
 		UInt32 size;
 		if (!Unserialize(context, &size))