diff --git a/src/emulator/memory_manager.cpp b/src/emulator/memory_manager.cpp
index 41064f4c..abd5405f 100644
--- a/src/emulator/memory_manager.cpp
+++ b/src/emulator/memory_manager.cpp
@@ -63,30 +63,33 @@ namespace
 	}
 }
 
-static void serialize(utils::buffer_serializer& buffer, const memory_manager::committed_region& region)
+namespace utils
 {
-	buffer.write<uint64_t>(region.length);
-	buffer.write(region.pemissions);
-}
+	static void serialize(buffer_serializer& buffer, const memory_manager::committed_region& region)
+	{
+		buffer.write<uint64_t>(region.length);
+		buffer.write(region.pemissions);
+	}
 
-static void deserialize(utils::buffer_deserializer& buffer, memory_manager::committed_region& region)
-{
-	region.length = static_cast<size_t>(buffer.read<uint64_t>());
-	region.pemissions = buffer.read<memory_permission>();
-}
+	static void deserialize(buffer_deserializer& buffer, memory_manager::committed_region& region)
+	{
+		region.length = static_cast<size_t>(buffer.read<uint64_t>());
+		region.pemissions = buffer.read<memory_permission>();
+	}
 
-static void serialize(utils::buffer_serializer& buffer, const memory_manager::reserved_region& region)
-{
-	buffer.write(region.is_mmio);
-	buffer.write<uint64_t>(region.length);
-	buffer.write_map(region.committed_regions);
-}
+	static void serialize(buffer_serializer& buffer, const memory_manager::reserved_region& region)
+	{
+		buffer.write(region.is_mmio);
+		buffer.write<uint64_t>(region.length);
+		buffer.write_map(region.committed_regions);
+	}
 
-static void deserialize(utils::buffer_deserializer& buffer, memory_manager::reserved_region& region)
-{
-	buffer.read(region.is_mmio);
-	region.length = static_cast<size_t>(buffer.read<uint64_t>());
-	buffer.read_map(region.committed_regions);
+	static void deserialize(buffer_deserializer& buffer, memory_manager::reserved_region& region)
+	{
+		buffer.read(region.is_mmio);
+		region.length = static_cast<size_t>(buffer.read<uint64_t>());
+		buffer.read_map(region.committed_regions);
+	}
 }
 
 void memory_manager::serialize_memory_state(utils::buffer_serializer& buffer, const bool is_snapshot) const
diff --git a/src/emulator/serialization.hpp b/src/emulator/serialization.hpp
index e3dd8612..c75dcb74 100644
--- a/src/emulator/serialization.hpp
+++ b/src/emulator/serialization.hpp
@@ -9,11 +9,6 @@
 #include <functional>
 #include <typeindex>
 
-#ifndef WIN32
-inline void serialize() {}
-inline void deserialize() {}
-#endif
-
 namespace utils
 {
 	class buffer_serializer;
@@ -43,7 +38,7 @@ namespace utils
 		};
 
 		template <typename T>
