diff --git a/Coral.vcxproj b/Coral.vcxproj
index cf959681..0b8b35ea 100644
--- a/Coral.vcxproj
+++ b/Coral.vcxproj
@@ -301,6 +301,7 @@
     <ClCompile Include="Source\Components\Particles\ParticleLightComponent.cpp" />
     <ClCompile Include="Source\Components\Particles\ParticleUtilities.cpp" />
     <ClCompile Include="Source\Core\Device.cpp" />
+    <ClCompile Include="Source\Core\ThreadPool.cpp" />
     <ClCompile Include="Source\Platform\PC\Core\Renderer.cpp" />
     <ClCompile Include="Source\Assets\Core\AssetHandle.cpp" />
     <ClCompile Include="Source\Assets\Importers\AudioImporter.cpp">
@@ -324,7 +325,6 @@
     <ClCompile Include="Source\Systems\Rendering\ParticleRenderingSystem.cpp" />
     <ClCompile Include="Source\Systems\Rendering\StaticMeshRenderingSystem.cpp" />
     <ClCompile Include="Source\UnitTests\AssetHandleUnitTests.cpp" />
-    <ClCompile Include="Source\Utilities\ASync.cpp" />
     <ClCompile Include="Source\Utilities\BVH.cpp" />
     <ClCompile Include="Source\Utilities\Events.cpp" />
     <ClCompile Include="Source\Utilities\Imgui\WorldDetailsPanel.cpp">
@@ -862,13 +862,13 @@
     <ClInclude Include="Include\Components\Particles\ParticleUtilities\ParticleUtilitiesImpl.h" />
     <ClInclude Include="Include\Components\AudioEmitterComponent.h" />
     <ClInclude Include="Include\Core\Renderer.h" />
+    <ClInclude Include="Include\Core\ThreadPool.h" />
     <ClInclude Include="Include\EditorSystems\ThumbnailEditorSystem.h" />
     <ClInclude Include="Include\Systems\AudioSystem.h" />
     <ClInclude Include="Include\Systems\Particles\ParticleLightSystem.h" />
     <ClInclude Include="Include\Systems\Rendering\LightRenderingSystem.h" />
     <ClInclude Include="Include\Systems\Rendering\ParticleRenderingSystem.h" />
     <ClInclude Include="Include\Systems\Rendering\StaticMeshRenderingSystem.h" />
-    <ClInclude Include="Include\Utilities\ASync.h" />
     <ClInclude Include="Include\Utilities\BVH.h" />
     <ClInclude Include="Include\Utilities\Geometry2d.h" />
     <ClInclude Include="Include\EditorSystems\ImporterSystem.h" />
diff --git a/Include/Assets/Level.h b/Include/Assets/Level.h
index 3c166797..3cd797de 100644
--- a/Include/Assets/Level.h
+++ b/Include/Assets/Level.h
@@ -33,9 +33,13 @@ namespace CE
 		Level& operator=(const Level&) = delete;
 
 		void CreateFromWorld(const World& world);
-		World CreateWorld(bool callBeginPlayImmediately) const;
+		void LoadIntoWorld(World& world) const;
 
-		static World CreateDefaultWorld();
+		// Will never return nullptr
+		std::unique_ptr<World> CreateWorld(bool callBeginPlayImmediately) const;
+
+		// Will never return nullptr
+		static std::unique_ptr<World> CreateDefaultWorld();
 
 	protected:
 		void OnSave(AssetSaveInfo& saveInfo) const override;
@@ -71,7 +75,7 @@ namespace CE
 		// when loading the level. Instead of
 		// discarding the world, we return this
 		// one on the first call to CreateWorld
-		mutable std::optional<World> mWorld{};
+		mutable std::unique_ptr<World> mWorld{};
 		mutable std::optional<BinaryGSONObject> mSerializedWorld{};
 
 		friend ReflectAccess;
diff --git a/Include/Assets/Script.h b/Include/Assets/Script.h
index 65e625f8..9f8ccdf5 100644
--- a/Include/Assets/Script.h
+++ b/Include/Assets/Script.h
@@ -96,9 +96,10 @@ namespace CE
 		// so if this ever changes, you'll know exactly where you need to start fixing things.
 		static constexpr bool sIsTypeIdTheSameAsNameHash = true;
 
-		// Each component script secretly gets assigned a field of type entt::entity with this name.
-		// Upon constructing the component, the correct entity id is assigned.
+		// Each component script secretly gets assigned a field of type entt::entity and World* with these names.
+		// Upon constructing the component, the correct entity id and world is assigned.
 		static constexpr Name sNameOfOwnerField = "Owner"_Name;
+		static constexpr Name sNameOfWorldField = "World"_Name;
 
 		void CollectErrors(ScriptErrorInserter inserter) const;
 
