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/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/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..d1a01afe 100644
--- a/Source/Core/Engine.cpp
+++ b/Source/Core/Engine.cpp
@@ -163,7 +163,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 +206,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/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/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/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/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;
 }