diff --git a/CMake/Modules/FindMono.cmake b/CMake/Modules/FindMono.cmake
index 70c8f48..1d68550 100644
--- a/CMake/Modules/FindMono.cmake
+++ b/CMake/Modules/FindMono.cmake
@@ -18,9 +18,9 @@ else()
 	set(MONO_N "monosgen-2.0")
 endif()
 
-set(MONO_LIBRARIES   "${MONO_N}.lib")
+find_library(MONO_LIBRARIES ${MONO_N} PATHS ${MONO_LIBRARY_DIR})
 
 message("Mono Path: ${MONO_PATH}")
-# message(${MONO_INCLUDE_DIR})
-# message(${MONO_LIBRARY_DIR})
-# message(${MONO_LIBRARIES})
\ No newline at end of file
+#message(${MONO_INCLUDE_DIR})
+#message(${MONO_LIBRARY_DIR})
+#message(${MONO_LIBRARIES})
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7beaf5b..822fbf0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -165,7 +165,7 @@ list(APPEND OE_LIBRARIES
 	FreeImage
 	xsc_core
 	assimp
-	${MONO_LIBRARY_DIR}/${MONO_LIBRARIES}
+	${MONO_LIBRARIES}
 )
 list(APPEND OE_LIBRARIES_INC
 	${freetype_SOURCE_DIR}/include
diff --git a/Code/include/OE/Engine/Component.hpp b/Code/include/OE/Engine/Component.hpp
index 923264f..a6552ef 100644
--- a/Code/include/OE/Engine/Component.hpp
+++ b/Code/include/OE/Engine/Component.hpp
@@ -3,11 +3,15 @@
 
 #include "OE/Config.hpp"
 
+#include "OE/Meta/NativeReflection.hpp"
+
 namespace OrbitEngine {	namespace Engine {
 	class Transform;
 	class SceneObject;
 
 	class Component {
+		NATIVE_REFLECTION
+
 	public:
 		virtual ~Component();
 
diff --git a/Code/include/OE/Engine/MemoryDomain.hpp b/Code/include/OE/Engine/MemoryDomain.hpp
index 907cd64..9334975 100644
--- a/Code/include/OE/Engine/MemoryDomain.hpp
+++ b/Code/include/OE/Engine/MemoryDomain.hpp
@@ -5,7 +5,7 @@
 #include <math.h>
 
 #include "OE/Meta/NativeType.hpp"
-#include "OE/Memory/Allocator.hpp"
+#include "OE/Memory/MemoryPool.hpp"
 
 namespace std {
 	template <>
@@ -26,11 +26,6 @@ namespace OrbitEngine {
 	class WeakPtr;
 	template<typename T>
 	class StrongPtr;
-
-	namespace Memory {
-		template<typename T>
-		class TrackedMemoryPool;
-	}
 }
 
 namespace OrbitEngine { namespace Engine {
@@ -43,19 +38,23 @@ namespace OrbitEngine { namespace Engine {
 		static MemoryDomain* Get();
 
 		template<typename T>
-		StrongPtr<T> Allocate();
+		StrongPtr<T> Create();
 		template<typename T>
-		void Deallocate(Ptr<T>& object);
+		void Destroy(Ptr<T>& object);
 		template<typename T>
 		const std::vector<WeakPtr<T>>& GetAll();
 
 	private:
 		std::unordered_map<Meta::NativeType*, Memory::Allocator*> m_Allocators;
+		std::unordered_map<Meta::NativeType*, void* /* std::vector<WeakPtr<T>> */> m_Objects;
+
+		template<typename T>
+		std::vector<WeakPtr<T>>& GetObjects();
 
 		template<typename T>
-		Memory::TrackedMemoryPool<T>* GetAllocator();
+		Memory::MemoryPool* GetAllocator();
 		template<typename T>
-		Memory::TrackedMemoryPool<T>* CreateAllocator();
+		Memory::MemoryPool* CreateAllocator();
 	};
 } }
 
diff --git a/Code/include/OE/Engine/MemoryDomain.inl b/Code/include/OE/Engine/MemoryDomain.inl
index 339804b..2d522e7 100644
--- a/Code/include/OE/Engine/MemoryDomain.inl
+++ b/Code/include/OE/Engine/MemoryDomain.inl
@@ -6,61 +6,98 @@
 #include "OE/Memory/Ptrs.hpp"
 #include "OE/Memory/MemoryPool.hpp"
 
+#include "OE/Misc/Log.hpp"
+
 namespace OrbitEngine { namespace Engine {
 	
 	template<typename T>
-	inline StrongPtr<T> MemoryDomain::Allocate()
+	inline StrongPtr<T> MemoryDomain::Create()
 	{
 		Meta::NativeType* type = Meta::NativeTypeResolver<T>::Get();
-		Memory::TrackedMemoryPool<T>* allocator = GetAllocator<T>();
+		OE_ASSERT(type);
+
+		Memory::MemoryPool* allocator = GetAllocator<T>();
 		if (!allocator)
 			allocator = CreateAllocator<T>();
 
-		StrongPtr<T> object = allocator->AllocatePtr();
-		if (object)
-			type->Construct(object.Get());
-		return object;
+		void* obj = allocator->Allocate();
+		if (obj == 0)
+			return StrongPtr<T>();
+		type->Construct(obj);
+
+		std::vector<WeakPtr<T>>& objs = GetObjects<T>();
+
+		StrongPtr<T> ptr = StrongPtr<T>(static_cast<T*>(obj));
+
+		/* -- */
+		auto it = std::lower_bound(objs.begin(), objs.end(), WeakPtr<T>(ptr), [](const WeakPtr<T>& lhs, const WeakPtr<T>& rhs) {
+			return lhs.Get() < rhs.Get();
+		});
+		objs.insert(it, ptr);
+		/* -- */
+
+		return ptr;
 	}
 
 	template<typename T>
-	inline void MemoryDomain::Deallocate(Ptr<T>& object)
+	inline void MemoryDomain::Destroy(Ptr<T>& object)
 	{
 		Meta::NativeType* type = Meta::NativeTypeResolver<T>::Get();
-		Memory::TrackedMemoryPool<T>* allocator = GetAllocator<T>();
-		OE_ASSERT(allocator)
+		OE_ASSERT(type);
+		Memory::MemoryPool* allocator = GetAllocator<T>();
+		OE_ASSERT(allocator);
 
 		type->Destruct(object.Get());
-		allocator->DeallocatePtr(object);
+		allocator->Deallocate(object.Get());
+
+		std::vector<WeakPtr<T>>& objs = GetObjects<T>();
+
+		/* -- */
+		auto it = std::lower_bound(objs.begin(), objs.end(), WeakPtr<T>(object), [](const WeakPtr<T>& lhs, const WeakPtr<T>& rhs) {
+			return lhs.Get() < rhs.Get();
+		});
+		objs.erase(it);
+		/* -- */
 	}
 
 	template<typename T>
 	inline const std::vector<WeakPtr<T>>& MemoryDomain::GetAll()
 	{
-		return GetAllocator<T>()->GetAll();
+		return GetObjects<T>();
 	}
 
 	template<typename T>
-	inline Memory::TrackedMemoryPool<T>* MemoryDomain::GetAllocator()
+	inline Memory::MemoryPool* MemoryDomain::GetAllocator()
 	{
-		Meta::NativeType* type = Meta::NativeTypeResolver<T>::Get();
-		OE_ASSERT(type)
-		auto it = m_Allocators.find(type);
+		auto it = m_Allocators.find(Meta::NativeTypeResolver<T>::Get());
 		if (it != m_Allocators.end())
-			return static_cast<Memory::TrackedMemoryPool<T>*>((*it).second);
+			return static_cast<Memory::MemoryPool*>((*it).second);
 		return nullptr;
 	}
 
 	template<typename T>
-	inline Memory::TrackedMemoryPool<T>* MemoryDomain::CreateAllocator()
+	inline Memory::MemoryPool* MemoryDomain::CreateAllocator()
 	{
-		Meta::NativeType* type = Meta::NativeTypeResolver<T>::Get();
-		OE_ASSERT(type)
-			Memory::TrackedMemoryPool<T>* allocator = new Memory::TrackedMemoryPool<T>(100);
+		const int capacity = 100;
 
-		m_Allocators.insert(std::make_pair(type, allocator));
+		Memory::MemoryPool* allocator = new Memory::MemoryPool(sizeof(T), capacity);
+
+		m_Allocators.insert(std::make_pair(Meta::NativeTypeResolver<T>::Get(), allocator));
+		GetObjects<T>().reserve(capacity);
 
 		return allocator;
 	}
+
+	template<typename T>
+	inline std::vector<WeakPtr<T>>& MemoryDomain::GetObjects()
+	{
+		Meta::NativeType* type = Meta::NativeTypeResolver<T>::Get();
+		OE_ASSERT(type);
+		auto it = m_Objects.find(type);
+		if (it == m_Objects.end())
+			m_Objects[type] = new std::vector<WeakPtr<T>>();
+		return *static_cast<std::vector<WeakPtr<T>>*>(m_Objects[type]);
+	}
 } }
 
 #endif
\ No newline at end of file
diff --git a/Code/include/OE/Engine/SceneObject.hpp b/Code/include/OE/Engine/SceneObject.hpp
index c2355ac..610ffe2 100644
--- a/Code/include/OE/Engine/SceneObject.hpp
+++ b/Code/include/OE/Engine/SceneObject.hpp
@@ -10,6 +10,7 @@
 
 #include "OE/Config.hpp"
 #include "OE/Misc/Log.hpp"
+#include "OE/Memory/Ptrs.hpp"
 #include "OE/Engine/Object.hpp"
 #include "OE/Engine/Scene.hpp"
 #include "OE/Engine/Component.hpp"
@@ -33,6 +34,9 @@ namespace OrbitEngine {	namespace Engine {
 		void SetName(const std::string& name);
 		void SetParent(WeakPtr<SceneObject> parent, int position = 99999999);
 
+		template<typename T>
+		WeakPtr<T> AddComponent();
+
 	private:
 		friend class Scene;
 		
@@ -42,7 +46,16 @@ namespace OrbitEngine {	namespace Engine {
 
 		std::string m_Name;
 		std::vector<StrongPtr<SceneObject>> m_Childs;
+		std::vector<StrongPtr<Component>> m_Components;
 	};
+
+	template<typename T>
+	inline WeakPtr<T> SceneObject::AddComponent()
+	{
+		StrongPtr<T> ptr = MemoryDomain::Get()->Create<T>();
+		m_Components.push_back(ptr.template AsStrong<Component>());
+		return ptr;
+	}
 } }
 
 #endif
\ No newline at end of file
diff --git a/Code/include/OE/Engine/TestComponent.hpp b/Code/include/OE/Engine/TestComponent.hpp
index 4ffc69c..2cf6bc1 100644
--- a/Code/include/OE/Engine/TestComponent.hpp
+++ b/Code/include/OE/Engine/TestComponent.hpp
@@ -8,11 +8,15 @@
 #include "OE/Math/Vec3.hpp"
 #include "OE/Math/Vec4.hpp"
 
+#include "OE/Meta/NativeReflection.hpp"
+
 #include "Transform.hpp"
 
 namespace OrbitEngine {	namespace Engine {
 
 	class TestComponent : public Component {
+		NATIVE_REFLECTION
+
 	public:
 		TestComponent();
 		~TestComponent();
diff --git a/Code/include/OE/Engine/Transform.hpp b/Code/include/OE/Engine/Transform.hpp
index dc9ff6e..34a06b4 100644
--- a/Code/include/OE/Engine/Transform.hpp
+++ b/Code/include/OE/Engine/Transform.hpp
@@ -10,6 +10,8 @@
 namespace OrbitEngine {	namespace Engine {
 
 	class Transform : public Component {
+		NATIVE_REFLECTION
+
 	public:
 		Transform();
 		~Transform();
diff --git a/Code/include/OE/Memory/MemoryPool.hpp b/Code/include/OE/Memory/MemoryPool.hpp
index 65e9eea..279787f 100644
--- a/Code/include/OE/Memory/MemoryPool.hpp
+++ b/Code/include/OE/Memory/MemoryPool.hpp
@@ -4,7 +4,6 @@
 #include <vector>
 
 #include "OE/Memory/Allocator.hpp"
-#include "OE/Memory/Ptrs.hpp"
 
 namespace OrbitEngine {	namespace Memory {
 	class MemoryPool : public Allocator {
@@ -23,23 +22,6 @@ namespace OrbitEngine {	namespace Memory {
 		unsigned char* m_Memory;
 		unsigned char* m_Next;
 	};
-	
-	template<typename T>
-	class TrackedMemoryPool : public MemoryPool {
-	public:
-		TrackedMemoryPool(int capacity);
-		virtual ~TrackedMemoryPool();
-
-		StrongPtr<T> AllocatePtr();
-		void DeallocatePtr(Ptr<T>& ptr);
-
-		const std::vector<WeakPtr<T>>& GetAll() const;
-
-	private:
-		std::vector<WeakPtr<T>> m_Used;
-	};
 } }
 
-#include "OE/Memory/MemoryPool.inl"
-
 #endif
\ No newline at end of file
diff --git a/Code/include/OE/Memory/MemoryPool.inl b/Code/include/OE/Memory/MemoryPool.inl
deleted file mode 100644
index 4f162e6..0000000
--- a/Code/include/OE/Memory/MemoryPool.inl
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef MEMORY_MEMORY_POOL_INL
-#define MEMORY_MEMORY_POOL_INL
-
-#include "OE/Memory/MemoryPool.hpp"
-
-namespace OrbitEngine {	namespace Memory {
-
-	template<typename T>
-	inline TrackedMemoryPool<T>::TrackedMemoryPool(int capacity)
-		: MemoryPool(sizeof(T), capacity)
-	{
-		m_Used.reserve(capacity);
-	}
-
-	template<typename T>
-	inline TrackedMemoryPool<T>::~TrackedMemoryPool()
-	{
-		m_Used.clear();
-	}
-
-	template<typename T>
-	inline StrongPtr<T> TrackedMemoryPool<T>::AllocatePtr()
-	{
-		void* obj = MemoryPool::Allocate();
-		if (obj == 0)
-			return StrongPtr<T>();
-
-		StrongPtr<T> ptr = StrongPtr<T>(static_cast<T*>(obj));
-
-		auto it = std::lower_bound(m_Used.begin(), m_Used.end(), WeakPtr<T>(ptr), [](const WeakPtr<T>& lhs, const WeakPtr<T>& rhs) {
-			return lhs.Get() < rhs.Get();
-		});
-
-		m_Used.insert(it, ptr);
-
-		return ptr;
-	}
-
-	template<typename T>
-	inline void TrackedMemoryPool<T>::DeallocatePtr(Ptr<T>& ptr)
-	{
-		MemoryPool::Deallocate(ptr.Get());
-
-		auto it = std::lower_bound(m_Used.begin(), m_Used.end(), WeakPtr<T>(ptr), [](const WeakPtr<T>& lhs, const WeakPtr<T>& rhs) {
-			return lhs.Get() < rhs.Get();
-		});
-		m_Used.erase(it);
-	}
-
-	template<typename T>
-	inline const std::vector<WeakPtr<T>>& TrackedMemoryPool<T>::GetAll() const
-	{
-		return m_Used;
-	}
-} }
-
-#endif
\ No newline at end of file
diff --git a/Code/include/OE/Memory/Ptrs.hpp b/Code/include/OE/Memory/Ptrs.hpp
index dcadc2c..29b98fa 100644
--- a/Code/include/OE/Memory/Ptrs.hpp
+++ b/Code/include/OE/Memory/Ptrs.hpp
@@ -1,12 +1,9 @@
 #ifndef PTRS_HPP
 #define PTRS_HPP
 
-#include "OE/Meta/NativeReflection.hpp"
-#include "OE/Misc/Log.hpp"
-
 namespace OrbitEngine {
-	namespace Engine {
-		class MemoryDomain;
+	namespace Meta {
+		class NativeType;
 	}
 
 	template<typename T>
@@ -14,25 +11,24 @@ namespace OrbitEngine {
 	template<typename T>
 	class WeakPtr;
 
-	namespace internal {
-		struct RefCount {
-			// TODO atomic
-			unsigned int strong = 0;
-			unsigned int weak = 0;
+	struct RefCount {
+		// TODO atomic
+		unsigned int strong = 0;
+		unsigned int weak = 0;
 
-			void Decr();
-			void Incr();
-			void WDecr();
-			void WIncr();
+		void Decr();
+		void Incr();
+		void WDecr();
+		void WIncr();
 
-			void Destroy();
-		};
-	}
+		void Destroy();
+	};
 
 	template<typename T>
 	class Ptr {
 	public:
-		Ptr(T* ptr = 0);
+
+		Ptr(T* ptr = 0, RefCount* ref_count = 0);
 		virtual ~Ptr();
 
 		Meta::NativeType* GetType() const;
@@ -42,52 +38,60 @@ namespace OrbitEngine {
 		T& operator*() const;
 		T* operator->() const;
 		operator bool() const;
-
 		bool operator==(const Ptr& rhs) const;
 		bool operator!=(const Ptr& rhs) const;
 
+		template<typename V>
+		WeakPtr<V> AsWeak();
+		template<typename V>
+		StrongPtr<V> AsStrong();
+
 	protected:
-		internal::RefCount* m_RefCount;
+		RefCount* m_RefCount;
 		T* m_Ptr;
 
+		virtual void BuildFromPtr(const Ptr<T>& ptr);
+
 		friend class StrongPtr<T>;
 		friend class WeakPtr<T>;
 	};
-	
+
 	template<typename T>
 	class StrongPtr : public Ptr<T> {
 	public:
 		StrongPtr(T* ptr = 0);
-		StrongPtr(StrongPtr<T>&& mv);
+		StrongPtr(const Ptr<T>& ptr);
 		StrongPtr(const StrongPtr<T>& ptr);
 		StrongPtr(const WeakPtr<T>& ptr);
+		StrongPtr(StrongPtr<T>&& mv);
 		~StrongPtr();
 
 		StrongPtr<T>& operator=(const StrongPtr<T>& ptr);
 		StrongPtr<T>& operator=(const WeakPtr<T>& ptr);
-
 		StrongPtr<T>& operator=(StrongPtr<T>&& other);
 
 		void Clear() override;
 
-	private:
-		void BuildFromPtr(const Ptr<T>& ptr);
+		void BuildFromPtr(const Ptr<T>& ptr) override;
 	};
 
 	template<typename T>
 	class WeakPtr : public Ptr<T> {
 	public:
+		WeakPtr();
 		WeakPtr(const Ptr<T>& ptr);
 		WeakPtr(const StrongPtr<T>& ptr);
 		WeakPtr(const WeakPtr<T>& ptr);
-		WeakPtr();
+		WeakPtr(WeakPtr<T>&& mv);
 		~WeakPtr();
 
 		WeakPtr<T>& operator=(const StrongPtr<T>& ptr);
 		WeakPtr<T>& operator=(const WeakPtr<T>& ptr);
+		WeakPtr<T>& operator=(WeakPtr<T>&& other);
+
+		void Clear() override;
 
-	private:
-		void BuildFromPtr(const Ptr<T>& ptr);
+		void BuildFromPtr(const Ptr<T>& ptr) override;
 	};
 }
 
diff --git a/Code/include/OE/Memory/Ptrs.inl b/Code/include/OE/Memory/Ptrs.inl
index 2b06ff9..6878e40 100644
--- a/Code/include/OE/Memory/Ptrs.inl
+++ b/Code/include/OE/Memory/Ptrs.inl
@@ -3,47 +3,46 @@
 
 #include "OE/Memory/Ptrs.hpp"
 
+#include "OE/Meta/NativeReflection.hpp"
 #include "OE/Engine/MemoryDomain.hpp"
+#include "OE/Misc/Log.hpp"
 
 namespace OrbitEngine {
 
-	namespace internal {
-		inline void RefCount::Decr()
-		{
-			strong--;
-			if (strong + weak == 0) Destroy();
-		}
+	inline void RefCount::Decr()
+	{
+		strong--;
+		if (strong + weak == 0) Destroy();
+	}
 
-		inline void RefCount::Incr()
-		{
-			strong++;
-		}
+	inline void RefCount::Incr()
+	{
+		strong++;
+	}
 
-		inline void RefCount::WDecr()
-		{
-			weak--;
-			if (strong + weak == 0) Destroy();
-		}
+	inline void RefCount::WDecr()
+	{
+		weak--;
+		if (strong + weak == 0) Destroy();
+	}
 
-		inline void RefCount::WIncr()
-		{
-			weak++;
-		}
+	inline void RefCount::WIncr()
+	{
+		weak++;
+	}
 
-		inline void RefCount::Destroy()
-		{
-			delete this;
-		}
+	inline void RefCount::Destroy()
+	{
+		delete this;
 	}
 
-	// Ptr
 
 	template<typename T>
-	inline Ptr<T>::Ptr(T* ptr)
-		: m_Ptr(ptr), m_RefCount(0)
+	inline Ptr<T>::Ptr(T* ptr, RefCount* ref_count)
+		: m_Ptr(ptr), m_RefCount(ref_count)
 	{
 	}
-
+	
 	template<typename T>
 	inline Ptr<T>::~Ptr()
 	{
@@ -62,6 +61,15 @@ namespace OrbitEngine {
 		m_Ptr = 0;
 	}
 
+	template<typename T>
+	inline void Ptr<T>::BuildFromPtr(const Ptr<T>& ptr)
+	{
+		Clear();
+
+		m_Ptr = ptr.m_Ptr;
+		m_RefCount = ptr.m_RefCount;
+	}
+
 	template<typename T>
 	inline T* Ptr<T>::Get() const
 	{
@@ -100,22 +108,36 @@ namespace OrbitEngine {
 		return !operator==(rhs);
 	}
 
-	// Strong
+	template<typename T>
+	template<typename V>
+	inline WeakPtr<V> Ptr<T>::AsWeak()
+	{
+		return WeakPtr<V>(Ptr<V>(static_cast<V*>(m_Ptr), m_RefCount));
+	}
+
+	template<typename T>
+	template<typename V>
+	inline StrongPtr<V> Ptr<T>::AsStrong()
+	{
+		return StrongPtr<V>(Ptr<V>(static_cast<V*>(m_Ptr), m_RefCount));
+	}
+
 
 	template<typename T>
 	inline StrongPtr<T>::StrongPtr(T* ptr)
 		: Ptr<T>(ptr)
 	{
-		if (ptr) {
-			this->m_RefCount = new internal::RefCount();
+		if (this->m_Ptr) {
+			if (!this->m_RefCount)
+				this->m_RefCount = new RefCount();
 			this->m_RefCount->Incr();
 		}
 	}
 
 	template<typename T>
-	inline StrongPtr<T>::StrongPtr(StrongPtr<T>&& mv)
+	inline StrongPtr<T>::StrongPtr(const Ptr<T>& ptr)
 	{
-		operator=(mv);
+		BuildFromPtr(ptr);
 	}
 
 	template<typename T>
@@ -127,6 +149,13 @@ namespace OrbitEngine {
 	template<typename T>
 	inline StrongPtr<T>::StrongPtr(const WeakPtr<T>& ptr)
 	{
+		BuildFromPtr(ptr);
+	}
+
+	template<typename T>
+	inline StrongPtr<T>::StrongPtr(StrongPtr<T>&& mv)
+	{
+		operator=(mv);
 	}
 
 	template<typename T>
@@ -155,11 +184,7 @@ namespace OrbitEngine {
 		if (this == &other)
 			return *this;
 
-		Clear();
-
-		this->m_Ptr = other.m_Ptr;
-		this->m_RefCount = other.m_RefCount;
-
+		Ptr<T>::BuildFromPtr(other);
 		other.Ptr<T>::Clear();
 
 		return *this;
@@ -172,7 +197,7 @@ namespace OrbitEngine {
 			if (this->m_RefCount->strong == 1) {
 				Engine::MemoryDomain* md = Engine::MemoryDomain::Get();
 				if (md)
-					md->Deallocate(*this);
+					md->Destroy(*this);
 				else
 					delete this->m_Ptr;
 			}
@@ -184,16 +209,18 @@ namespace OrbitEngine {
 	template<typename T>
 	inline void StrongPtr<T>::BuildFromPtr(const Ptr<T>& ptr)
 	{
-		Clear();
-
-		this->m_Ptr = ptr.m_Ptr;
-		this->m_RefCount = ptr.m_RefCount;
+		Ptr<T>::BuildFromPtr(ptr);
 
 		if (this->m_RefCount && this->m_RefCount->strong > 0)
 			this->m_RefCount->Incr();
 	}
 
-	// Weak
+
+	template<typename T>
+	inline WeakPtr<T>::WeakPtr()
+		: Ptr<T>()
+	{
+	}
 
 	template<typename T>
 	inline WeakPtr<T>::WeakPtr(const Ptr<T>& ptr)
@@ -214,17 +241,15 @@ namespace OrbitEngine {
 	}
 
 	template<typename T>
-	inline WeakPtr<T>::WeakPtr()
-		: Ptr<T>()
+	inline WeakPtr<T>::WeakPtr(WeakPtr<T>&& mv)
 	{
+		operator=(mv);
 	}
 
 	template<typename T>
 	inline WeakPtr<T>::~WeakPtr()
 	{
-		if (this->m_RefCount) {
-			this->m_RefCount->WDecr();
-		}
+		Clear();
 	}
 
 	template<typename T>
@@ -242,13 +267,29 @@ namespace OrbitEngine {
 	}
 
 	template<typename T>
-	inline void WeakPtr<T>::BuildFromPtr(const Ptr<T>& ptr)
+	inline WeakPtr<T>& WeakPtr<T>::operator=(WeakPtr<T>&& other)
+	{
+		if (this == &other)
+			return *this;
+
+		Ptr<T>::BuildFromPtr(other);
+		other.Ptr<T>::Clear();
+
+		return *this;
+	}
+
+	template<typename T>
+	inline void WeakPtr<T>::Clear()
 	{
 		if (this->m_RefCount)
 			this->m_RefCount->WDecr();
+		Ptr<T>::Clear();
+	}
 
-		this->m_Ptr = ptr.m_Ptr;
-		this->m_RefCount = ptr.m_RefCount;
+	template<typename T>
+	inline void WeakPtr<T>::BuildFromPtr(const Ptr<T>& ptr)
+	{
+		Ptr<T>::BuildFromPtr(ptr);
 
 		if (this->m_RefCount)
 			this->m_RefCount->WIncr();
diff --git a/Code/include/OE/Meta/NativeReflection.hpp b/Code/include/OE/Meta/NativeReflection.hpp
index 1889f7e..3ec8340 100644
--- a/Code/include/OE/Meta/NativeReflection.hpp
+++ b/Code/include/OE/Meta/NativeReflection.hpp
@@ -48,15 +48,17 @@ namespace OrbitEngine { namespace Meta {
 		static Meta::NativeType Reflection; \
 	private: \
 		static void meta_reflect(Meta::NativeType*); \
+		static void meta_ctor(void* ptr); \
+		static void meta_dctor(void* ptr); \
 
 #define NATIVE_REFLECTION_BEGIN(type) \
-	static void meta_ctor_##type (void* ptr) { new (ptr) type (); } \
-	static void meta_dctor_##type (void* ptr) { static_cast<type*>(ptr)-> type ::~type (); } \
+	void type::meta_ctor (void* ptr) { new (ptr) type (); } \
+	void type::meta_dctor (void* ptr) { static_cast<type*>(ptr)-> type ::~type (); } \
 	Meta::NativeType type::Reflection{type::meta_reflect}; \
 	void type::meta_reflect(Meta::NativeType* t) { \
 		using T = type; \
 		t->SetKind(Meta::Kind::CLASS); \
-		t->SetCtorAndDctor(meta_ctor_##type, meta_dctor_##type); \
+		t->SetCtorAndDctor(meta_ctor, meta_dctor); \
 		t->SetName(#type); \
 		t->SetSize(sizeof(T)); \
 
diff --git a/Code/include/OE/Platform/OpenGL/OpenGL.hpp b/Code/include/OE/Platform/OpenGL/OpenGL.hpp
index f20204b..5e830c3 100644
--- a/Code/include/OE/Platform/OpenGL/OpenGL.hpp
+++ b/Code/include/OE/Platform/OpenGL/OpenGL.hpp
@@ -50,6 +50,7 @@
 		#if OE_WINDOWS
 			#include "OE/Platform/Windows/Windows.hpp"
 		#elif OE_LINUX
+			#include "OE/Platform/X11/X11.hpp"
 			#include <GL/glx.h>
 		#endif
 		#include <GL/gl.h>
diff --git a/Code/src/OE/Engine/Component.cpp b/Code/src/OE/Engine/Component.cpp
index f0df6df..91f5717 100644
--- a/Code/src/OE/Engine/Component.cpp
+++ b/Code/src/OE/Engine/Component.cpp
@@ -30,4 +30,8 @@ namespace OrbitEngine {	namespace Engine {
 	{
 
 	}
+
+	NATIVE_REFLECTION_BEGIN(Component)
+
+	NATIVE_REFLECTION_END()
 } }
\ No newline at end of file
diff --git a/Code/src/OE/Engine/Scene.cpp b/Code/src/OE/Engine/Scene.cpp
index 2a5ddc1..60f629a 100644
--- a/Code/src/OE/Engine/Scene.cpp
+++ b/Code/src/OE/Engine/Scene.cpp
@@ -9,7 +9,7 @@
 namespace OrbitEngine {	namespace Engine {
 
 	Scene::Scene() {
-		m_Root = MemoryDomain::Get()->Allocate<SceneObject>();
+		m_Root = MemoryDomain::Get()->Create<SceneObject>();
 		m_Root->m_Self = m_Root;
 		//m_Root->m_Scene = WeakPtr<Scene>(this);
 		m_Root->SetName("Root");
diff --git a/Code/src/OE/Engine/SceneObject.cpp b/Code/src/OE/Engine/SceneObject.cpp
index 00214a1..4bef152 100644
--- a/Code/src/OE/Engine/SceneObject.cpp
+++ b/Code/src/OE/Engine/SceneObject.cpp
@@ -10,11 +10,14 @@ namespace OrbitEngine {	namespace Engine {
 	SceneObject::SceneObject()
 		: m_Name("SceneObject")
 	{
+		AddComponent<Transform>();
+		AddComponent<TestComponent>();
 	}
 
 	SceneObject::~SceneObject()
 	{
 		m_Childs.clear();
+		m_Components.clear();
 	}
 
 	WeakPtr<Scene> SceneObject::GetScene() const
@@ -46,7 +49,7 @@ namespace OrbitEngine {	namespace Engine {
 
 	WeakPtr<SceneObject> SceneObject::AddChildren()
 	{
-		StrongPtr<SceneObject> sceneObject = MemoryDomain::Get()->Allocate<SceneObject>();
+		StrongPtr<SceneObject> sceneObject = MemoryDomain::Get()->Create<SceneObject>();
 		if (!sceneObject) {
 			OE_LOG_WARNING("Can't allocate more SceneObjects!");
 			return WeakPtr<SceneObject>();
diff --git a/Code/src/OE/Engine/TestComponent.cpp b/Code/src/OE/Engine/TestComponent.cpp
index 58779f5..d4db85c 100644
--- a/Code/src/OE/Engine/TestComponent.cpp
+++ b/Code/src/OE/Engine/TestComponent.cpp
@@ -11,4 +11,8 @@ namespace OrbitEngine {	namespace Engine {
 	{
 
 	}
+
+	NATIVE_REFLECTION_BEGIN(TestComponent)
+		NATIVE_REFLECTION_MEMBER(m_Int)
+	NATIVE_REFLECTION_END()
 } }
\ No newline at end of file
diff --git a/Code/src/OE/Engine/Transform.cpp b/Code/src/OE/Engine/Transform.cpp
index b10a143..eef4e62 100644
--- a/Code/src/OE/Engine/Transform.cpp
+++ b/Code/src/OE/Engine/Transform.cpp
@@ -47,4 +47,7 @@ namespace OrbitEngine {	namespace Engine {
 
 		return m_Matrix;
 	}
+
+	NATIVE_REFLECTION_BEGIN(Transform)
+	NATIVE_REFLECTION_END()
 } }
\ No newline at end of file