diff --git a/Include/Components/GridSpawnerComponent.h b/Include/Components/GridSpawnerComponent.h
index 6fbbea3d..98808827 100644
--- a/Include/Components/GridSpawnerComponent.h
+++ b/Include/Components/GridSpawnerComponent.h
@@ -10,10 +10,10 @@ namespace CE
 	{
 	public:
 		void OnConstruct(World&, entt::entity owner);
-		void OnBeginPlay(World&, entt::entity);
+		void OnBeginPlay(World& world, entt::entity);
 
-		void ClearGrid();
-		void SpawnGrid();
+		void ClearGrid(World& world);
+		void SpawnGrid(World& world);
 
 		std::vector<AssetHandle<Prefab>> mTiles{};
 
diff --git a/Include/Core/ThreadPool.h b/Include/Core/ThreadPool.h
new file mode 100644
index 00000000..fcf5cea6
--- /dev/null
+++ b/Include/Core/ThreadPool.h
@@ -0,0 +1,54 @@
+#pragma once
+#include <future>
+#include <queue>
+
+namespace CE
+{
+	class ThreadPool final :
+		public EngineSubsystem<ThreadPool>
+	{
+		friend EngineSubsystem;
+
+		ThreadPool();
+		~ThreadPool(); // joins all threads
+	public:
+
+		template<class F, class... A>
+		decltype(auto) Enqueue(F&& callable, A &&...arguments);
+
+		size_t NumberOfThreads() const { return mThreads.size(); }
+
+	private:
+		std::vector<std::thread> mThreads{};
+		std::queue<std::packaged_task<void()>> mTasks{};
+		std::mutex mMutex{};
+		std::condition_variable mCondition{};
+		bool mStopped{};
+	};
+
+	// add new work item to the pool
+	template<class F, class... Args>
+	decltype(auto) ThreadPool::Enqueue(F&& f, Args&&... args)
+	{
+		using return_type = std::invoke_result_t<F, Args...>;
+
+		auto task = std::make_shared<std::packaged_task<return_type()>>(
+			std::bind(std::forward<F>(f), std::forward<Args>(args)...)
+		);
+
+		std::future<return_type> res = task->get_future();
+		{
+			std::unique_lock lock{ mMutex };
+			mTasks.emplace([task]{ (*task)(); });
+		}
+		mCondition.notify_one();
+		return res;
+	}
+
+
+	template<typename T>
+	bool IsFutureReady(const std::future<T>& f)
+	{
+		return f.valid() && f.wait_for(std::chrono::seconds{}) == std::future_status::ready;
+	}
+}
\ No newline at end of file
diff --git a/Include/EditorSystems/AssetEditorSystems/ScriptEditorSystem.h b/Include/EditorSystems/AssetEditorSystems/ScriptEditorSystem.h
index 8445cbcd..6ce5c2d2 100644
--- a/Include/EditorSystems/AssetEditorSystems/ScriptEditorSystem.h
+++ b/Include/EditorSystems/AssetEditorSystems/ScriptEditorSystem.h
@@ -1,9 +1,8 @@
-#include "Utilities/ASync.h"
 #ifdef EDITOR
 #pragma once
 #include "EditorSystems/AssetEditorSystems/AssetEditorSystem.h"
 
-#include <thread>
+#include <future>
 
 #include "imnodes/imgui_node_editor.h"
 #include "Assets/Script.h"
@@ -202,8 +201,10 @@ namespace CE
 		void InitialiseAllNodesTheUserCanAdd();
 
 		std::vector<NodeCategory> mAllNodesTheUserCanAdd{};
-		ASyncThread mNodePopularityCalculateThread{};
-		bool mShouldWeStopCountingNodePopularity{};
+
+		// The popularity is stored inside of each node in mAllNodesTheUserCanAdd
+		std::future<void> mNodePopularityCalculations{};
+		std::atomic<bool> mShouldWeStopCountingNodePopularity{};
 
 		ax::NodeEditor::PinId mPinTheUserRightClicked{};
 		ax::NodeEditor::PinId mPinTheUserIsTryingToLink{};
diff --git a/Include/EditorSystems/ContentBrowserEditorSystem.h b/Include/EditorSystems/ContentBrowserEditorSystem.h
index 61ccde63..c5ced8b9 100644
--- a/Include/EditorSystems/ContentBrowserEditorSystem.h
+++ b/Include/EditorSystems/ContentBrowserEditorSystem.h
@@ -1,8 +1,9 @@
 #ifdef EDITOR
 #pragma once
+#include <future>
+
 #include "EditorSystems/EditorSystem.h"
 #include "Core/AssetManager.h"
-#include "Utilities/ASync.h"
 
 namespace CE
 {
@@ -25,7 +26,6 @@ namespace CE
 	private:
 		struct ContentFolder
 		{
-			ContentFolder() = default;
 			ContentFolder(const std::filesystem::path& path, std::string&& name, ContentFolder* parent) :
 				mActualPath(path),
 				mFolderName(std::move(name)),
@@ -33,10 +33,10 @@ namespace CE
 			{}
 
 			ContentFolder(const ContentFolder&) = delete;
-			ContentFolder(ContentFolder&&) noexcept = default;
+			ContentFolder(ContentFolder&&) noexcept = delete;
 
 			ContentFolder& operator=(const ContentFolder&) = delete;
-			ContentFolder& operator=(ContentFolder&&) noexcept = default;
+			ContentFolder& operator=(ContentFolder&&) noexcept = delete;
 
 			// Will be empty for the root folder
 			std::filesystem::path mActualPath{};
@@ -46,6 +46,7 @@ namespace CE
 			ContentFolder* mParent{};
 			std::vector<WeakAssetHandle<>> mContent{};
 		};
+
 		void RequestUpdateToFolderGraph();
 
 		void DisplayFolderHierarchyPanel();
@@ -87,11 +88,11 @@ namespace CE
 		static MetaType Reflect();
 		REFLECT_AT_START_UP(ContentBrowserEditorSystem);
 
-		ContentFolder mRootFolder{ {}, "All", nullptr };
-		std::reference_wrapper<const ContentFolder> mSelectedFolder = mRootFolder;
+		std::unique_ptr<ContentFolder> mRootFolder = std::make_unique<ContentFolder>(std::filesystem::path{}, "All", nullptr);
+		std::reference_wrapper<const ContentFolder> mSelectedFolder = *mRootFolder;
 		std::filesystem::path mSelectedFolderPath{};
 
-		ASyncFuture<ContentFolder> mPendingRootFolder{};
+		std::future<std::unique_ptr<ContentFolder>> mPendingRootFolder{};
 
 		float mFolderHierarchyPanelWidthPercentage = .25f;
 		float mContentPanelWidthPercentage = .75f;
diff --git a/Include/EditorSystems/ImporterSystem.h b/Include/EditorSystems/ImporterSystem.h
index 34c14396..daad5343 100644
--- a/Include/EditorSystems/ImporterSystem.h
+++ b/Include/EditorSystems/ImporterSystem.h
@@ -1,14 +1,11 @@
-#include "Utilities/ASync.h"
-#include "Utilities/Time.h"
 #ifdef EDITOR
 #include "EditorSystems/EditorSystem.h"
 
 #include <future>
 
 #include "Core/AssetManager.h"
-#include "Assets/Core/AssetLoadInfo.h"
 #include "Assets/Importers/Importer.h"
-#include "Utilities/MemFunctions.h"
+#include "Utilities/Time.h"
 
 namespace CE
 {
@@ -51,7 +48,7 @@ namespace CE
 		struct ImportFuture
 		{
 			ImportRequest mImportRequest{};
-			ASyncFuture<std::optional<std::vector<ImportPreview>>> mImportResult{};
+			std::future<std::optional<std::vector<ImportPreview>>> mImportResult{};
 		};
 
 		struct DirToWatch
@@ -113,7 +110,7 @@ namespace CE
 
 		std::array<DirToWatch, 2> mDirectoriesToWatch{};
 		Cooldown mCheckDirectoryCooldown{ 10.0f };
-		ASyncFuture<std::vector<ImportRequest>> mChangedFilesInDirectoriesToWatch{};
+		std::future<std::vector<ImportRequest>> mChangedFilesInDirectoriesToWatch{};
 
 		static inline bool sExcludeDuplicates{};
 		static inline bool sIgnoreReadOnly = true;
diff --git a/Include/EditorSystems/ThumbnailEditorSystem.h b/Include/EditorSystems/ThumbnailEditorSystem.h
index 1ad0aa72..c19ac8fe 100644
--- a/Include/EditorSystems/ThumbnailEditorSystem.h
+++ b/Include/EditorSystems/ThumbnailEditorSystem.h
@@ -12,7 +12,7 @@ namespace CE
 	class Texture;
 	class World;
 
-	using GetThumbnailRet = std::variant<AssetHandle<Texture>, World>;
+	using GetThumbnailRet = std::variant<AssetHandle<Texture>, std::unique_ptr<World>>;
 
 	class ThumbnailEditorSystem final :
 		public EditorSystem
@@ -72,9 +72,7 @@ namespace CE
 
 		struct CurrentlyGenerating
 		{
-			CurrentlyGenerating(World&& world, WeakAssetHandle<> forAsset);
-
-			World mWorld;
+			std::unique_ptr<World> mWorld{};
 			WeakAssetHandle<> mForAsset{};
 			FrameBuffer mFrameBuffer{ sGeneratedThumbnailResolution };
 			Timer mNumSecondsSinceLastRequested{};
diff --git a/Include/Scripting/ScriptPin.h b/Include/Scripting/ScriptPin.h
index 64c8dbad..e219d88c 100644
--- a/Include/Scripting/ScriptPin.h
+++ b/Include/Scripting/ScriptPin.h
@@ -1,17 +1,10 @@
 #pragma once
 #include "ScriptIds.h"
-#include "imnodes/imgui_node_editor.h"
 
-#include "Meta/MetaAny.h"
-#include "Meta/MetaTypeTraits.h"
 #include "Meta/Fwd/MetaFuncFwd.h"
+#include "Meta/MetaTypeTraits.h"
 #include "Scripting/ScriptErrors.h"
 
-namespace CE
-{
-	struct MetaFuncNamedParam;
-}
-
 namespace CE
 {
 	enum class ScriptPinKind : bool
diff --git a/Include/Utilities/ASync.h b/Include/Utilities/ASync.h
deleted file mode 100644
index 0f242efb..00000000
--- a/Include/Utilities/ASync.h
+++ /dev/null
@@ -1,81 +0,0 @@
-#pragma once
-
-namespace CE
-{
-	namespace Internal
-	{
-		struct Job;
-	}
-
-	// Like a regular thread, except this one
-	// does not slow down the main thread.
-	class ASyncThread
-	{
-	public:
-		ASyncThread() = default;
-		ASyncThread(std::function<void()>&& work);
-
-		ASyncThread(const ASyncThread&) = delete;
-		ASyncThread(ASyncThread&&) noexcept = default;
-
-		ASyncThread& operator=(const ASyncThread&) = delete;
-		ASyncThread& operator=(ASyncThread&&) noexcept = default;
-
-		~ASyncThread();
-
-		bool WasLaunched() const;
-
-		void CancelOrJoin();
-		void CancelOrDetach();
-		void Join();
-		void Detach();
-
-	private:
-		std::shared_ptr<Internal::Job> mJob{};
-	};
-
-	template<typename T>
-	class ASyncFuture
-	{
-	public:
-		ASyncFuture() = default;
-		ASyncFuture(std::function<T()>&& work) :
-			mValue(std::make_shared<std::optional<T>>()),
-			mThread(
-				[value = mValue, work]
-				{
-					const_cast<std::shared_ptr<std::optional<T>>&>(value)->emplace(work());
-				}
-			)
-		{
-		}
-
-		ASyncFuture(const ASyncFuture&) = delete;
-		ASyncFuture(ASyncFuture&&) noexcept = default;
-
-		ASyncFuture& operator=(const ASyncFuture&) = delete;
-		ASyncFuture& operator=(ASyncFuture&&) noexcept = default;
-
-		ASyncThread& GetThread() { return mThread; }
-		const ASyncThread& GetThread() const { return mThread; }
-
-		bool IsReady() const { return mValue != nullptr && mValue->has_value(); }
-
-		T& Get();
-
-	private:
-		std::shared_ptr<std::optional<T>> mValue{};
-		ASyncThread mThread{};
-	};
-
-	template <typename T>
-	T& ASyncFuture<T>::Get()
-	{
-		if (mThread.WasLaunched())
-		{
-			mThread.Join();
-		}
-
-		return **mValue;
-	}
-}
diff --git a/Include/Utilities/Imgui/WorldInspect.h b/Include/Utilities/Imgui/WorldInspect.h
index 1424c154..fb71a869 100644
--- a/Include/Utilities/Imgui/WorldInspect.h
+++ b/Include/Utilities/Imgui/WorldInspect.h
@@ -21,7 +21,7 @@ namespace CE
 		The provided doUndoStack must remain alive for the duration of this
 		objects lifetime.
 		*/
-		WorldInspectHelper(World&& worldThatHasNotYetBegunPlay);
+		WorldInspectHelper(std::unique_ptr<World> worldThatHasNotYetBegunPlay);
 		~WorldInspectHelper();
 
 		/*
diff --git a/Include/Utilities/Reflect/ReflectComponentType.h b/Include/Utilities/Reflect/ReflectComponentType.h
index f68982ed..0e46d33c 100644
--- a/Include/Utilities/Reflect/ReflectComponentType.h
+++ b/Include/Utilities/Reflect/ReflectComponentType.h
@@ -36,12 +36,10 @@ namespace CE
 		MetaFunc& addComponentFunc = entityType.AddFunc(
 			[](MetaFunc::DynamicArgs args, MetaFunc::RVOBuffer) -> FuncResult
 			{
-				World* world = World::TryGetWorldAtTopOfStack();
-				ASSERT(world != nullptr && "Reached a scripting context without pushing a world");
+				World& world = *static_cast<World*>(args[0].GetData());
+				const entt::entity entity = *static_cast<entt::entity*>(args[1].GetData());
 
-				entt::entity entity = *static_cast<entt::entity*>(args[0].GetData());
-
-				Registry& reg = world->GetRegistry();
+				Registry& reg = world.GetRegistry();
 
 				if (reg.HasComponent<T>(entity))
 				{
@@ -61,7 +59,7 @@ namespace CE
 			},
 			Internal::GetAddComponentFuncName(type.GetName()),
 			MetaFunc::Return{ isEmpty ? MakeTypeTraits<void>() : MakeTypeTraits<T&>() },
-			MetaFunc::Params{ { MakeTypeTraits<const entt::entity&>(), "Entity" } });
+			MetaFunc::Params{ { MakeTypeTraits<World&>() }, { MakeTypeTraits<entt::entity>() } });
 
 		if (type.GetProperties().Has(Props::sIsScriptableTag))
 		{
diff --git a/Include/World/EventManager.h b/Include/World/EventManager.h
index bafd9d6e..45145778 100644
--- a/Include/World/EventManager.h
+++ b/Include/World/EventManager.h
@@ -29,8 +29,6 @@ namespace CE
 			MetaFunc::DynamicArgs argsProvided, 
 			std::span<TypeForm> argFormsProvided);
 
-		// mWorld needs to be updated in World::World(World&&), so we give access to World to do so.
-		friend class World;
 		std::reference_wrapper<World> mWorld;
 
 		std::unordered_map<std::string_view, std::vector<BoundEvent>> mBoundEvents{};
diff --git a/Include/World/Physics.h b/Include/World/Physics.h
index a10caf42..755655f2 100644
--- a/Include/World/Physics.h
+++ b/Include/World/Physics.h
@@ -52,8 +52,6 @@ namespace CE
 		static MetaType Reflect();
 		REFLECT_AT_START_UP(Physics);
 
-		// mWorld needs to be updated in World::World(World&&), so we give access to World to do so.
-		friend class World;
 		std::reference_wrapper<World> mWorld;
 
 		BVHS mBVHs;
diff --git a/Include/World/Registry.h b/Include/World/Registry.h
index ed485d40..5d554475 100644
--- a/Include/World/Registry.h
+++ b/Include/World/Registry.h
@@ -157,9 +157,6 @@ namespace CE
 
 		void CallEndPlayEventsForEntity(entt::sparse_set& storage, entt::entity entity, const BoundEvent& endPlayEvent);
 
-		// mWorld needs to be updated in World::World(World&&), so we give access to World to do so.
-		friend World;
-
 		std::reference_wrapper<World> mWorld; 
 		
 		entt::registry mRegistry{};
@@ -217,8 +214,6 @@ namespace CE
 				}
 			}();
 
-		World::PushWorld(mWorld);
-
 		if constexpr (isEmpty)
 		{
 			mRegistry.emplace<ComponentType>(toEntity, std::forward<AdditonalArgs>(additionalArgs)...);
@@ -236,8 +231,6 @@ namespace CE
 					events.mOnBeginPlay->mFunc.get().InvokeUncheckedUnpacked(GetWorld(), toEntity);
 				}
 			}
-
-			World::PopWorld();
 		}
 		else
 		{
@@ -271,8 +264,6 @@ namespace CE
 				}
 			}
 
-			World::PopWorld();
-
 			return component;
 		}
 	}
@@ -307,7 +298,6 @@ namespace CE
 	template<typename ComponentType>
 	void Registry::RemoveComponent(entt::entity fromEntity)
 	{
-		World::PushWorld(mWorld);
 		static constexpr TypeId componentClassTypeId = MakeStrippedTypeId<ComponentType>();
 		entt::sparse_set* storage = Storage(componentClassTypeId);
 		ASSERT(storage != nullptr);
@@ -335,7 +325,6 @@ namespace CE
 		}
 
 		storage->erase(fromEntity);
-		World::PopWorld();
 	}
 
 	template <typename ComponentType, typename It>
@@ -358,8 +347,6 @@ namespace CE
 			return;
 		}
 
-		World::PushWorld(mWorld);
-
 		if constexpr (sIsReflectable<ComponentType>)
 		{
 			static std::optional<BoundEvent> endPlayEvent =
@@ -379,7 +366,6 @@ namespace CE
 			{
 				if (!storage->contains(fromEntity))
 				{
-					World::PopWorld();
 					return;
 				}
 
@@ -388,7 +374,6 @@ namespace CE
 		}
 
 		storage->remove(fromEntity);
-		World::PopWorld();
 	}
 
 	template<typename It>
diff --git a/Include/World/World.h b/Include/World/World.h
index 07a9e04b..9a336463 100644
--- a/Include/World/World.h
+++ b/Include/World/World.h
@@ -18,14 +18,15 @@ namespace CE
 	{
 	public:
 		World(bool beginPlayImmediately);
-		World(World&& other) noexcept;
-		World(const World&) = delete;
 
-		~World();
+		World(World&&) = delete;
+		World(const World&) = delete;
 
-		World& operator=(World&& other) noexcept;
+		World& operator=(World&&) noexcept = delete;
 		World& operator=(const World&) = delete;
 
+		~World();
+
 		void Tick(float deltaTime);
 		void Render(FrameBuffer* renderTarget = nullptr);
 
@@ -75,11 +76,6 @@ namespace CE
 
 		void RequestEndplay();
 
-		static void PushWorld(World& world);
-		static void PopWorld();
-
-		static World* TryGetWorldAtTopOfStack();
-
 		/**
 		 * \brief Will request a transition to a different level.
 		 *
diff --git a/Include/World/WorldViewport.h b/Include/World/WorldViewport.h
index 501921d6..b77661bc 100644
--- a/Include/World/WorldViewport.h
+++ b/Include/World/WorldViewport.h
@@ -23,8 +23,6 @@ namespace CE
 		glm::vec3 ScreenToWorldPlane(glm::vec2 screenPosition, float planeHeight) const;
 
 	private:
-		// mWorld needs to be updated in World::World(World&&), so we give access to World to do so.
-		friend class World;
 		std::reference_wrapper<const World> mWorld;
 
 		// In pixels
diff --git a/Source/Assets/Level.cpp b/Source/Assets/Level.cpp
index bf225626..ca7d9c18 100644
--- a/Source/Assets/Level.cpp
+++ b/Source/Assets/Level.cpp
@@ -44,7 +44,7 @@ CE::Level::Level(std::string_view name) :
 
 CE::Level::Level(AssetLoadInfo& loadInfo) :
 	Asset(loadInfo),
-	mWorld(false)
+	mWorld(std::make_unique<World>(false))
 {
 	BinaryGSONObject savedData{};
 	savedData.LoadFromBinary(loadInfo.GetStream());
@@ -178,7 +178,7 @@ void CE::Level::OnSave(AssetSaveInfo& saveInfo) const
 {
 	if (!mSerializedWorld.has_value())
 	{
-		if (!mWorld.has_value())
+		if (mWorld == nullptr)
 		{
 			LOG(LogAssets, Error, "Cannot save level {}, mSerializedComponents and mWorld are null",
 				GetName());
@@ -213,49 +213,49 @@ void CE::Level::CreateFromWorld(const World& world)
 	mSerializedWorld.emplace(Archiver::Serialize(world));
 }
 
-CE::World CE::Level::CreateWorld(const bool callBeginPlayImmediately) const
+void CE::Level::LoadIntoWorld(World& world) const
 {
-	if (mWorld.has_value())
+	if (!mSerializedWorld.has_value())
 	{
-		World world = std::move(*mWorld);
-		mWorld.reset();
+		LOG(LogAssets, Warning, "Failed to load {} into world, mSerializedWorld was null", GetName());
+		return;
+	}
 
+	Archiver::Deserialize(world, *mSerializedWorld);
+}
+
+std::unique_ptr<CE::World> CE::Level::CreateWorld(const bool callBeginPlayImmediately) const
+{
+	if (mWorld != nullptr)
+	{
 		if (!mSerializedWorld.has_value())
 		{
-			mSerializedWorld.emplace(Archiver::Serialize(world));
+			mSerializedWorld.emplace(Archiver::Serialize(*mWorld));
 		}
 
 		if (callBeginPlayImmediately)
 		{
-			world.BeginPlay();
+			mWorld->BeginPlay();
 		}
 
-		return world;
+		return std::move(mWorld);
 	}
 
-	World world{ false };
-
-	if (mSerializedWorld.has_value())
-	{
-		Archiver::Deserialize(world, *mSerializedWorld);
-	}
-	else
-	{
-		LOG(LogAssets, Warning, "mWorld and mSerializedWorld were both null for {}", GetName());
-	}
+	std::unique_ptr<World> world = std::make_unique<World>(false);
+	LoadIntoWorld(*world);
 
 	if (callBeginPlayImmediately)
 	{
-		world.BeginPlay();
+		world->BeginPlay();
 	}
 
 	return world;
 }
 
-CE::World CE::Level::CreateDefaultWorld()
+std::unique_ptr<CE::World> CE::Level::CreateDefaultWorld()
 {
-	World world{ false };
-	Registry& reg = world.GetRegistry();
+	std::unique_ptr<World> world = std::make_unique<World>(false);
+	Registry& reg = world->GetRegistry();
 
 	{
 		const entt::entity camera = reg.Create();
diff --git a/Source/Assets/Script.cpp b/Source/Assets/Script.cpp
index a72df196..8ff2f261 100644
--- a/Source/Assets/Script.cpp
+++ b/Source/Assets/Script.cpp
@@ -16,6 +16,16 @@
 #include "Utilities/Reflect/ReflectAssetType.h"
 #include "Utilities/Reflect/ReflectComponentType.h"
 
+// We've hardcoded our scripts to always have a
+// While fields normally dont support ptr/ref types,
+// we can make a little wrapper around our pointer
+struct WorldPointer
+{
+	CE::World* mData{};
+	static CE::MetaType Reflect();
+	REFLECT_AT_START_UP(WorldPointer);
+};
+
 CE::Script::Script(std::string_view name) :
 	Asset(name, MakeTypeId<Script>())
 {
@@ -112,7 +122,7 @@ CE::ScriptFunc& CE::Script::AddEvent(const EventBase& event)
 		return *existingFunc;
 	}
 
-	auto& result = mFunctions.emplace_back(*this, event);
+	ScriptFunc& result = mFunctions.emplace_back(*this, event);
 
 	if (!result.IsPure()
 		|| !result.GetParameters(true).empty())
@@ -239,23 +249,23 @@ CE::MetaType* CE::Script::DeclareMetaType()
 		return nullptr;
 	}
 
-	const MetaType* const entityType = MetaManager::Get().TryGetType<entt::entity>();
-
-	if (entityType == nullptr)
-	{
-		LOG(LogScripting, Warning, "Making a metatype from {} failed - Type entt::entity was not reflected", GetName());
-		return nullptr;
-	}
+	const MetaType& entityType = MetaManager::Get().GetType<entt::entity>();
+	const MetaType& worldPtrType = MetaManager::Get().GetType<WorldPointer>();
 
 	struct MemberToAdd
 	{
-		MemberToAdd(const MetaType& type, const std::string& name) : mType(type), mName(name) {};
 		std::reference_wrapper<const MetaType> mType;
 		std::string mName{};
+		std::vector<Name> mPropsToAdd{ Props::sIsScriptableTag };
 		uint32 mOffset{};
 	};
 
-	std::vector<MemberToAdd> membersToAdd{ { *entityType, sNameOfOwnerField.String() } };
+	std::vector<MemberToAdd> membersToAdd{
+		{ entityType, sNameOfOwnerField.String(),
+			{ Props::sIsScriptableTag, Props::sNoInspectTag, Props::sNoSerializeTag, Props::sIsScriptReadOnlyTag } },
+		{ worldPtrType, sNameOfWorldField.String(),
+			{ Props::sNoInspectTag, Props::sNoSerializeTag } },
+	};
 
 	for (const ScriptField& field : mFields)
 	{
@@ -383,16 +393,41 @@ CE::MetaType* CE::Script::DeclareMetaType()
 	{
 		MetaField& newMember = metaType.AddField(memberToAdd.mType, memberToAdd.mOffset, memberToAdd.mName);
 		MetaProps& memberProperties = newMember.GetProperties();
+		memberProperties.Add(Props::sIsFromScriptsTag);
 
-		memberProperties.Add(Props::sIsScriptableTag).Add(Props::sIsFromScriptsTag);
-
-		if (newMember.GetName() == sNameOfOwnerField.StringView())
+		for (const Name prop : memberToAdd.mPropsToAdd)
 		{
-			// Don't allow the user to inspect it
-			memberProperties.Add(Props::sNoInspectTag).Add(Props::sNoSerializeTag).Add(Props::sIsScriptReadOnlyTag);
+			memberProperties.Add(prop);
 		}
 	}
 
+	{
+		// We hardcoded a function to get the world from any component. That way components can interact with
+		// the world without us resorting to a global world ptr (which is what we had before, pain to multi-thread and the cause of many bugs)
+		// So we do this instead!
+
+		const MetaField* worldField = metaType.TryGetField(sNameOfWorldField);
+		ASSERT(worldField != nullptr);
+		const uintptr offsetToWorldField = worldField->GetOffset();
+
+		static constexpr TypeTraits ret = { MakeTypeTraits<World*>() };
+		const std::vector<TypeTraits> params = { { ourTypeInfo.mTypeId, TypeForm::ConstRef } };
+
+		metaType.AddFunc(
+			[offsetToWorldField](MetaFunc::DynamicArgs arg, MetaFunc::RVOBuffer) -> FuncResult
+			{
+				MetaAny& self = arg[0];
+				std::byte* selfAddress = reinterpret_cast<std::byte*>(self.GetData());
+				World** worldAddress = reinterpret_cast<World**>(selfAddress + offsetToWorldField);
+				// Cast is needed to prevent implicit conversion to World*&
+				return MetaAny{ static_cast<World*>(*worldAddress) };
+			},
+			"Get World",
+			MetaFunc::Return{ ret }, // Return value
+			MetaFunc::Params{ params.data(), params.data() + params.size() } // Parameters
+		).GetProperties().Add(Props::sIsScriptableTag).Add(Props::sIsFromScriptsTag);
+	}
+
 	AddDefaultConstructor(metaType, false);
 	AddMoveConstructor(metaType, false);
 	AddCopyConstructor(metaType, false);
@@ -528,20 +563,23 @@ void CE::Script::AddDefaultConstructor(MetaType& toType, bool define) const
 	{
 		std::optional<BinaryGSONMember>& serializedNonDefaultValue = serializedDefaultValues.emplace_back();
 
-		if (metaField.GetName() == sNameOfOwnerField.StringView())
+		if (metaField.GetName() == sNameOfOwnerField.StringView()
+			|| metaField.GetName() == sNameOfWorldField.StringView())
 		{
 			continue;
 		}
 
-		const ScriptField& scriptField = *TryGetField(metaField.GetName());
+		const ScriptField* scriptField = TryGetField(metaField.GetName());
+		ASSERT_LOG(scriptField != nullptr, "Could not find corresponding scriptfield, hardcoded fields must be included in the if-statement above");
+
 		const MetaType& fieldType = metaField.GetType();
 
-		if (!scriptField.WasValueDefaultConstructed())
+		if (!scriptField->WasValueDefaultConstructed())
 		{
 			// Remove std::nullopt
 			serializedNonDefaultValue = BinaryGSONMember{};
 
-			FuncResult serializeResult = fieldType.CallFunction(sSerializeMemberFuncName, *serializedNonDefaultValue, scriptField.GetDefaultValue());
+			FuncResult serializeResult = fieldType.CallFunction(sSerializeMemberFuncName, *serializedNonDefaultValue, scriptField->GetDefaultValue());
 			ASSERT_LOG(!serializeResult.HasError(), "{}", serializeResult.Error());
 		}
 	}
@@ -827,4 +865,26 @@ CE::MetaType CE::Script::Reflect()
 
 	ReflectAssetType<Script>(type);
 	return type;
-}
\ No newline at end of file
+}
+
+bool operator==(const WorldPointer& lhs, const WorldPointer& rhs)
+{
+	return lhs.mData == rhs.mData;
+}
+
+#ifdef EDITOR
+IMGUI_AUTO_DEFINE_INLINE(template<>, WorldPointer, (void)var; (void)name;)
+#endif
+
+namespace cereal
+{
+	template<typename Archive>
+	void serialize(Archive&, WorldPointer&) {}
+}
+
+CE::MetaType WorldPointer::Reflect()
+{
+	CE::MetaType type{ CE::MetaType::T<WorldPointer>{}, "WorldPointer" };
+	CE::ReflectFieldType<WorldPointer>(type);
+	return type;
+}
diff --git a/Source/Components/GridSpawnerComponent.cpp b/Source/Components/GridSpawnerComponent.cpp
index c5cefc01..84f9f424 100644
--- a/Source/Components/GridSpawnerComponent.cpp
+++ b/Source/Components/GridSpawnerComponent.cpp
@@ -14,24 +14,17 @@ void CE::GridSpawnerComponent::OnConstruct(World&, entt::entity owner)
 	mOwner = owner;
 }
 
-void CE::GridSpawnerComponent::OnBeginPlay(World&, entt::entity)
+void CE::GridSpawnerComponent::OnBeginPlay(World& world, entt::entity)
 {
 	if (mShouldSpawnOnBeginPlay)
 	{
-		SpawnGrid();
+		SpawnGrid(world);
 	}
 }
 
-void CE::GridSpawnerComponent::ClearGrid()
+void CE::GridSpawnerComponent::ClearGrid(World& world)
 {
-	World* const world = World::TryGetWorldAtTopOfStack();
-
-	if (world == nullptr)
-	{
-		return;
-	}
-
-	Registry& reg = world->GetRegistry();
+	Registry& reg = world.GetRegistry();
 
 	TransformComponent* transform = reg.TryGet<TransformComponent>(mOwner);
 
@@ -46,23 +39,16 @@ void CE::GridSpawnerComponent::ClearGrid()
 	}
 }
 
-void CE::GridSpawnerComponent::SpawnGrid()
+void CE::GridSpawnerComponent::SpawnGrid(World& world)
 {
 	if (mTiles.empty())
 	{
 		return;
 	}
 
-	World* const world = World::TryGetWorldAtTopOfStack();
-
-	if (world == nullptr)
-	{
-		return;
-	}
-
-	ClearGrid();
+	ClearGrid(world);
 
-	Registry& reg = world->GetRegistry();
+	Registry& reg = world.GetRegistry();
 	TransformComponent* transform = reg.TryGet<TransformComponent>(mOwner);
 
 	if (transform == nullptr)
diff --git a/Source/Components/Physics2D/DiskColliderComponent.cpp b/Source/Components/Physics2D/DiskColliderComponent.cpp
index ffb7bd2e..d1cf941c 100644
--- a/Source/Components/Physics2D/DiskColliderComponent.cpp
+++ b/Source/Components/Physics2D/DiskColliderComponent.cpp
@@ -20,28 +20,6 @@ CE::MetaType CE::DiskColliderComponent::Reflect()
 
 	metaType.AddField(&DiskColliderComponent::mRadius, "mRadius").GetProperties().Add(Props::sIsScriptableTag);
 
-	metaType.AddFunc([](entt::entity owner)
-		{
-			World* world = World::TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-
-			const auto transform = world->GetRegistry().TryGet<TransformComponent>(owner);
-			if (transform == nullptr)
-			{
-				LOG(LogPhysics, Error, "Entity {} passed to GetScaledRadius does not have a TransformComponent.", entt::to_integral(owner));
-				return 0.0f;
-			}
-			const auto collider = world->GetRegistry().TryGet<DiskColliderComponent>(owner);
-			if (transform == nullptr)
-			{
-				LOG(LogPhysics, Error, "Entity {} passed to GetScaledRadius does not have a DiskColliderComponent.", entt::to_integral(owner));
-				return 0.0f;
-			}
-
-			return collider->CreateTransformedCollider(*transform).mRadius;
-		}, "GetScaledRadius", MetaFunc::ExplicitParams<
-		entt::entity>{}, "Owner of Disk Collider").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
-
 	ReflectComponentType<DiskColliderComponent>(metaType);
 
 	return metaType;
diff --git a/Source/Core/Engine.cpp b/Source/Core/Engine.cpp
index 9cf7159c..466b1740 100644
--- a/Source/Core/Engine.cpp
+++ b/Source/Core/Engine.cpp
@@ -3,6 +3,7 @@
 
 #include <chrono>
 
+#include "Core/ThreadPool.h"
 #include "Core/FileIO.h"
 #include "Core/Device.h"
 #include "Core/Renderer.h"
@@ -31,34 +32,22 @@ CE::Engine::Engine(int argc, char* argv[], std::string_view gameDir)
 
 	FileIO::StartUp(argc, argv, gameDir);
 	Logger::StartUp();
+	ThreadPool::StartUp();
 
-	LOG(LogCore, Verbose, "Created logger");
-
-	std::thread deviceAgnosticSystems
-	{
-		[&]
+	const std::future startupThread = ThreadPool::Get().Enqueue([&]
 		{
-			LOG(LogCore, Verbose, "Creating MetaManager");
 			MetaManager::StartUp();
-			LOG(LogCore, Verbose, "Creating AssetManager");
 			AssetManager::StartUp();
-			LOG(LogCore, Verbose, "Booting up virtual machine");
 			VirtualMachine::StartUp();
-		}
-	};
+		});
 
 	if (!isHeadless)
 	{
-		LOG(LogCore, Verbose, "Creating window & device");
 		Device::StartUp(DeviceConfiguration{});
-		LOG(LogCore, Verbose, "Creating renderer");
 		Renderer::StartUp();
 	}
 
-	LOG(LogCore, Verbose, "Creating Audio");
 	Audio::StartUp();
-
-	LOG(LogCore, Verbose, "Creating Input");
 	Input::StartUp();
 
 #ifdef EDITOR
@@ -68,13 +57,12 @@ CE::Engine::Engine(int argc, char* argv[], std::string_view gameDir)
 	}
 #endif // EDITOR
 
-	deviceAgnosticSystems.join();
+	startupThread.wait();
 
 #ifdef EDITOR
 	Editor::StartUp();
 #endif // EDITOR
 
-	LOG(LogCore, Verbose, "Creating UnitTestManager");
 	UnitTestManager::StartUp();
 
 	if (isHeadless)
@@ -92,7 +80,7 @@ CE::Engine::Engine(int argc, char* argv[], std::string_view gameDir)
 		const uint32 numOfErrorsLogged = Logger::Get().GetNumOfEntriesPerSeverity()[LogSeverity::Error];
 		if (numOfErrorsLogged != 0)
 		{
-			LOG(LogUnitTest, Error, "There were {} unresolved errors logged to the consoler", numOfErrorsLogged);
+			LOG(LogUnitTest, Error, "There were {} unresolved errors logged to the console", numOfErrorsLogged);
 			numFailed += numOfErrorsLogged;
 		}
 
@@ -114,34 +102,25 @@ CE::Engine::Engine(int argc, char* argv[], std::string_view gameDir)
 
 CE::Engine::~Engine()
 {
-	LOG(LogCore, Verbose, "Shutting down UnitTestManager");
+	ThreadPool::ShutDown();
 	UnitTestManager::ShutDown();
 
 #ifdef EDITOR
-	LOG(LogCore, Verbose, "Shutting down Editor");
 	Editor::ShutDown();
 #endif  // EDITOR
 
-	LOG(LogCore, Verbose, "Shutting down VirtualMachine");
 	VirtualMachine::ShutDown();
-	LOG(LogCore, Verbose, "Shutting down AssetManager");
 	AssetManager::ShutDown();
-	LOG(LogCore, Verbose, "Shutting down MetaManager");
 	MetaManager::ShutDown();
-	LOG(LogCore, Verbose, "Shutting down Audio");
 	Audio::ShutDown();
-	LOG(LogCore, Verbose, "Shutting down Input");
 	Input::ShutDown();
 
 	if (!Device::IsHeadless())
 	{
-		LOG(LogCore, Verbose, "Shutting down Renderer");
 		Renderer::ShutDown();
-		LOG(LogCore, Verbose, "Shutting down Device");
 		Device::ShutDown();
 	}
 
-	LOG(LogCore, Verbose, "Shutting down Logger");
 	Logger::ShutDown();
 	FileIO::ShutDown();
 }
@@ -163,7 +142,7 @@ void CE::Engine::Run([[maybe_unused]] Name starterLevel)
 	}
 
 	LOG(LogCore, Verbose, "Loading initial level - {}", starterLevel.StringView());
-	World world = level->CreateWorld(true);
+	std::unique_ptr<World> world = level->CreateWorld(true);
 #endif // EDITOR
 
 	Input& input = Input::Get();
@@ -206,14 +185,14 @@ void CE::Engine::Run([[maybe_unused]] Name starterLevel)
 #ifdef EDITOR
 		editor.Tick(deltaTime);
 #else
-		world.Tick(deltaTime);
+		world->Tick(deltaTime);
 
-		if (world.HasRequestedEndPlay())
+		if (world->HasRequestedEndPlay())
 		{
 			break;
 		}
 
-		world.Render();
+		world->Render();
 #endif  // EDITOR
 
 		renderer.RunCommandQueues();
diff --git a/Source/Core/ThreadPool.cpp b/Source/Core/ThreadPool.cpp
new file mode 100644
index 00000000..9995be87
--- /dev/null
+++ b/Source/Core/ThreadPool.cpp
@@ -0,0 +1,49 @@
+#include "Precomp.h"
+#include "Core/ThreadPool.h"
+
+CE::ThreadPool::ThreadPool()
+{
+    const uint32 numOfHardwareThreads = std::max(4u, std::thread::hardware_concurrency());
+    LOG(LogCore, Verbose, "Threadpool has {} thread(s)", numOfHardwareThreads);
+
+    mThreads.reserve(numOfHardwareThreads);
+    for (std::size_t i = 0; i < numOfHardwareThreads; ++i)
+    {
+        mThreads.emplace_back(
+            [this]
+            {
+                while (true)
+                {
+                    std::packaged_task<void()> task;
+                    {
+                        std::unique_lock uniqueLock(mMutex);
+                        mCondition.wait(uniqueLock, [this] { return mTasks.empty() == false || mStopped == true; });
+                        if (mTasks.empty() == false)
+                        {
+                            task = std::move(mTasks.front());
+                            // attention! tasks_.front() moved
+                            mTasks.pop();
+                        }
+                        else
+                        {  // stopped_ == true (necessarily)
+                            return;
+                        }
+                    }
+                    task();
+                }
+            });
+    }
+}
+
+CE::ThreadPool::~ThreadPool()
+{
+    {
+        std::lock_guard lockGuard(mMutex);
+        mStopped = true;
+    }
+    mCondition.notify_all();
+    for (std::thread& worker : mThreads)
+    {
+        worker.join();
+    }
+}
diff --git a/Source/EditorSystems/AssetEditorSystems/LevelEditorSystem.cpp b/Source/EditorSystems/AssetEditorSystems/LevelEditorSystem.cpp
index 610498ae..3a3cb89a 100644
--- a/Source/EditorSystems/AssetEditorSystems/LevelEditorSystem.cpp
+++ b/Source/EditorSystems/AssetEditorSystems/LevelEditorSystem.cpp
@@ -2,7 +2,6 @@
 #include "EditorSystems/AssetEditorSystems/LevelEditorSystem.h"
 
 #include "Utilities/Imgui/WorldInspect.h"
-#include "World/World.h"
 
 CE::LevelEditorSystem::LevelEditorSystem(Level&& asset) :
 	AssetEditorSystem(std::move(asset)),
@@ -36,7 +35,7 @@ void CE::LevelEditorSystem::Tick(const float deltaTime)
 
 void CE::LevelEditorSystem::SaveState(std::ostream& toStream) const
 {
-	AssetEditorSystem<Level>::SaveState(toStream);
+	AssetEditorSystem::SaveState(toStream);
 
 	BinaryGSONObject savedState{};
 	mWorldHelper->SaveState(savedState);
@@ -45,7 +44,7 @@ void CE::LevelEditorSystem::SaveState(std::ostream& toStream) const
 
 void CE::LevelEditorSystem::LoadState(std::istream& fromStream)
 {
-	AssetEditorSystem<Level>::LoadState(fromStream);
+	AssetEditorSystem::LoadState(fromStream);
 
 	BinaryGSONObject savedState{};
 
diff --git a/Source/EditorSystems/AssetEditorSystems/ScriptEditorSystem/ScriptCanvasPanel.cpp b/Source/EditorSystems/AssetEditorSystems/ScriptEditorSystem/ScriptCanvasPanel.cpp
index 29dbbd54..7caa76f1 100644
--- a/Source/EditorSystems/AssetEditorSystems/ScriptEditorSystem/ScriptCanvasPanel.cpp
+++ b/Source/EditorSystems/AssetEditorSystems/ScriptEditorSystem/ScriptCanvasPanel.cpp
@@ -11,6 +11,7 @@
 
 #include "Utilities/Search.h"
 #include "Core/Input.h"
+#include "Core/ThreadPool.h"
 #include "Core/VirtualMachine.h"
 #include "Scripting/ScriptTools.h"
 #include "Scripting/Nodes/CommentScriptNode.h"
@@ -1034,9 +1035,8 @@ void CE::ScriptEditorSystem::InitialiseAllNodesTheUserCanAdd()
 			return lhs.mName < rhs.mName;
 		});
 
-	mNodePopularityCalculateThread =
-	{
-		[this]()
+	mNodePopularityCalculations = ThreadPool::Get().Enqueue(
+		[this]
 		{
 			uint32 totalNumOfNodesUsed{};
 
@@ -1105,8 +1105,7 @@ void CE::ScriptEditorSystem::InitialiseAllNodesTheUserCanAdd()
 					nodeThatCanBeAdded.mSearchBonus += sPopularityInfluenceOnSearchBonus * static_cast<float>(nodeThatCanBeAdded.mNumOfTimesUsed) / static_cast<float>(totalNumOfNodesUsed);
 				}
 			}
-		}
-	};
+		});
 }
 
 ImColor CE::ScriptEditorSystem::GetIconColor(const ScriptVariableTypeData& typeData) const
diff --git a/Source/EditorSystems/AssetEditorSystems/ScriptEditorSystem/ScriptEditorSystem.cpp b/Source/EditorSystems/AssetEditorSystems/ScriptEditorSystem/ScriptEditorSystem.cpp
index 8485cf4e..8770314a 100644
--- a/Source/EditorSystems/AssetEditorSystems/ScriptEditorSystem/ScriptEditorSystem.cpp
+++ b/Source/EditorSystems/AssetEditorSystems/ScriptEditorSystem/ScriptEditorSystem.cpp
@@ -22,11 +22,10 @@ CE::ScriptEditorSystem::~ScriptEditorSystem()
 	// Frees the context
 	SelectFunction(nullptr);
 
-	mShouldWeStopCountingNodePopularity = true;
-
-	if (mNodePopularityCalculateThread.WasLaunched())
+	mShouldWeStopCountingNodePopularity = false;
+	if (mNodePopularityCalculations.valid())
 	{
-		mNodePopularityCalculateThread.CancelOrJoin();
+		mNodePopularityCalculations.get();
 	}
 }
 
diff --git a/Source/EditorSystems/ContentBrowserEditorSystem.cpp b/Source/EditorSystems/ContentBrowserEditorSystem.cpp
index 1a6202c6..3123ff4f 100644
--- a/Source/EditorSystems/ContentBrowserEditorSystem.cpp
+++ b/Source/EditorSystems/ContentBrowserEditorSystem.cpp
@@ -9,6 +9,7 @@
 #include "Core/Editor.h"
 #include "Core/FileIO.h"
 #include "Core/Input.h"
+#include "Core/ThreadPool.h"
 #include "EditorSystems/ImporterSystem.h"
 #include "Utilities/Imgui/ImguiDragDrop.h"
 #include "Utilities/Imgui/ImguiInspect.h"
@@ -33,9 +34,9 @@ CE::ContentBrowserEditorSystem::ContentBrowserEditorSystem() :
 
 CE::ContentBrowserEditorSystem::~ContentBrowserEditorSystem()
 {
-	if (mPendingRootFolder.GetThread().WasLaunched())
+	if (mPendingRootFolder.valid())
 	{
-		mPendingRootFolder.GetThread().CancelOrDetach();
+		mPendingRootFolder.get();
 	}
 }
 
@@ -47,19 +48,9 @@ void CE::ContentBrowserEditorSystem::Tick(const float)
 		return;
 	}
 
-	if (mPendingRootFolder.IsReady())
+	if (IsFutureReady(mPendingRootFolder))
 	{
-		mRootFolder = std::move(mPendingRootFolder.Get());
-
-		// I didn't feel like making a move constructor,
-		// plus this reassignment only needs to happen for
-		// the rootfolder
-		for (ContentFolder& child : mRootFolder.mChildren)
-		{
-			child.mParent = &mRootFolder;
-		}
-
-		mPendingRootFolder = {};
+		mRootFolder = mPendingRootFolder.get();
 		SelectFolder(mSelectedFolderPath);
 	}
 
@@ -87,14 +78,13 @@ void CE::ContentBrowserEditorSystem::LoadState(std::istream& fromStream)
 
 void CE::ContentBrowserEditorSystem::RequestUpdateToFolderGraph()
 {
-	if (mPendingRootFolder.GetThread().WasLaunched())
+	if (mPendingRootFolder.valid())
 	{
-		mPendingRootFolder.GetThread().CancelOrDetach();
+		mPendingRootFolder.get();
 	}
 
-	mPendingRootFolder = 
-	{
-		[]
+	mPendingRootFolder = ThreadPool::Get().Enqueue(
+		[]() -> std::unique_ptr<ContentFolder>
 		{
 			std::unordered_map<std::filesystem::path, WeakAssetHandle<>> assetLookUp{};
 
@@ -107,10 +97,10 @@ void CE::ContentBrowserEditorSystem::RequestUpdateToFolderGraph()
 			}
 
 			// Create the root folder to hold the top-level directories and files
-			ContentFolder rootFolder = { "", "All", nullptr };
+			std::unique_ptr<ContentFolder> rootFolder = std::make_unique<ContentFolder>("", "All", nullptr);
 
-			ContentFolder& engineFolder = rootFolder.mChildren.emplace_back(FileIO::Get().GetPath(FileIO::Directory::EngineAssets, ""), std::string{ sEngineAssetsDisplayName }, &rootFolder);
-			ContentFolder& gameFolder = rootFolder.mChildren.emplace_back(FileIO::Get().GetPath(FileIO::Directory::GameAssets, ""), std::string{ sGameAssetsDisplayName }, &rootFolder);
+			ContentFolder& engineFolder = rootFolder->mChildren.emplace_back(FileIO::Get().GetPath(FileIO::Directory::EngineAssets, ""), std::string{ sEngineAssetsDisplayName }, rootFolder.get());
+			ContentFolder& gameFolder = rootFolder->mChildren.emplace_back(FileIO::Get().GetPath(FileIO::Directory::GameAssets, ""), std::string{ sGameAssetsDisplayName }, rootFolder.get());
 
 			std::function<void(ContentFolder&)> parse = [&parse, &assetLookUp](ContentFolder& folder)
 				{
@@ -148,8 +138,7 @@ void CE::ContentBrowserEditorSystem::RequestUpdateToFolderGraph()
 			parse(gameFolder);
 
 			return rootFolder;
-		}
-	};
+		});
 }
 
 void CE::ContentBrowserEditorSystem::DisplayFolderHierarchyPanel()
@@ -163,7 +152,7 @@ void CE::ContentBrowserEditorSystem::DisplayFolderHierarchyPanel()
 		ImGui::SetItemTooltip("Create a new asset");
 
 		ImGui::SetNextItemOpen(true, ImGuiCond_Once);
-		DisplayFolder(mRootFolder);
+		DisplayFolder(*mRootFolder);
 
 		if (ImGui::BeginPopup("CreateNewAssetMenu"))
 		{
@@ -328,11 +317,11 @@ void CE::ContentBrowserEditorSystem::DisplayFolder(const ContentFolder& folder)
 		}
 		else
 		{
-			SelectFolder(mRootFolder);
+			SelectFolder(*mRootFolder);
 		}
 	}
 
-	if (&folder != &mRootFolder)
+	if (&folder != mRootFolder.get())
 	{
 		WeakAssetHandle receivedAsset = DragDrop::PeekAsset<Asset>();
 
@@ -675,7 +664,7 @@ void CE::ContentBrowserEditorSystem::DisplayRightClickMenu(const ContentFolder&
 	ImGui::TextUnformatted(folder.mFolderName.c_str());
 	ImGui::Separator();
 
-	if (&folder != &mRootFolder
+	if (&folder != mRootFolder.get()
 		&& ImGui::BeginMenu("New folder"))
 	{
 		static std::string name{};
@@ -733,7 +722,7 @@ void CE::ContentBrowserEditorSystem::DisplayRightClickMenu(const ContentFolder&
 			};
 		deleteRecursive(deleteRecursive, folder);
 
-		if (&folder != &mRootFolder)
+		if (&folder != mRootFolder.get())
 		{
 			Editor::Get().Refresh(
 				{
@@ -759,7 +748,7 @@ void CE::ContentBrowserEditorSystem::SelectFolder(const ContentFolder& folder)
 void CE::ContentBrowserEditorSystem::SelectFolder(const std::filesystem::path& path)
 {
 	mSelectedFolderPath = path;
-	mSelectedFolder = mRootFolder;
+	mSelectedFolder = *mRootFolder;
 
 	auto selectRecursive = [&](const auto& self, ContentFolder& current) -> void
 		{
@@ -773,7 +762,7 @@ void CE::ContentBrowserEditorSystem::SelectFolder(const std::filesystem::path& p
 				self(self, child);
 			}
 		};
-	selectRecursive(selectRecursive, mRootFolder);
+	selectRecursive(selectRecursive, *mRootFolder);
 }
 
 CE::MetaType CE::ContentBrowserEditorSystem::Reflect()
diff --git a/Source/EditorSystems/ImporterSystem.cpp b/Source/EditorSystems/ImporterSystem.cpp
index f951e71a..5350b8fe 100644
--- a/Source/EditorSystems/ImporterSystem.cpp
+++ b/Source/EditorSystems/ImporterSystem.cpp
@@ -3,6 +3,7 @@
 
 #include "Core/Editor.h"
 #include "Core/FileIO.h"
+#include "Core/ThreadPool.h"
 #include "Meta/MetaType.h"
 #include "Meta/MetaProps.h"
 #include "Meta/MetaTools.h"
@@ -116,44 +117,34 @@ CE::ImporterSystem::~ImporterSystem()
 {
 	*mWasImportingCancelled = true;
 
-	if (mChangedFilesInDirectoriesToWatch.GetThread().WasLaunched())
+	if (mChangedFilesInDirectoriesToWatch.valid())
 	{
-		mChangedFilesInDirectoriesToWatch.GetThread().CancelOrJoin();
+		mChangedFilesInDirectoriesToWatch.get();
 	}
 
-	for (ImportFuture& future : mImportFutures)
-	{
-		if (future.mImportResult.GetThread().WasLaunched())
-		{
-			future.mImportResult.GetThread().CancelOrDetach();
-		}
-	}
+	mImportFutures.clear();
 }
 
 void CE::ImporterSystem::Tick(const float dt)
 {
 	if (mCheckDirectoryCooldown.IsReady(dt)
-		&& !mChangedFilesInDirectoriesToWatch.GetThread().WasLaunched())
+		&& !mChangedFilesInDirectoriesToWatch.valid())
 	{
-		mChangedFilesInDirectoriesToWatch =
-		{
+		mChangedFilesInDirectoriesToWatch = ThreadPool::Get().Enqueue(
 			[this]
 			{
 				return GetAllFilesToImport();
-			}
-		};
+			});
 	}
 
-	if (mChangedFilesInDirectoriesToWatch.IsReady())
+	if (IsFutureReady(mChangedFilesInDirectoriesToWatch))
 	{
-		const std::vector<ImportRequest>& assetsToImport = mChangedFilesInDirectoriesToWatch.Get();
+		const std::vector<ImportRequest> assetsToImport = mChangedFilesInDirectoriesToWatch.get();
 
 		for (const ImportRequest& assetToImport : assetsToImport)
 		{
 			Import(assetToImport.mFile, assetToImport.mReasonForImporting);
 		}
-
-		mChangedFilesInDirectoriesToWatch = {};
 	}
 
 	RetrieveImportResultsFromFutures();
@@ -256,8 +247,7 @@ void CE::ImporterSystem::Import(const std::filesystem::path& fileToImport, std::
 		ImportFuture
 		{
 			request,
-			ASyncFuture<std::optional<std::vector<ImportPreview>>>
-			{
+			ThreadPool::Get().Enqueue(
 				[request, importer, isCancelled = mWasImportingCancelled]() -> std::optional<std::vector<ImportPreview>>
 				{
 					if (*isCancelled)
@@ -284,8 +274,7 @@ void CE::ImporterSystem::Import(const std::filesystem::path& fileToImport, std::
 					}
 
 					return previews;
-				}
-			}
+				})
 		});
 }
 
@@ -576,13 +565,13 @@ void CE::ImporterSystem::RetrieveImportResultsFromFutures()
 {
 	for (auto it = mImportFutures.begin(); it != mImportFutures.end();)
 	{
-		if (!it->mImportResult.IsReady())
+		if (!IsFutureReady(it->mImportResult))
 		{
 			++it;
 			continue;
 		}
 
-		std::optional<std::vector<ImportPreview>>& result = it->mImportResult.Get();
+		std::optional<std::vector<ImportPreview>> result = it->mImportResult.get();
 
 		if (!result.has_value())
 		{
diff --git a/Source/EditorSystems/ThumbnailEditorSystem.cpp b/Source/EditorSystems/ThumbnailEditorSystem.cpp
index e5c6495e..d7332851 100644
--- a/Source/EditorSystems/ThumbnailEditorSystem.cpp
+++ b/Source/EditorSystems/ThumbnailEditorSystem.cpp
@@ -36,7 +36,7 @@ void CE::ThumbnailEditorSystem::Tick(float deltaTime)
 
 			LOG(LogEditor, Verbose, "Rendering {} to thumbnail", current.mForAsset.GetMetaData().GetName());
 
-			current.mWorld.Render(&current.mFrameBuffer);
+			current.mWorld->Render(&current.mFrameBuffer);
 
 			const auto result = mGeneratedThumbnails.emplace(std::piecewise_construct,
 				std::forward_as_tuple(Name::HashString(current.mForAsset.GetMetaData().GetName())),
@@ -110,7 +110,8 @@ void CE::ThumbnailEditorSystem::Tick(float deltaTime)
 		}
 		else
 		{
-			CurrentlyGenerating& result = mCurrentlyGenerating.emplace_back(std::move(std::get<World>(generatedThumbnail)), it->mForAsset);
+			std::unique_ptr<World>& world = std::get<std::unique_ptr<World>>(generatedThumbnail);
+			CurrentlyGenerating& result = mCurrentlyGenerating.emplace_back(std::move(world), it->mForAsset);
 			result.mTimeNeededToCreateWorld = timeToGenerate.GetSecondsElapsed();
 		}
 
@@ -266,12 +267,6 @@ CE::ThumbnailEditorSystem::GeneratedThumbnail::GeneratedThumbnail(AssetHandle<Te
 {
 }
 
-CE::ThumbnailEditorSystem::CurrentlyGenerating::CurrentlyGenerating(World&& world, WeakAssetHandle<> forAsset) :
-	mWorld(std::move(world)),
-	mForAsset(std::move(forAsset))
-{
-}
-
 CE::GetThumbnailRet CE::Internal::GenerateThumbnail(WeakAssetHandle<> forAsset)
 {
 	if (forAsset == nullptr)
@@ -332,18 +327,18 @@ CE::GetThumbnailRet GetThumbNailImpl<CE::Level>(const CE::WeakAssetHandle<CE::Le
 template <>
 CE::GetThumbnailRet GetThumbNailImpl<CE::Prefab>(const CE::WeakAssetHandle<CE::Prefab>& forAsset)
 {
-	CE::World world = CE::Level::CreateDefaultWorld();
-	world.GetRegistry().CreateFromPrefab(*CE::AssetHandle<CE::Prefab>{ forAsset });
+	std::unique_ptr<CE::World> world = CE::Level::CreateDefaultWorld();
+	world->GetRegistry().CreateFromPrefab(*CE::AssetHandle<CE::Prefab>{ forAsset });
 	return world;
 }
 
 template <>
 CE::GetThumbnailRet GetThumbNailImpl<CE::StaticMesh>(const CE::WeakAssetHandle<CE::StaticMesh>& forAsset)
 {
-	CE::World world = CE::Level::CreateDefaultWorld();
+	std::unique_ptr<CE::World> world = CE::Level::CreateDefaultWorld();
+	CE::Registry& reg = world->GetRegistry();
 
 	{
-		CE::Registry& reg = world.GetRegistry();
 		const entt::entity entity = reg.Create();
 
 		reg.AddComponent<CE::TransformComponent>(entity);
@@ -359,10 +354,10 @@ CE::GetThumbnailRet GetThumbNailImpl<CE::StaticMesh>(const CE::WeakAssetHandle<C
 template <>
 CE::GetThumbnailRet GetThumbNailImpl<CE::Material>(const CE::WeakAssetHandle<CE::Material>& forAsset)
 {
-	CE::World world = CE::Level::CreateDefaultWorld();
+	std::unique_ptr<CE::World> world = CE::Level::CreateDefaultWorld();
+	CE::Registry& reg = world->GetRegistry();
 
 	{
-		CE::Registry& reg = world.GetRegistry();
 		const entt::entity entity = reg.Create();
 
 		reg.AddComponent<CE::TransformComponent>(entity).SetLocalScale(2.5f);
diff --git a/Source/Meta/ReflectedTypes/ENTT/ReflectEntity.cpp b/Source/Meta/ReflectedTypes/ENTT/ReflectEntity.cpp
index b1211240..8fe7cae4 100644
--- a/Source/Meta/ReflectedTypes/ENTT/ReflectEntity.cpp
+++ b/Source/Meta/ReflectedTypes/ENTT/ReflectEntity.cpp
@@ -57,26 +57,22 @@ MetaType Reflector<T>::Reflect()
 		}, "ToString", MetaFunc::ExplicitParams<const T&>{}).GetProperties().Add(Props::sIsScriptableTag);
 
 
-	type.AddFunc([](const entt::entity& entity)
+	type.AddFunc([](const World& world, const entt::entity& entity)
 		{
-			const World* world = World::TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			return world->GetRegistry().Valid(entity);
-		}, "IsAlive", MetaFunc::ExplicitParams<const T&>{}).GetProperties().Add(Props::sIsScriptableTag);
+			return world.GetRegistry().Valid(entity);
+		}, "IsAlive", MetaFunc::ExplicitParams<const World&, const T&>{}).GetProperties().Add(Props::sIsScriptableTag);
 
 
-	type.AddFunc([](const entt::entity& entity, const ComponentFilter& component)
+	type.AddFunc([](World& world, const entt::entity& entity, const ComponentFilter& component)
 		{
 			if (component == nullptr)
 			{
 				return;
 			}
 
-			World* world = World::TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			world->GetRegistry().AddComponent(*component.Get(), entity);
+			world.GetRegistry().AddComponent(*component.Get(), entity);
 
-		}, "AddComponent", MetaFunc::ExplicitParams<const T&, const ComponentFilter&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
+		}, "AddComponent", MetaFunc::ExplicitParams<World&, const T&, const ComponentFilter&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
 
 	ReflectFieldType<T>(type);
 
diff --git a/Source/UnitTests/LevelAndPrefabSerializationUnitTests.cpp b/Source/UnitTests/LevelAndPrefabSerializationUnitTests.cpp
index 33e5b80f..c66865c0 100644
--- a/Source/UnitTests/LevelAndPrefabSerializationUnitTests.cpp
+++ b/Source/UnitTests/LevelAndPrefabSerializationUnitTests.cpp
@@ -21,9 +21,9 @@ static constexpr std::string_view sTestPrefabName = "__TestPrefab__";
 
 namespace
 {
-	World ReloadUsingLevel(World&& world);
+	std::unique_ptr<World> ReloadUsingLevel(std::unique_ptr<World> world);
 
-	World ReloadUsingPrefab(World&& world, entt::entity entity);
+	std::unique_ptr<World> ReloadUsingPrefab(std::unique_ptr<World> world, entt::entity entity);
 
 	struct PrefabChange
 	{
@@ -37,7 +37,7 @@ namespace
 		static MetaType Reflect();
 	};
 
-	UnitTest::Result TestPrefabChanges(World&& initialWorld,
+	UnitTest::Result TestPrefabChanges(std::unique_ptr<World> initialWorld,
 		entt::entity initialEntity,
 		std::vector<PrefabChange> changes,
 		std::function<void(World&, entt::entity)>&& changePrefabInstanceInWorld = {});
@@ -51,8 +51,8 @@ UNIT_TEST(Serialization, NoPrefabsLevelSerialization)
 	static const std::string childName = "ChildName\t\n\t!!";
 	static constexpr glm::vec3 childPosition = -glm::vec3{ 102.0f, 2035.f, -2035.f };
 
-	World world{ false };
-	Registry& reg = world.GetRegistry();
+	std::unique_ptr<World> world = std::make_unique<World>(false);
+	Registry& reg = world->GetRegistry();
 
 	const entt::entity parent = reg.Create();
 	const entt::entity child = reg.Create();
@@ -68,8 +68,8 @@ UNIT_TEST(Serialization, NoPrefabsLevelSerialization)
 		childTransform.SetParent(&reg.Get<TransformComponent>(parent));
 	}
 
-	World reloadedWorld = ReloadUsingLevel(std::move(world));
-	Registry& reloadedReg = reloadedWorld.GetRegistry();
+	const std::unique_ptr<World> reloadedWorld = ReloadUsingLevel(std::move(world));
+	Registry& reloadedReg = reloadedWorld->GetRegistry();
 
 	TEST_ASSERT(reloadedReg.Valid(parent));
 	TEST_ASSERT(reloadedReg.Valid(child));
@@ -100,8 +100,8 @@ UNIT_TEST(Serialization, PrefabsSerialization)
 	static const std::string childName = "ChildName\t\n\t!!";
 	static constexpr glm::vec3 childPosition = -glm::vec3{ 102.0f, 2035.f, -2035.f };
 
-	World world{ false };
-	Registry& reg = world.GetRegistry();
+	std::unique_ptr<World> world = std::make_unique<World>(false);
+	Registry& reg = world->GetRegistry();
 
 	const entt::entity parent = reg.Create();
 	const entt::entity child = reg.Create();
@@ -117,8 +117,8 @@ UNIT_TEST(Serialization, PrefabsSerialization)
 		childTransform.SetParent(&reg.Get<TransformComponent>(parent));
 	}
 
-	World reloadedWorld = ReloadUsingPrefab(std::move(world), parent);
-	Registry& reloadedReg = reloadedWorld.GetRegistry();
+	std::unique_ptr<World>  reloadedWorld = ReloadUsingPrefab(std::move(world), parent);
+	Registry& reloadedReg = reloadedWorld->GetRegistry();
 
 	TEST_ASSERT(reloadedReg.Valid(parent));
 	TEST_ASSERT(reloadedReg.Valid(child));
@@ -149,13 +149,13 @@ UNIT_TEST(Serialization, PrefabsSerialization)
 
 UNIT_TEST(Serialization, EmptyEntityLevelSerialization)
 {
-	World world{ false };
-	Registry& reg = world.GetRegistry();
+	std::unique_ptr<World> world = std::make_unique<World>(false);
+	Registry& reg = world->GetRegistry();
 
 	const entt::entity entity = reg.Create();
 
-	World reloadedWorld = ReloadUsingLevel(std::move(world));
-	Registry& reloadedReg = reloadedWorld.GetRegistry();
+	std::unique_ptr<World> reloadedWorld = ReloadUsingLevel(std::move(world));
+	Registry& reloadedReg = reloadedWorld->GetRegistry();
 
 	TEST_ASSERT(reloadedReg.Valid(entity));
 	TEST_ASSERT(reloadedReg.Storage<entt::entity>().in_use() == 1);
@@ -165,15 +165,15 @@ UNIT_TEST(Serialization, EmptyEntityLevelSerialization)
 
 UNIT_TEST(Serialization, EmptyComponentLevelSerialization)
 {
-	World world{ false };
-	Registry& reg = world.GetRegistry();
+	std::unique_ptr<World> world = std::make_unique<World>(false);
+	Registry& reg = world->GetRegistry();
 
 	const entt::entity entity = reg.Create(); 
 	reg.AddComponent<EmptyEventTestingComponent>(entity);
 	TEST_ASSERT(reg.HasComponent<EmptyEventTestingComponent>(entity));
 
-	World reloadedWorld = ReloadUsingLevel(std::move(world));
-	Registry& reloadedReg = reloadedWorld.GetRegistry();
+	std::unique_ptr<World> reloadedWorld = ReloadUsingLevel(std::move(world));
+	Registry& reloadedReg = reloadedWorld->GetRegistry();
 
 	TEST_ASSERT(reloadedReg.Valid(entity));
 	TEST_ASSERT(reloadedReg.Storage<entt::entity>().in_use() == 1);
@@ -184,13 +184,13 @@ UNIT_TEST(Serialization, EmptyComponentLevelSerialization)
 
 UNIT_TEST(Serialization, EmptyEntityPrefabSerialization)
 {
-	World world{ false };
-	Registry& reg = world.GetRegistry();
+	std::unique_ptr<World> world = std::make_unique<World>(false);
+	Registry& reg = world->GetRegistry();
 
 	const entt::entity entity = reg.Create();
 
-	World reloadedWorld = ReloadUsingPrefab(std::move(world), entity);
-	Registry& reloadedReg = reloadedWorld.GetRegistry();
+	std::unique_ptr<World> reloadedWorld = ReloadUsingPrefab(std::move(world), entity);
+	Registry& reloadedReg = reloadedWorld->GetRegistry();
 
 	TEST_ASSERT(reloadedReg.Valid(entity));
 	TEST_ASSERT(reloadedReg.Storage<entt::entity>().in_use() == 1);
@@ -200,9 +200,9 @@ UNIT_TEST(Serialization, EmptyEntityPrefabSerialization)
 
 UNIT_TEST(Serialization, PrefabAddComponent)
 {
-	World world{ false };
+	std::unique_ptr<World> world = std::make_unique<World>(false);
 
-	Registry& reg = world.GetRegistry();
+	Registry& reg = world->GetRegistry();
 	entt::entity entity = reg.Create();
 
 	return TestPrefabChanges(std::move(world), entity,
@@ -229,9 +229,9 @@ UNIT_TEST(Serialization, PrefabAddComponent)
 
 UNIT_TEST(Serialization, PrefabRemoveComponent)
 {
-	World world{ false };
+	std::unique_ptr<World> world = std::make_unique<World>(false);
 
-	Registry& reg = world.GetRegistry();
+	Registry& reg = world->GetRegistry();
 	entt::entity entity = reg.Create();
 	reg.AddComponent<NameComponent>(entity);
 
@@ -261,9 +261,9 @@ UNIT_TEST(Serialization, PrefabRemoveComponent)
 
 UNIT_TEST(Serialization, PrefabAddChild)
 {
-	World world{ false };
+	std::unique_ptr<World> world = std::make_unique<World>(false);
 
-	Registry& reg = world.GetRegistry();
+	Registry& reg = world->GetRegistry();
 	entt::entity parent = reg.Create();
 	reg.AddComponent<TransformComponent>(parent);
 
@@ -315,9 +315,9 @@ UNIT_TEST(Serialization, PrefabAddChild)
 
 UNIT_TEST(Serialization, PrefabRemoveChild)
 {
-	World world{ false };
+	std::unique_ptr<World> world = std::make_unique<World>(false);
 
-	Registry& reg = world.GetRegistry();
+	Registry& reg = world->GetRegistry();
 	entt::entity parent = reg.Create();
 	reg.AddComponent<TransformComponent>(parent);
 
@@ -369,9 +369,9 @@ UNIT_TEST(Serialization, PrefabRemoveChild)
 
 UNIT_TEST(Serialization, PrefabChildRemovedWhileInstancesHaveChanges)
 {
-	World world{ false };
+	std::unique_ptr<World> world = std::make_unique<World>(false);
 
-	Registry& reg = world.GetRegistry();
+	Registry& reg = world->GetRegistry();
 	entt::entity parent = reg.Create();
 	reg.AddComponent<TransformComponent>(parent);
 
@@ -445,8 +445,8 @@ UNIT_TEST(Serialization, CopyPaste)
 	static const std::string childName = "ChildName\t\n\t!!";
 	static constexpr glm::vec3 childPosition = -glm::vec3{ 102.0f, 2035.f, -2035.f };
 
-	World world{ false };
-	Registry& reg = world.GetRegistry();
+	std::unique_ptr<World> world = std::make_unique<World>(false);
+	Registry& reg = world->GetRegistry();
 
 	const entt::entity parent = reg.Create();
 	const entt::entity child = reg.Create();
@@ -503,8 +503,8 @@ UNIT_TEST(Serialization, CopyPaste)
 
 			if (depthRemaining > 0)
 			{
-				BinaryGSONObject copy = Archiver::Serialize(world, std::array<entt::entity, 2>{ parent, child }, true);
-				const std::vector<entt::entity> copiedEntities = Archiver::Deserialize(world, copy);
+				BinaryGSONObject copy = Archiver::Serialize(*world, std::array<entt::entity, 2>{ parent, child }, true);
+				const std::vector<entt::entity> copiedEntities = Archiver::Deserialize(*world, copy);
 				entitiesToCheck.insert(entitiesToCheck.end(), copiedEntities.begin(), copiedEntities.end());
 				return doesMatch(entitiesToCheck);
 			}
@@ -517,10 +517,10 @@ UNIT_TEST(Serialization, CopyPaste)
 
 namespace
 {
-	World ReloadUsingLevel(World&& world)
+	std::unique_ptr<World> ReloadUsingLevel(std::unique_ptr<World> world)
 	{
 		Level testLevel{ sTestLevelName };
-		testLevel.CreateFromWorld(world);
+		testLevel.CreateFromWorld(*world);
 
 		AssetLoadInfo savedLevel = testLevel.Save();
 
@@ -528,17 +528,17 @@ namespace
 		return reloadedLevel.CreateWorld(false);
 	}
 
-	World ReloadUsingPrefab(World&& world, entt::entity entity)
+	std::unique_ptr<World> ReloadUsingPrefab(std::unique_ptr<World> world, entt::entity entity)
 	{
 		Prefab testPrefab{ sTestPrefabName };
-		testPrefab.CreateFromEntity(world, entity);
+		testPrefab.CreateFromEntity(*world, entity);
 
 		AssetLoadInfo savedPrefab = testPrefab.Save();
 
 		Prefab reloadedPrefab{ savedPrefab };
 
-		World reloadedWorld{ false };
-		Registry& reloadedReg = reloadedWorld.GetRegistry();
+		std::unique_ptr<World> reloadedWorld = std::make_unique<World>(false);
+		Registry& reloadedReg = reloadedWorld->GetRegistry();
 		reloadedReg.CreateFromPrefab(reloadedPrefab, entity);
 		return reloadedWorld;
 	}
@@ -554,7 +554,7 @@ namespace
 		return type;
 	}
 
-	UnitTest::Result TestPrefabChanges(World&& initialWorld,
+	UnitTest::Result TestPrefabChanges(std::unique_ptr<World> initialWorld,
 	                                   entt::entity initialEntity,
 	                                   std::vector<PrefabChange> changes,
 	                                   std::function<void(World&, entt::entity)>&& changePrefabInstanceInWorld)
@@ -582,7 +582,7 @@ namespace
 				if (prefabInAssetManager == nullptr)
 				{
 					Prefab testPrefab{ sTestPrefabName };
-					testPrefab.CreateFromEntity(initialWorld, initialEntity);
+					testPrefab.CreateFromEntity(*initialWorld, initialEntity);
 					prefabInAssetManager = AssetManager::Get().AddAsset(std::move(testPrefab));
 				}
 				else
@@ -600,7 +600,7 @@ namespace
 					}
 
 					Prefab newPrefab{ loadInfo };
-					newPrefab.CreateFromEntity(initialWorld, initialEntity);
+					newPrefab.CreateFromEntity(*initialWorld, initialEntity);
 					prefabInAssetManager = AssetManager::Get().AddAsset(std::move(newPrefab));
 				}
 			};
@@ -629,7 +629,7 @@ namespace
 
 			for (const PrefabChange& change : changes)
 			{
-				UnitTest::Result result = change.mMakeChanges(initialWorld, initialEntity);
+				UnitTest::Result result = change.mMakeChanges(*initialWorld, initialEntity);
 
 				if (result != UnitTest::Result::Success)
 				{
@@ -639,8 +639,8 @@ namespace
 				updatePrefab();
 				AssetLoadInfo loadInfo{ serializedLevel };
 				Level level{ loadInfo };
-				World worldWithChangesApplied = level.CreateWorld(false);
-				result = change.mCheckChanges(worldWithChangesApplied, initialEntity);
+				std::unique_ptr<World> worldWithChangesApplied = level.CreateWorld(false);
+				result = change.mCheckChanges(*worldWithChangesApplied, initialEntity);
 
 				if (result != UnitTest::Result::Success)
 				{
diff --git a/Source/Utilities/ASync.cpp b/Source/Utilities/ASync.cpp
deleted file mode 100644
index da1a990e..00000000
--- a/Source/Utilities/ASync.cpp
+++ /dev/null
@@ -1,195 +0,0 @@
-#include "Precomp.h"
-#include "Utilities/ASync.h"
-
-#include <forward_list>
-#include <mutex>
-#include <thread>
-
-namespace
-{
-	struct Worker;
-}
-
-namespace CE::Internal
-{
-	struct Job
-	{
-		Job(std::function<void()>&& workload, std::weak_ptr<Worker>&& worker);
-
-		std::function<void()> mWorkload{};
-		std::weak_ptr<Worker> mWorker{};
-		bool mIsCancelled{};
-		bool mIsCurrentlyBeingDone{};
-		std::mutex mMutex{};
-	};
-}
-
-namespace
-{
-	struct Worker
-	{
-		~Worker();
-
-		void RunWorkerThread();
-
-		std::thread mThread{
-			[this]
-			{
-				RunWorkerThread();
-			}
-		};
-		std::list<std::shared_ptr<CE::Internal::Job>> mJobs{};
-		std::mutex mJobsMutex{};
-		bool mShouldStopWorking{};
-	};
-
-	void DoJob(std::shared_ptr<CE::Internal::Job> job);
-
-	std::vector<std::shared_ptr<Worker>> sWorkers{};
-	std::mutex sWorkersMutex{};
-}
-
-CE::Internal::Job::Job(std::function<void()>&& workload, std::weak_ptr<Worker>&& worker) :
-	mWorkload(std::move(workload)),
-	mWorker(std::move(worker))
-{
-}
-
-Worker::~Worker()
-{
-	mShouldStopWorking = true;
-	mThread.join();
-}
-
-void Worker::RunWorkerThread()
-{
-	while (!mShouldStopWorking)
-	{
-		if (mJobs.empty())
-		{
-			continue;
-		}
-
-		std::shared_ptr<CE::Internal::Job> jobToDo{};
-
-		mJobsMutex.lock();
-
-		if (mJobs.empty())
-		{
-			mJobsMutex.unlock();
-			continue;
-		}
-
-		jobToDo = mJobs.front();
-		mJobsMutex.unlock();
-
-		DoJob(std::move(jobToDo));
-	}
-}
-
-CE::ASyncThread::ASyncThread(std::function<void()>&& work)
-{
-	std::shared_ptr<Worker> bestWorker{};
-
-	sWorkersMutex.lock();
-
-	// Find the worker with the least amount of jobs.
-	for (const std::shared_ptr<Worker>& worker : sWorkers)
-	{
-		// If we find a thread with no work left, we assign the job.
-		if (worker->mJobs.empty())
-		{
-			bestWorker = std::move(worker);
-			break;
-		}
-
-		if (bestWorker == nullptr
-			|| worker->mJobs.size() < bestWorker->mJobs.size())
-		{
-			bestWorker = std::move(worker);
-		}
-	}
-
-	if (bestWorker == nullptr
-		|| (bestWorker->mJobs.size() > 8 && sWorkers.size() < 7))
-	{
-		bestWorker = sWorkers.emplace_back(std::make_shared<Worker>());
-	}
-
-	sWorkersMutex.unlock();
-
-	bestWorker->mJobsMutex.lock();
-	mJob = bestWorker->mJobs.emplace_back(std::make_shared<Internal::Job>(std::move(work), bestWorker));
-	bestWorker->mJobsMutex.unlock();
-}
-
-CE::ASyncThread::~ASyncThread()
-{
-	ASSERT(!WasLaunched());
-}
-
-bool CE::ASyncThread::WasLaunched() const
-{
-	return mJob != nullptr;
-}
-
-void CE::ASyncThread::CancelOrJoin()
-{
-	ASSERT(WasLaunched());
-	mJob->mIsCancelled = true;
-	Join();
-}
-
-void CE::ASyncThread::CancelOrDetach()
-{
-	ASSERT(WasLaunched());
-	mJob->mIsCancelled = true;
-	Detach();
-}
-
-void CE::ASyncThread::Join()
-{
-	ASSERT(WasLaunched());
-	DoJob(mJob);
-	mJob = nullptr;
-}
-
-void CE::ASyncThread::Detach()
-{
-	mJob = nullptr;
-}
-
-namespace
-{
-	void DoJob(const std::shared_ptr<CE::Internal::Job> job)
-	{
-		if (job == nullptr)
-		{
-			return;
-		}
-
-		const std::shared_ptr thread = job->mWorker.lock();
-
-		if (thread == nullptr)
-		{
-			return;
-		}
-
-		thread->mJobsMutex.lock();
-		thread->mJobs.remove(job);
-		thread->mJobsMutex.unlock();
-
-		job->mMutex.lock();
-
-		// Could've been cancelled from another thread
-		// during the last few lines
-		if (!job->mIsCancelled
-			&& !job->mIsCurrentlyBeingDone)
-		{
-			job->mIsCurrentlyBeingDone = true;
-			job->mWorkload();
-		}
-
-		job->mMutex.unlock();
-	}
-}
diff --git a/Source/Utilities/Benchmark.cpp b/Source/Utilities/Benchmark.cpp
index a08fc9ee..ecb1e931 100644
--- a/Source/Utilities/Benchmark.cpp
+++ b/Source/Utilities/Benchmark.cpp
@@ -77,8 +77,8 @@ CE::BenchmarkResult CE::BenchMark(std::string_view levelName, BenchmarkParams pa
         return {};
     }
 
-	World world = level->CreateWorld(true);
-    return BenchMark(world, params);
+	std::unique_ptr<World> world = level->CreateWorld(true);
+    return BenchMark(*world, params);
 }
 
 void CE::BenchmarkResult::Print() const
diff --git a/Source/Utilities/Events.cpp b/Source/Utilities/Events.cpp
index 656c27ba..e683b5c6 100644
--- a/Source/Utilities/Events.cpp
+++ b/Source/Utilities/Events.cpp
@@ -120,9 +120,6 @@ void CE::EventBase::Define(MetaFunc& metaFunc, const ScriptFunc& scriptFunc, con
 	metaFunc.RedirectFunction([&scriptFunc, script, firstNode = scriptFunc.GetFirstNode().GetValue(), entry = scriptFunc.GetEntryNode().GetValue(), numOfArgsToPass]
 		(MetaFunc::DynamicArgs args, MetaFunc::RVOBuffer rvoBuffer) -> FuncResult
 		{
-			World& world = *args[1].As<World>();
-			World::PushWorld(world);
-
 			// Raii object that manages the lifetime
 			struct ParamDeleter
 			{
@@ -148,9 +145,7 @@ void CE::EventBase::Define(MetaFunc& metaFunc, const ScriptFunc& scriptFunc, con
 				new (&scriptArgs[i + 1])MetaAny(MakeRef(args[i + 3]));
 			}
 
-			FuncResult result = VirtualMachine::Get().ExecuteScriptFunction(std::span<MetaAny>{ scriptArgs, numOfArgsToPass}, rvoBuffer, scriptFunc, firstNode, entry);
-
-			World::PopWorld();
+			FuncResult result = VirtualMachine::Get().ExecuteScriptFunction(std::span{ scriptArgs, numOfArgsToPass}, rvoBuffer, scriptFunc, firstNode, entry);
 			return result;
 		});
 }
diff --git a/Source/Utilities/Imgui/WorldDetailsPanel.cpp b/Source/Utilities/Imgui/WorldDetailsPanel.cpp
index 903e64c1..da4d5d26 100644
--- a/Source/Utilities/Imgui/WorldDetailsPanel.cpp
+++ b/Source/Utilities/Imgui/WorldDetailsPanel.cpp
@@ -116,12 +116,12 @@ void CE::WorldDetails::Display(World& world, std::vector<entt::entity>& selected
 
 						if (onInspect->mIsStatic)
 						{
-							onInspect->mFunc.get().InvokeCheckedUnpacked(world, selectedEntities[0]);
+							onInspect->mFunc.get().InvokeUncheckedUnpacked(world, selectedEntities[0]);
 						}
 						else
 						{
 							MetaAny component = reg.Get(componentClass.GetTypeId(), selectedEntities[0]);
-							onInspect->mFunc.get().InvokeCheckedUnpacked(component, world, selectedEntities[0]);
+							onInspect->mFunc.get().InvokeUncheckedUnpacked(component, world, selectedEntities[0]);
 						}
 					}
 				}
@@ -136,12 +136,15 @@ void CE::WorldDetails::Display(World& world, std::vector<entt::entity>& selected
 				continue;
 			}
 
-			const bool isMemberFunc = func.GetParameters().size() == 1 && func.GetParameters()[0].mTypeTraits.mStrippedTypeId == componentClass.GetTypeId();
+			const bool isMemberFunc = func.GetParameters().size() >= 1
+					&& func.GetParameters()[0].mTypeTraits.mStrippedTypeId == componentClass.GetTypeId();
 
-			if (!func.GetParameters().empty()
-				&& !isMemberFunc)
+			const bool doesFuncRequireWorld = func.GetParameters().size() >= (isMemberFunc + 1)
+				&& func.GetParameters()[isMemberFunc].mTypeTraits.mStrippedTypeId == MakeTypeId<World>();
+
+			if (func.GetParameters().size() > isMemberFunc + doesFuncRequireWorld)
 			{
-				LOG(LogEditor, Warning, "Function {}::{} has {} property, but the function has parameters",
+				LOG(LogEditor, Warning, "Function {}::{} has {} property, but the function has parameters that cannot be passed in from here",
 					componentClass.GetName(), func.GetDesignerFriendlyName(), Props::sCallFromEditorTag);
 				continue;
 			}
@@ -172,23 +175,20 @@ void CE::WorldDetails::Display(World& world, std::vector<entt::entity>& selected
 				{
 					for (const entt::entity entity : selectedEntities)
 					{
+						std::vector<MetaAny> args{};
+						static constexpr std::array forms{ TypeForm::Ref, TypeForm::Ref };
+
 						if (isMemberFunc)
 						{
-							MetaAny component{ componentClass, storage->value(entity), false };
-
-							if (component == nullptr)
-							{
-								LOG(LogEditor, Error, "Error invoking {}::{}: Component was unexpectedly nullptr",
-									componentClass.GetName(), func.GetDesignerFriendlyName());
-								continue;
-							}
-
-							func.InvokeUncheckedUnpacked(component);
+							args.emplace_back(componentClass, storage->value(entity), false);
 						}
-						else
+
+						if (doesFuncRequireWorld)
 						{
-							func.InvokeUncheckedUnpacked();
+							args.emplace_back(world);
 						}
+
+						func.InvokeUnchecked(args, std::span{ forms.data(), static_cast<size_t>(isMemberFunc + doesFuncRequireWorld) });
 					}
 				}
 				else
diff --git a/Source/Utilities/Imgui/WorldInspect.cpp b/Source/Utilities/Imgui/WorldInspect.cpp
index b79c7fb0..a7dc1f4a 100644
--- a/Source/Utilities/Imgui/WorldInspect.cpp
+++ b/Source/Utilities/Imgui/WorldInspect.cpp
@@ -54,9 +54,9 @@ namespace CE::Internal
 	static constexpr std::string_view sCopiedEntitiesId = "B1C2FF80";
 }
 
-CE::WorldInspectHelper::WorldInspectHelper(World&& worldThatHasNotYetBegunPlay) :
+CE::WorldInspectHelper::WorldInspectHelper(std::unique_ptr<World> worldThatHasNotYetBegunPlay) :
 	mViewportFrameBuffer(std::make_unique<FrameBuffer>(glm::ivec2(1.f, 1.f))),
-	mWorldBeforeBeginPlay(std::make_unique<World>(std::move(worldThatHasNotYetBegunPlay)))
+	mWorldBeforeBeginPlay(std::move(worldThatHasNotYetBegunPlay))
 {
 	ASSERT(!mWorldBeforeBeginPlay->HasBegunPlay());
 }
@@ -263,7 +263,6 @@ void CE::WorldInspectHelper::DisplayAndTick(const float deltaTime)
 
 		// World will not change anymore
 		World& world = GetWorld();
-		World::PushWorld(world);
 
 		const glm::vec2 fpsCursorPos = { viewportPos.x + mViewportWidth - 60.0f, 0.0f };
 		ImGui::SetCursorPos(fpsCursorPos);
@@ -323,8 +322,6 @@ void CE::WorldInspectHelper::DisplayAndTick(const float deltaTime)
 
 		drawList->ChannelsMerge();
 
-		World::PopWorld();
-
 		if (world.HasRequestedEndPlay())
 		{
 			(void)EndPlay();
@@ -337,7 +334,6 @@ void CE::WorldInspectHelper::DisplayAndTick(const float deltaTime)
 	if (ImGui::BeginChild("HierarchyAndDetailsWindow", { mHierarchyAndDetailsWidth, 0.0f }, false, ImGuiWindowFlags_NoScrollbar))
 	{
 		World& world = GetWorld();
-		World::PushWorld(world);
 
 		ImGui::PushID(2); // Second splitter requires new ID
 		ImGui::Splitter(false, &mHierarchyHeight, &mDetailsHeight);
@@ -350,8 +346,6 @@ void CE::WorldInspectHelper::DisplayAndTick(const float deltaTime)
 		ImGui::BeginChild("WorldDetails", { 0.0f, mDetailsHeight - 5.0f }, false, ImGuiWindowFlags_NoScrollbar);
 		WorldDetails::Display(world, mSelectedEntities);
 		ImGui::EndChild();
-
-		World::PopWorld();
 	}
 
 	ImGui::EndChild();
diff --git a/Source/Utilities/Search.cpp b/Source/Utilities/Search.cpp
index b0d54808..2ae59e19 100644
--- a/Source/Utilities/Search.cpp
+++ b/Source/Utilities/Search.cpp
@@ -5,7 +5,7 @@
 #include <stack>
 #include <imgui/imgui_internal.h>
 
-#include "Utilities/ASync.h"
+#include "Core/ThreadPool.h"
 #include "Utilities/ManyStrings.h"
 #include "Utilities/Math.h"
 
@@ -67,8 +67,7 @@ namespace
 	{
 		~Result();
 
-		CE::ASyncThread mThread{};
-        bool mIsReady{};
+		std::future<void> mFuture{};
 
 		Input mInput{};
 		ReusableBuffers mBuffers{};
@@ -135,19 +134,14 @@ void CE::Search::End()
 	SearchContext& context = sContextStack.top();
 
 	// Check if the result from our previous thread is ready
-    if (context.mResults[!context.mIndexOfLastValidResult].mIsReady)
+    if (IsFutureReady(context.mResults[!context.mIndexOfLastValidResult].mFuture))
     {
         // Note that we do not check if the pending result is still valid.
         // We do this later, where we check if the last valid result is
         // still valid. Since our pending result now becomes our last valid result,
         // we can defer that check.
         Result& pendingResult = context.mResults[!context.mIndexOfLastValidResult];
-
-        if (pendingResult.mThread.WasLaunched())
-        {
-            pendingResult.mThread.Join();
-        }
-        pendingResult.mIsReady = false;
+		pendingResult.mFuture.get();
 
         // Swap the buffers
 		context.mIndexOfLastValidResult = !context.mIndexOfLastValidResult;
@@ -168,19 +162,13 @@ void CE::Search::End()
 	Result& pendingResult = context.mResults[!context.mIndexOfLastValidResult];
 
 	if (!IsResultUpToDate(lastValidResult, context.mInput)
-		&& !pendingResult.mThread.WasLaunched())
+		&& !pendingResult.mFuture.valid())
 	{
 		pendingResult.mInput = context.mInput;
-		pendingResult.mIsReady = false;
-
-		pendingResult.mThread =
-		{
-			[&pendingResult]
+		pendingResult.mFuture = ThreadPool::Get().Enqueue([&pendingResult]
 			{
 				BringResultUpToDate(pendingResult);
-				pendingResult.mIsReady = true;
-			}
-		};
+			});
 	}
 
 	if (!context.mInput.mEntries.empty()
@@ -434,9 +422,9 @@ namespace
 
 	Result::~Result()
 	{
-		if (mThread.WasLaunched())
+		if (mFuture.valid())
 		{
-			mThread.CancelOrJoin();
+			mFuture.wait();
 		}
 	}
 
diff --git a/Source/Utilities/StaticReflection/ReflectComponentType.cpp b/Source/Utilities/StaticReflection/ReflectComponentType.cpp
index e1819c4c..1205e2ad 100644
--- a/Source/Utilities/StaticReflection/ReflectComponentType.cpp
+++ b/Source/Utilities/StaticReflection/ReflectComponentType.cpp
@@ -40,12 +40,10 @@ void CE::Internal::ReflectRuntimeComponentType(MetaType& type, bool isEmpty)
 		entityType.AddFunc(
 			[&type](MetaFunc::DynamicArgs args, MetaFunc::RVOBuffer) -> FuncResult
 			{
-				World* world = World::TryGetWorldAtTopOfStack();
-				ASSERT(world != nullptr && "Reached a scripting context without pushing a world");
+				World& world = *static_cast<World*>(args[0].GetData());
+				const entt::entity entity = *static_cast<entt::entity*>(args[1].GetData());
 
-				entt::entity entity = *static_cast<entt::entity*>(args[0].GetData());
-
-				Registry& reg = world->GetRegistry();
+				Registry& reg = world.GetRegistry();
 
 				const MetaAny existingComponent = reg.TryGet(type.GetTypeId(), entity);
 
@@ -55,11 +53,11 @@ void CE::Internal::ReflectRuntimeComponentType(MetaType& type, bool isEmpty)
 						type.GetName(), entt::to_integral(entity));
 				}
 
-				return world->GetRegistry().AddComponent(type, entity);
+				return world.GetRegistry().AddComponent(type, entity);
 			},
 			Internal::GetAddComponentFuncName(type.GetName()),
 			MetaFunc::Return{ { type.GetTypeId(), TypeForm::Ref } },
-			MetaFunc::Params{ { MakeTypeTraits<const entt::entity&>(), "Entity" } }).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
+			MetaFunc::Params{ { MakeTypeTraits<World&>() }, { MakeTypeTraits<entt::entity>() }}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
 	}
 
 	if (!isEmpty)
@@ -67,49 +65,42 @@ void CE::Internal::ReflectRuntimeComponentType(MetaType& type, bool isEmpty)
 		entityType.AddFunc(
 			[typeId = type.GetTypeId()](MetaFunc::DynamicArgs args, MetaFunc::RVOBuffer) -> FuncResult
 			{
-				World* world = World::TryGetWorldAtTopOfStack();
-				ASSERT(world != nullptr && "Reached a scripting context without pushing a world");
-
-				const entt::entity entity = *static_cast<entt::entity*>(args[0].GetData());
-
-				return world->GetRegistry().TryGet(typeId, entity);
+				World& world = *static_cast<World*>(args[0].GetData());
+				const entt::entity entity = *static_cast<entt::entity*>(args[1].GetData());
+				return world.GetRegistry().TryGet(typeId, entity);
 			},
 			GetGetComponentFuncName(type.GetName()),
 			MetaFuncNamedParam{ { type.GetTypeId(), TypeForm::Ptr } }, // Return value
-			std::vector<MetaFuncNamedParam>{ { MakeTypeTraits<const entt::entity&>() } }
+			std::vector<MetaFuncNamedParam>{ { MakeTypeTraits<World&>() }, { MakeTypeTraits<entt::entity>() } }
 		).GetProperties().Add(Props::sIsScriptableTag);
 	}
-	else
-	{
-		entityType.AddFunc(
-			[typeId = type.GetTypeId()](MetaFunc::DynamicArgs args, MetaFunc::RVOBuffer rvoBuffer) -> FuncResult
-			{
-				World* world = World::TryGetWorldAtTopOfStack();
-				ASSERT(world != nullptr && "Reached a scripting context without pushing a world");
 
-				const entt::entity entity = *static_cast<entt::entity*>(args[0].GetData());
+	entityType.AddFunc(
+		[typeId = type.GetTypeId()](MetaFunc::DynamicArgs args, MetaFunc::RVOBuffer rvoBuffer) -> FuncResult
+		{
+			const World& world = *static_cast<const World*>(args[0].GetData());
+			const entt::entity entity = *static_cast<entt::entity*>(args[1].GetData());
 
-				return MetaAny{ world->GetRegistry().HasComponent(typeId, entity), rvoBuffer };
-			},
-			GetHasComponentFuncName(type.GetName()),
-			MetaFuncNamedParam{ MakeTypeTraits<bool>() }, // Return value
-			std::vector<MetaFuncNamedParam>{ { MakeTypeTraits<const entt::entity&>() } }
-		).GetProperties().Add(Props::sIsScriptableTag);
-	}
+			return MetaAny{ world.GetRegistry().HasComponent(typeId, entity), rvoBuffer };
+		},
+		GetHasComponentFuncName(type.GetName()),
+		MetaFuncNamedParam{ MakeTypeTraits<bool>() }, // Return value
+		std::vector<MetaFuncNamedParam>{ { MakeTypeTraits<const World&>() }, { MakeTypeTraits<const entt::entity&>() } }
+	).GetProperties().Add(Props::sIsScriptableTag);
+	
 
 	entityType.AddFunc(
 		[typeId = type.GetTypeId()](MetaFunc::DynamicArgs args, MetaFunc::RVOBuffer) -> FuncResult
 		{
-			World* world = World::TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr && "Reached a scripting context without pushing a world");
+			World& world = *static_cast<World*>(args[0].GetData());
+			const entt::entity entity = *static_cast<entt::entity*>(args[1].GetData());
 
-			const entt::entity entity = *static_cast<entt::entity*>(args[0].GetData());
-			world->GetRegistry().RemoveComponentIfEntityHasIt(typeId, entity);
+			world.GetRegistry().RemoveComponentIfEntityHasIt(typeId, entity);
 			return std::nullopt;
 		},
 		GetRemoveComponentFuncName(type.GetName()),
 		MetaFuncNamedParam{ MakeTypeTraits<void>() }, // Return value
-		std::vector<MetaFuncNamedParam>{ { MakeTypeTraits<const entt::entity&>() } }
+		std::vector<MetaFuncNamedParam>{ { MakeTypeTraits<World&>() }, { MakeTypeTraits<const entt::entity&>() } }
 	).GetProperties().Add(Props::sIsScriptableTag);
 }
 
diff --git a/Source/World/Physics.cpp b/Source/World/Physics.cpp
index b1682160..3aa49c8a 100644
--- a/Source/World/Physics.cpp
+++ b/Source/World/Physics.cpp
@@ -150,15 +150,15 @@ CE::MetaType CE::Physics::Reflect()
 	MetaType type = MetaType{ MetaType::T<Physics>{}, "Physics" };
 	type.GetProperties().Add(Props::sIsScriptableTag);
 
-	type.AddFunc([](glm::vec2 centre, float radius, const CollisionRules& filter)
+	type.AddFunc([](const World& world, glm::vec2 centre, float radius, const CollisionRules& filter)
 		{
-			return World::TryGetWorldAtTopOfStack()->GetPhysics().FindAllWithinShape(TransformedDisk{ centre, radius }, filter);
-		}, "Find all bodies in radius", MetaFunc::ExplicitParams<glm::vec2, float, const CollisionRules&>{}, "Centre", "Radius", "Filter").GetProperties().Add(Props::sIsScriptableTag);
+			return world.GetPhysics().FindAllWithinShape(TransformedDisk{ centre, radius }, filter);
+		}, "Find all bodies in radius", MetaFunc::ExplicitParams<const World&, glm::vec2, float, const CollisionRules&>{}, "Centre", "Radius", "Filter").GetProperties().Add(Props::sIsScriptableTag);
 
-	type.AddFunc([](glm::vec2 min, glm::vec2 max, const CollisionRules& filter)
+	type.AddFunc([](const World& world, glm::vec2 min, glm::vec2 max, const CollisionRules& filter)
 		{
-			return World::TryGetWorldAtTopOfStack()->GetPhysics().FindAllWithinShape(TransformedAABB{ min, max }, filter);
-		}, "Find all bodies in box", MetaFunc::ExplicitParams<glm::vec2, glm::vec2, const CollisionRules&>{}, "Min", "Max", "Filter").GetProperties().Add(Props::sIsScriptableTag);
+			return world.GetPhysics().FindAllWithinShape(TransformedAABB{ min, max }, filter);
+		}, "Find all bodies in box", MetaFunc::ExplicitParams<const World&, glm::vec2, glm::vec2, const CollisionRules&>{}, "Min", "Max", "Filter").GetProperties().Add(Props::sIsScriptableTag);
 
 	return type;
 }
diff --git a/Source/World/Registry.cpp b/Source/World/Registry.cpp
index eee82b93..b080c1d7 100644
--- a/Source/World/Registry.cpp
+++ b/Source/World/Registry.cpp
@@ -36,6 +36,8 @@ namespace CE::Internal
 		const MetaType& GetType() const { return mType; }
 		const MetaFunc* GetOnConstruct() const { return mOnConstruct; }
 		const MetaFunc* GetOnBeginPlay() const { return mOnBeginPlay; }
+		uintptr GetOffsetToOwner() const { return mOffsetToOwnerField; }
+		uintptr GetOffsetToWorld() const { return mOffsetToWorldField; }
 
 		const void* get_at(std::size_t pos) const override;
 
@@ -69,6 +71,12 @@ namespace CE::Internal
 		const MetaFunc* mOnConstruct{};
 		const MetaFunc* mOnBeginPlay{};
 
+		// Each script has these hardcoded fields.
+		// We initialize them manually when constructing
+		// a component.
+		uintptr mOffsetToWorldField{};
+		uintptr mOffsetToOwnerField{};
+
 		char* mData{};
 		size_t mCapacity{};
 		entt::type_info mTypeInfo;
@@ -296,8 +304,6 @@ void CE::Registry::Destroy(entt::entity entity, bool destroyChildren)
 
 void CE::Registry::RemovedDestroyed()
 {
-	World::PushWorld(mWorld);
-
 	while (true)
 	{
 		{
@@ -368,8 +374,6 @@ void CE::Registry::RemovedDestroyed()
 			mRegistry.destroy(entity);
 		}
 	}
-
-	World::PopWorld();
 }
 
 CE::MetaAny CE::Registry::AddComponent(const MetaType& componentClass, const entt::entity toEntity)
@@ -400,21 +404,13 @@ CE::MetaAny CE::Registry::AddComponent(const MetaType& componentClass, const ent
 
 		MetaAny componentToReturn = asAnyStorage->element_at(it.index());
 
-		const MetaField* const ownerMember = componentClass.TryGetField(Script::sNameOfOwnerField);
+		// Initialize our hard coded fields
+		std::byte* componentAddress = static_cast<std::byte*>(componentToReturn.GetData());
+		entt::entity* ownerAddress = reinterpret_cast<entt::entity*>(componentAddress + asAnyStorage->GetOffsetToOwner());
+		World** worldAddress = reinterpret_cast<World**>(componentAddress + asAnyStorage->GetOffsetToWorld());
 
-		if (ownerMember != nullptr)
-		{
-			if (ownerMember->GetType().GetTypeId() == MakeTypeId<entt::entity>())
-			{
-				MetaAny refToMember = ownerMember->MakeRef(componentToReturn);
-				*refToMember.As<entt::entity>() = toEntity;
-			}
-			else
-			{
-				LOG(LogScripting, Error, "Expected {}::Owner to be of type entt::entity",
-					componentClass.GetName());
-			}
-		}
+		*ownerAddress = toEntity;
+		*worldAddress = &mWorld.get();
 
 		// Call events
 		const MetaFunc* const onConstruct = asAnyStorage->GetOnConstruct();
@@ -448,11 +444,7 @@ CE::MetaAny CE::Registry::AddComponent(const MetaType& componentClass, const ent
 		return MetaAny{ componentClass.GetTypeInfo(), nullptr };
 	}
 
-	World::PushWorld(mWorld);
-
-	FuncResult result = addComponentFunc->InvokeUncheckedUnpacked(toEntity);
-
-	World::PopWorld();
+	FuncResult result = addComponentFunc->InvokeUncheckedUnpacked(GetWorld(), toEntity);
 
 	if (result.HasError())
 	{
@@ -473,7 +465,6 @@ CE::MetaAny CE::Registry::AddComponent(const MetaType& componentClass, const ent
 
 void CE::Registry::RemoveComponent(const TypeId componentClassTypeId, const entt::entity fromEntity)
 {
-	World::PushWorld(mWorld);
 	entt::sparse_set* storage = Storage(componentClassTypeId);
 	ASSERT(storage != nullptr);
 	ASSERT(storage->contains(fromEntity));
@@ -494,7 +485,6 @@ void CE::Registry::RemoveComponent(const TypeId componentClassTypeId, const entt
 	}
 
 	storage->erase(fromEntity);
-	World::PopWorld();
 }
 
 void CE::Registry::RemoveComponentIfEntityHasIt(const TypeId componentClassTypeId, const entt::entity fromEntity)
@@ -506,13 +496,10 @@ void CE::Registry::RemoveComponentIfEntityHasIt(const TypeId componentClassTypeI
 		return;
 	}
 
-	World::PushWorld(mWorld);
-
 	if (mWorld.get().HasBegunPlay())
 	{
 		if (!storage->contains(fromEntity))
 		{
-			World::PopWorld();
 			return;
 		}
 
@@ -530,7 +517,6 @@ void CE::Registry::RemoveComponentIfEntityHasIt(const TypeId componentClassTypeI
 	}
 
 	storage->remove(fromEntity);
-	World::PopWorld();
 }
 
 std::vector<CE::MetaAny> CE::Registry::GetComponents(entt::entity entity)
@@ -577,8 +563,6 @@ bool CE::Registry::HasComponent(TypeId componentClassTypeId, entt::entity entity
 
 void CE::Registry::Clear()
 {
-	World::PushWorld(mWorld);
-
 	for (const entt::entity entity : mRegistry.storage<entt::entity>())
 	{
 		if (!HasComponent<IsDestroyedTag>(entity))
@@ -587,7 +571,6 @@ void CE::Registry::Clear()
 		}
 	}
 	RemovedDestroyed();
-	World::PopWorld();
 }
 
 std::vector<CE::Registry::SingleTick> CE::Registry::GetSortedSystemsToUpdate(const float dt)
@@ -713,8 +696,6 @@ void CE::Registry::CallBeginPlayForEntitiesAwaitingBeginPlay()
 		return;
 	}
 
-	World::PushWorld(mWorld);
-
 	for (const BoundEvent& boundEvent : mWorld.get().GetEventManager().GetBoundEvents(sOnBeginPlay))
 	{
 		entt::sparse_set* storage = Storage(boundEvent.mType.get().GetTypeId());
@@ -743,8 +724,6 @@ void CE::Registry::CallBeginPlayForEntitiesAwaitingBeginPlay()
 			}
 		}
 	}
-
-	World::PopWorld();
 }
 
 bool CE::Registry::ShouldWeCallBeginPlayImmediatelyAfterConstruct(entt::entity ownerOfNewlyConstructedComponent) const
@@ -773,6 +752,9 @@ CE::Internal::AnyStorage::AnyStorage(const MetaType& type) :
 	mType(type),
 	mTypeInfo(type.GetTypeId(), type.GetTypeInfo(), type.GetName())
 {
+	ASSERT(CanTypeBeUsed(type));
+	reserve(64);
+
 	if (const std::optional<BoundEvent> boundEvent = TryGetEvent(type, sOnConstruct))
 	{
 		mOnConstruct = &boundEvent->mFunc.get();
@@ -783,8 +765,12 @@ CE::Internal::AnyStorage::AnyStorage(const MetaType& type) :
 		mOnBeginPlay = &boundEvent->mFunc.get();
 	}
 
-	ASSERT(CanTypeBeUsed(type));
-	reserve(64);
+	const MetaField* ownerField = type.TryGetField(Script::sNameOfOwnerField);
+	const MetaField* worldField = type.TryGetField(Script::sNameOfWorldField);
+	ASSERT_LOG(ownerField != nullptr && worldField != nullptr, "Expected hardcoded fields in script type {}", type.GetName());
+
+	mOffsetToOwnerField = ownerField->GetOffset();
+	mOffsetToWorldField = worldField->GetOffset();
 }
 
 CE::Internal::AnyStorage::~AnyStorage()
diff --git a/Source/World/World.cpp b/Source/World/World.cpp
index fdc159c5..23fa78b9 100644
--- a/Source/World/World.cpp
+++ b/Source/World/World.cpp
@@ -31,70 +31,37 @@ CE::World::World(const bool beginPlayImmediately) :
 	}
 }
 
-CE::World::World(World&& other) noexcept :
-	mTime(other.mTime),
-	mHasBegunPlay(other.mHasBegunPlay),
-	mRegistry(std::move(other.mRegistry)),
-	mViewport(std::move(other.mViewport)),
-	mPhysics(std::move(other.mPhysics)),
-	mEventManager(std::move(other.mEventManager)),
-	mRenderCommandQueue(std::move(other.mRenderCommandQueue)),
-	mLevelToTransitionTo(std::move(other.mLevelToTransitionTo))
-{
-	mRegistry->mWorld = *this;
-	mViewport->mWorld = *this;
-	mPhysics->mWorld = *this;
-	mEventManager->mWorld = *this;
-}
-
 CE::World::~World()
 {
-	// Mightve been moved out
-	if (mRegistry != nullptr)
-	{
-		mRegistry->Clear();
-		mRegistry.reset();
-		mViewport.reset();
-	}
-}
-
-CE::World& CE::World::operator=(World&& other) noexcept
-{
-	if (&other == this)
-	{
-		return *this;
-	}
-
-	mRegistry = std::move(other.mRegistry);
-	mViewport = std::move(other.mViewport);
-	mRenderCommandQueue = std::move(other.mRenderCommandQueue);
-	mPhysics = std::move(other.mPhysics);
-	mLevelToTransitionTo = std::move(other.mLevelToTransitionTo);
-
-	mRegistry->mWorld = *this;
-	mViewport->mWorld = *this;
-	mPhysics->mWorld = *this;
-	mTime = other.mTime;
-	mHasBegunPlay = other.mHasBegunPlay;
-
-	return *this;
+	mRegistry->Clear();
+	mRegistry.reset();
+	mViewport.reset();
 }
 
 void CE::World::Tick(const float unscaledDeltaTime)
 {
-	PushWorld(*this);
-
 	mTime.Step(unscaledDeltaTime);
 
 	GetRegistry().UpdateSystems(unscaledDeltaTime);
 	GetRegistry().RemovedDestroyed();
 
-	if (GetNextLevel() != nullptr)
+	const AssetHandle<Level> nextLevel = GetNextLevel();
+
+	if (nextLevel != nullptr)
 	{
-		*this = GetNextLevel()->CreateWorld(true);
-	}
+		const bool hasBegunPlay = mHasBegunPlay;
 
-	PopWorld();
+		World& self = *this;
+		self.~World();
+		new (this)World(false);
+
+		nextLevel->LoadIntoWorld(self);
+
+		if (hasBegunPlay)
+		{
+			BeginPlay();
+		}
+	}
 }
 
 void CE::World::Render(FrameBuffer* renderTarget)
@@ -263,26 +230,6 @@ const CE::AssetHandle<CE::Level>& CE::World::GetNextLevel() const
 	return mLevelToTransitionTo;
 }
 
-// Each thread has their own worldstack. This allows multiple worlds to run in parallel.
-// While helpful for multi-threaded importing, this makes it difficult to do multi-threading
-// of a workload in the same world. This decision may have to be revised..
-static thread_local std::stack<std::reference_wrapper<CE::World>> sWorldStacks{};
-
-void CE::World::PushWorld(World& world)
-{
-	sWorldStacks.emplace(world);
-}
-
-void CE::World::PopWorld()
-{
-	sWorldStacks.pop();
-}
-
-CE::World* CE::World::TryGetWorldAtTopOfStack()
-{
-	return sWorldStacks.empty() ? nullptr : &sWorldStacks.top().get();
-}
-
 void CE::World::TransitionToLevel(const AssetHandle<Level>& level)
 {
 	if (GetNextLevel() == nullptr)
@@ -323,99 +270,73 @@ CE::MetaType CE::World::Reflect()
 	MetaType type = MetaType{ MetaType::T<World>{}, "World" };
 	type.GetProperties().Add(Props::sIsScriptableTag);
 
-	type.AddFunc([]
+	type.AddFunc([](const World& world)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			return world->HasBegunPlay();
-		}, "HasBegunPlay").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
+			return world.HasBegunPlay();
+		}, "HasBegunPlay", MetaFunc::ExplicitParams<const World&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
 
-	type.AddFunc([]
+	type.AddFunc([](const World& world)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			return world->GetCurrentTimeScaled();
-		}, "GetCurrentTimeScaled").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
+			return world.GetCurrentTimeScaled();
+		}, "GetCurrentTimeScaled", MetaFunc::ExplicitParams<const World&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
 
-	type.AddFunc([]
+	type.AddFunc([](const World& world)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			return world->GetCurrentTimeReal();
-		}, "GetCurrentTimeReal").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
+			return world.GetCurrentTimeReal();
+		}, "GetCurrentTimeReal", MetaFunc::ExplicitParams<const World&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
 
-	type.AddFunc([]
+	type.AddFunc([](const World& world)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			return world->GetTimeScale(); }, "GetTimeScale").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
+			return world.GetTimeScale();
+		}, "GetTimeScale", MetaFunc::ExplicitParams<const World&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
 
-	type.AddFunc([](float timescale)
+	type.AddFunc([](World& world, float timescale)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			world->SetTimeScale(timescale);
-		}, "SetTimeScale", MetaFunc::ExplicitParams<float>{}, "TimeScale").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
+			world.SetTimeScale(timescale);
+		}, "SetTimeScale", MetaFunc::ExplicitParams<World&, float>{}, "TimeScale").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
 
-	type.AddFunc([]
+	type.AddFunc([](const World& world)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			return world->IsPaused();
-		}, "IsPaused").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
+			return world.IsPaused();
+		}, "IsPaused", MetaFunc::ExplicitParams<const World&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
 
-	type.AddFunc([]
+	type.AddFunc([](World& world)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			world->Pause();
-		}, "Pause").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
+			world.Pause();
+		}, "Pause", MetaFunc::ExplicitParams<World&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
 
-	type.AddFunc([]
+	type.AddFunc([](World& world)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			world->Unpause();
-		}, "Unpause").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
+			world.Unpause();
+		}, "Unpause", MetaFunc::ExplicitParams<World&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
 
-	type.AddFunc([](bool isPaused)
+	type.AddFunc([](World& world, bool isPaused)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			world->SetIsPaused(isPaused);
-		}, "SetIsPaused", MetaFunc::ExplicitParams<bool>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
+			world.SetIsPaused(isPaused);
+		}, "SetIsPaused", MetaFunc::ExplicitParams<World&, bool>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
 
-	type.AddFunc([]
+	type.AddFunc([](const World& world)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			return world->HasBegunPlay();
-		}, "HasBegunPlay").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
+			return world.HasBegunPlay();
+		}, "HasBegunPlay", MetaFunc::ExplicitParams<const World&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
 
-	type.AddFunc([]
+	type.AddFunc([](World& world)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			world->RequestEndplay();
-		}, "RequestEndPlay").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
+			world.RequestEndplay();
+		}, "RequestEndPlay", MetaFunc::ExplicitParams<World&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
 
-	type.AddFunc([](const AssetHandle<Level>& level)
+	type.AddFunc([](World& world, const AssetHandle<Level>& level)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			world->TransitionToLevel(level);
+			world.TransitionToLevel(level);
 		},
 		"TransitionToLevel", 
-		MetaFunc::ExplicitParams<const AssetHandle<Level>&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
+		MetaFunc::ExplicitParams<World&, const AssetHandle<Level>&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
 
-	type.AddFunc([]
+	type.AddFunc([](const World& world)
 		{
-			const World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-
 			std::vector<entt::entity> returnValue{};
 
-			const auto entityStorage = world->GetRegistry().Storage<entt::entity>();
+			const auto entityStorage = world.GetRegistry().Storage<entt::entity>();
 
 			if (entityStorage == nullptr)
 			{
@@ -430,35 +351,29 @@ CE::MetaType CE::World::Reflect()
 			}
 
 			return returnValue;
-		}, "Get all entities").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
+		}, "Get all entities", MetaFunc::ExplicitParams<const World&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
 
-	type.AddFunc([]
+	type.AddFunc([](World& world)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			world->GetRegistry().Clear();
-		}, "Clear").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
+			world.GetRegistry().Clear();
+		}, "Clear", MetaFunc::ExplicitParams<World&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
 
-	type.AddFunc([]
+	type.AddFunc([](World& world)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			return world->GetRegistry().Create();
-		}, "Spawn entity").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
+			return world.GetRegistry().Create();
+		}, "Spawn entity", MetaFunc::ExplicitParams<World&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
 
-	type.AddFunc([](const AssetHandle<Prefab>& prefab)
+	type.AddFunc([](World& world, const AssetHandle<Prefab>& prefab)
 		{
 			if (prefab == nullptr)
 			{
 				LOG(LogWorld, Warning, "Attempted to spawn NULL prefab.");
 			}
 
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			return world->GetRegistry().CreateFromPrefab(*prefab);
-		}, "Spawn prefab", MetaFunc::ExplicitParams<const AssetHandle<Prefab>&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
+			return world.GetRegistry().CreateFromPrefab(*prefab);
+		}, "Spawn prefab", MetaFunc::ExplicitParams<World&, const AssetHandle<Prefab>&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
 
-	type.AddFunc([](const AssetHandle<Prefab>& prefab, const glm::vec3 position, const glm::quat orientation, const glm::vec3 scale, TransformComponent* parent) -> entt::entity
+	type.AddFunc([](World& world, const AssetHandle<Prefab>& prefab, const glm::vec3 position, const glm::quat orientation, const glm::vec3 scale, TransformComponent* parent) -> entt::entity
 		{
 			if (prefab == nullptr)
 			{
@@ -471,25 +386,18 @@ CE::MetaType CE::World::Reflect()
 				LOG(LogWorld, Warning, "Spawning prefab {} with a scale of (0, 0, 0), may not be intended.", prefab.GetMetaData().GetName());
 			}
 
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			return world->GetRegistry().CreateFromPrefab(*prefab, entt::null, &position, &orientation, &scale, parent);
-		}, "Spawn prefab at", MetaFunc::ExplicitParams<const AssetHandle<Prefab>&, glm::vec3, glm::quat, glm::vec3, TransformComponent*>{},
+			return world.GetRegistry().CreateFromPrefab(*prefab, entt::null, &position, &orientation, &scale, parent);
+		}, "Spawn prefab at", MetaFunc::ExplicitParams<World&, const AssetHandle<Prefab>&, glm::vec3, glm::quat, glm::vec3, TransformComponent*>{},
 			"Prefab", "LocalPosition", "LocalOrientation", "LocalScale", "Parent").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
 
-	type.AddFunc([](const entt::entity& entity, bool destroyChildren)
+	type.AddFunc([](World& world, const entt::entity& entity, bool destroyChildren)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			world->GetRegistry().Destroy(entity, destroyChildren);
-		}, "Destroy entity", MetaFunc::ExplicitParams<const entt::entity&, bool>{}, "Entity", "DestroyChildren").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
+			world.GetRegistry().Destroy(entity, destroyChildren);
+		}, "Destroy entity", MetaFunc::ExplicitParams<World&, const entt::entity&, bool>{}, "Entity", "DestroyChildren").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
 
-	type.AddFunc([](const std::string& name) -> entt::entity
+	type.AddFunc([](const World& world, const std::string& name) -> entt::entity
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-
-			const auto view = world->GetRegistry().View<const NameComponent>();
+			const auto view = world.GetRegistry().View<const NameComponent>();
 
 			for (auto [entity, nameComponent] : view.each())
 			{
@@ -500,15 +408,12 @@ CE::MetaType CE::World::Reflect()
 			}
 
 			return entt::null;
-		}, "Find entity with name", MetaFunc::ExplicitParams<const std::string&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
+		}, "Find entity with name", MetaFunc::ExplicitParams<const World&, const std::string&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
 
-	type.AddFunc([](const std::string& name)
+	type.AddFunc([](const World& world, const std::string& name)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-
 			std::vector<entt::entity> returnValue{};
-			const auto view = world->GetRegistry().View<const NameComponent>();
+			const auto view = world.GetRegistry().View<const NameComponent>();
 
 			for (auto [entity, nameComponent] : view.each())
 			{
@@ -519,91 +424,71 @@ CE::MetaType CE::World::Reflect()
 			}
 
 			return returnValue;
-		}, "Find all entities with name", MetaFunc::ExplicitParams<const std::string&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
+		}, "Find all entities with name", MetaFunc::ExplicitParams<const World&, const std::string&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
 
-	type.AddFunc([](const ComponentFilter& component) -> entt::entity
+	type.AddFunc([](const World& world, const ComponentFilter& component) -> entt::entity
 		{
-			const World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-
-			const entt::runtime_view view = FindAllEntitiesWithComponents(*world, { &component, 1 });
+			const entt::runtime_view view = FindAllEntitiesWithComponents(world, { &component, 1 });
 
 			if (view.begin() == view.end())
 			{
 				return entt::null;
 			}
 			return *view.begin();
-		}, "Find entity with component", MetaFunc::ExplicitParams<const ComponentFilter&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
+		}, "Find entity with component", MetaFunc::ExplicitParams<const World&, const ComponentFilter&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
 
-	type.AddFunc([](const ComponentFilter& component)
+	type.AddFunc([](const World& world, const ComponentFilter& component)
 		{
-			const World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-
-			const entt::runtime_view view = FindAllEntitiesWithComponents(*world, { &component, 1 });
+			const entt::runtime_view view = FindAllEntitiesWithComponents(world, { &component, 1 });
 
 			std::vector<entt::entity> returnValue{};
 			returnValue.reserve(view.size_hint());
 			returnValue.insert(returnValue.end(), view.begin(), view.end());
 
 			return returnValue;
-		}, "Find all entities with component", MetaFunc::ExplicitParams<const ComponentFilter&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
+		}, "Find all entities with component", MetaFunc::ExplicitParams<const World&, const ComponentFilter&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
 
-	type.AddFunc([](const std::vector<ComponentFilter>& components) -> entt::entity
+	type.AddFunc([](const World& world, const std::vector<ComponentFilter>& components) -> entt::entity
 		{
-			const World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-
-			const entt::runtime_view view = FindAllEntitiesWithComponents(*world, components);
+			const entt::runtime_view view = FindAllEntitiesWithComponents(world, components);
 
 			if (view.begin() == view.end())
 			{
 				return entt::null;
 			}
 			return *view.begin();
-		}, "Find entity with components", MetaFunc::ExplicitParams<const std::vector<ComponentFilter>&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
+		}, "Find entity with components", MetaFunc::ExplicitParams<const World&, const std::vector<ComponentFilter>&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
 
-	type.AddFunc([](const std::vector<ComponentFilter>& components)
+	type.AddFunc([](const World& world, const std::vector<ComponentFilter>& components)
 		{
-			const World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-
-			const entt::runtime_view view = FindAllEntitiesWithComponents(*world, components);
+			const entt::runtime_view view = FindAllEntitiesWithComponents(world, components);
 
 			std::vector<entt::entity> returnValue{};
 			returnValue.reserve(view.size_hint());
 			returnValue.insert(returnValue.end(), view.begin(), view.end());
 
 			return returnValue;
-		}, "Find all entities with components", MetaFunc::ExplicitParams<const std::vector<ComponentFilter>&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
+		}, "Find all entities with components", MetaFunc::ExplicitParams<const World&, const std::vector<ComponentFilter>&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, false);
 
-	type.AddFunc([](glm::vec2 screenPosition, float distanceFromCamera)
+	type.AddFunc([](const World& world, glm::vec2 screenPosition, float distanceFromCamera)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			return world->GetViewport().ScreenToWorld(screenPosition, distanceFromCamera);
-		}, "ScreenToWorld", MetaFunc::ExplicitParams<glm::vec2, float>{}, "Screen position", "Distance from camera").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
+			return world.GetViewport().ScreenToWorld(screenPosition, distanceFromCamera);
+		}, "ScreenToWorld", MetaFunc::ExplicitParams<const World&, glm::vec2, float>{}, "Screen position", "Distance from camera").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
 
-	type.AddFunc([](glm::vec2 screenPosition, float planeHeight)
+	type.AddFunc([](const World& world, glm::vec2 screenPosition, float planeHeight)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			return world->GetViewport().ScreenToWorldPlane(screenPosition, planeHeight);
-		}, "ScreenToWorldPlane", MetaFunc::ExplicitParams<glm::vec2, float>{}, "Screen position", "Plane height").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
+			return world.GetViewport().ScreenToWorldPlane(screenPosition, planeHeight);
+		}, "ScreenToWorldPlane", MetaFunc::ExplicitParams<const World&, glm::vec2, float>{}, "Screen position", "Plane height").GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
 
-	type.AddFunc([]()
+	type.AddFunc([](const World& world)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			return world->GetScaledDeltaTime();
-		}, "GetScaledDeltaTime", MetaFunc::ExplicitParams<>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
+			return world.GetScaledDeltaTime();
+		}, "GetScaledDeltaTime", MetaFunc::ExplicitParams<const World&>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
 
-	type.AddFunc([]()
+	type.AddFunc([](const World& world)
 		{
-			World* world = TryGetWorldAtTopOfStack();
-			ASSERT(world != nullptr);
-			return world->GetRealDeltaTime();
-		}, "GetRealDeltaTime", MetaFunc::ExplicitParams<>{}).GetProperties().Add(Props::sIsScriptableTag).Set(Props::sIsScriptPure, true);
+			return world.GetRealDeltaTime();
+		}, "GetRealDeltaTime", MetaFunc::ExplicitParams<const World&>{}).GetProperties().Add(Props::sIsScriptableTag);
 
 	return type;
 }