-		struct has_serialize_function<T, std::void_t<decltype(::serialize(std::declval<buffer_serializer&>(),
+		struct has_serialize_function<T, std::void_t<decltype(serialize(std::declval<buffer_serializer&>(),
 		                                                                  std::declval<const std::remove_cvref_t<T>&>())
 		                              )>>
 			: std::true_type
@@ -56,7 +51,7 @@ namespace utils
 		};
 
 		template <typename T>
-		struct has_deserialize_function<T, std::void_t<decltype(::deserialize(
+		struct has_deserialize_function<T, std::void_t<decltype(deserialize(
 			                                std::declval<buffer_deserializer&>(),
 			                                std::declval<std::remove_cvref_t<T>&>()))>>
 			: std::true_type
@@ -142,7 +137,7 @@ namespace utils
 			}
 			else if constexpr (detail::has_deserialize_function<T>::value)
 			{
-				::deserialize(*this, object);
+				deserialize(*this, object);
 			}
 			else if constexpr (is_trivially_copyable)
 			{
@@ -365,7 +360,7 @@ namespace utils
 			}
 			else if constexpr (detail::has_serialize_function<T>::value)
 			{
-				::serialize(*this, object);
+				serialize(*this, object);
 			}
 			else if constexpr (is_trivially_copyable)
 			{
diff --git a/src/emulator/serialization_helper.hpp b/src/emulator/serialization_helper.hpp
index a1d2d8bd..0d6f58d2 100644
--- a/src/emulator/serialization_helper.hpp
+++ b/src/emulator/serialization_helper.hpp
@@ -5,40 +5,43 @@
 #include <chrono>
 #include <filesystem>
 
-inline void serialize(utils::buffer_serializer& buffer, const std::chrono::steady_clock::time_point& tp)
+namespace utils
 {
-	buffer.write(tp.time_since_epoch().count());
-}
-
-inline void deserialize(utils::buffer_deserializer& buffer, std::chrono::steady_clock::time_point& tp)
-{
-	using time_point = std::chrono::steady_clock::time_point;
-	using duration = time_point::duration;
-
-	const auto count = buffer.read<duration::rep>();
-	tp = time_point{duration{count}};
-}
-
-inline void serialize(utils::buffer_serializer& buffer, const std::chrono::system_clock::time_point& tp)
-{
-	buffer.write(tp.time_since_epoch().count());
-}
-
-inline void deserialize(utils::buffer_deserializer& buffer, std::chrono::system_clock::time_point& tp)
-{
-	using time_point = std::chrono::system_clock::time_point;
-	using duration = time_point::duration;
-
-	const auto count = buffer.read<duration::rep>();
-	tp = time_point{duration{count}};
-}
-
-inline void serialize(utils::buffer_serializer& buffer, const std::filesystem::path& path)
-{
-	buffer.write_string<char16_t>(path.u16string());
-}
-
-inline void deserialize(utils::buffer_deserializer& buffer, std::filesystem::path& path)
-{
-	path = buffer.read_string<char16_t>();
+	inline void serialize(buffer_serializer& buffer, const std::chrono::steady_clock::time_point& tp)
+	{
+		buffer.write(tp.time_since_epoch().count());
+	}
+
+	inline void deserialize(buffer_deserializer& buffer, std::chrono::steady_clock::time_point& tp)
+	{
+		using time_point = std::chrono::steady_clock::time_point;
+		using duration = time_point::duration;
+
+		const auto count = buffer.read<duration::rep>();
+		tp = time_point{duration{count}};
+	}
+
+	inline void serialize(buffer_serializer& buffer, const std::chrono::system_clock::time_point& tp)
+	{
+		buffer.write(tp.time_since_epoch().count());
+	}
+
+	inline void deserialize(buffer_deserializer& buffer, std::chrono::system_clock::time_point& tp)
+	{
+		using time_point = std::chrono::system_clock::time_point;
+		using duration = time_point::duration;
+
+		const auto count = buffer.read<duration::rep>();
+		tp = time_point{duration{count}};
+	}
+
+	inline void serialize(buffer_serializer& buffer, const std::filesystem::path& path)
+	{
+		buffer.write_string<char16_t>(path.u16string());
+	}
+
+	inline void deserialize(buffer_deserializer& buffer, std::filesystem::path& path)
+	{
+		path = buffer.read_string<char16_t>();
+	}
 }
diff --git a/src/windows-emulator/handles.hpp b/src/windows-emulator/handles.hpp
index 4be1a622..35362a4f 100644
--- a/src/windows-emulator/handles.hpp
+++ b/src/windows-emulator/handles.hpp
@@ -42,14 +42,17 @@ union handle
 	std::uint64_t h;
 };
 
-inline void serialize(utils::buffer_serializer& buffer, const handle& h)
+namespace utils
 {
-	buffer.write(h.bits);
-}
+	inline void serialize(buffer_serializer& buffer, const handle& h)
+	{
+		buffer.write(h.bits);
+	}
 
-inline void deserialize(utils::buffer_deserializer& buffer, handle& h)
-{
-	buffer.read(h.bits);
+	inline void deserialize(buffer_deserializer& buffer, handle& h)
+	{
+		buffer.read(h.bits);
+	}
 }
 
 inline bool operator==(const handle& h1, const handle& h2)
diff --git a/src/windows-emulator/kusd_mmio.cpp b/src/windows-emulator/kusd_mmio.cpp
index 80b2033e..3a2c0ca3 100644
--- a/src/windows-emulator/kusd_mmio.cpp
+++ b/src/windows-emulator/kusd_mmio.cpp
@@ -88,15 +88,18 @@ namespace
 	}
 }
 
-inline void serialize(utils::buffer_serializer& buffer, const KUSER_SHARED_DATA64& kusd)
+namespace utils
 {
-	static_assert(KUSD_SIZE == sizeof(kusd));
-	buffer.write(&kusd, KUSD_SIZE);
-}
+	inline void serialize(buffer_serializer& buffer, const KUSER_SHARED_DATA64& kusd)
+	{
+		static_assert(KUSD_SIZE == sizeof(kusd));
+		buffer.write(&kusd, KUSD_SIZE);
+	}
 
-inline void deserialize(utils::buffer_deserializer& buffer, KUSER_SHARED_DATA64& kusd)
-{
-	buffer.read(&kusd, KUSD_SIZE);
+	inline void deserialize(buffer_deserializer& buffer, KUSER_SHARED_DATA64& kusd)
+	{
+		buffer.read(&kusd, KUSD_SIZE);
+	}
 }
 
 kusd_mmio::kusd_mmio(x64_emulator& emu, process_context& process)
diff --git a/src/windows-emulator/module/module_manager.cpp b/src/windows-emulator/module/module_manager.cpp
index 477dcc49..d3a8144e 100644
--- a/src/windows-emulator/module/module_manager.cpp
+++ b/src/windows-emulator/module/module_manager.cpp
@@ -19,46 +19,49 @@ namespace
 	}
 }
 
-static void serialize(utils::buffer_serializer& buffer, const exported_symbol& sym)
+namespace utils
 {
-	buffer.write(sym.name);
-	buffer.write(sym.ordinal);
-	buffer.write(sym.rva);
-	buffer.write(sym.address);
-}
+	static void serialize(buffer_serializer& buffer, const exported_symbol& sym)
+	{
+		buffer.write(sym.name);
+		buffer.write(sym.ordinal);
+		buffer.write(sym.rva);
+		buffer.write(sym.address);
+	}
 
-static void deserialize(utils::buffer_deserializer& buffer, exported_symbol& sym)
-{
-	buffer.read(sym.name);
-	buffer.read(sym.ordinal);
-	buffer.read(sym.rva);
-	buffer.read(sym.address);
-}
+	static void deserialize(buffer_deserializer& buffer, exported_symbol& sym)
+	{
+		buffer.read(sym.name);
+		buffer.read(sym.ordinal);
+		buffer.read(sym.rva);
+		buffer.read(sym.address);
+	}
 
-static void serialize(utils::buffer_serializer& buffer, const mapped_module& mod)
-{
-	buffer.write_string(mod.name);
-	buffer.write(mod.path.u16string());
+	static void serialize(buffer_serializer& buffer, const mapped_module& mod)
+	{
+		buffer.write_string(mod.name);
+		buffer.write(mod.path.u16string());
 
-	buffer.write(mod.image_base);
-	buffer.write(mod.size_of_image);
-	buffer.write(mod.entry_point);
+		buffer.write(mod.image_base);
+		buffer.write(mod.size_of_image);
+		buffer.write(mod.entry_point);
 
-	buffer.write_vector(mod.exports);
-	buffer.write_map(mod.address_names);
-}
+		buffer.write_vector(mod.exports);
+		buffer.write_map(mod.address_names);
+	}
 
-static void deserialize(utils::buffer_deserializer& buffer, mapped_module& mod)
-{
-	mod.name = buffer.read_string();
-	mod.path = buffer.read_string<std::u16string::value_type>();
+	static void deserialize(buffer_deserializer& buffer, mapped_module& mod)
+	{
+		mod.name = buffer.read_string();
+		mod.path = buffer.read_string<std::u16string::value_type>();
 
-	buffer.read(mod.image_base);
-	buffer.read(mod.size_of_image);
-	buffer.read(mod.entry_point);
+		buffer.read(mod.image_base);
+		buffer.read(mod.size_of_image);
+		buffer.read(mod.entry_point);
 
-	buffer.read_vector(mod.exports);
-	buffer.read_map(mod.address_names);
+		buffer.read_vector(mod.exports);
+		buffer.read_map(mod.address_names);
+	}
 }
 
 module_manager::module_manager(emulator& emu)