@@ -90,6 +90,7 @@ Gothic::Gothic() {
   defaults->set("GAME", "useGothic1Controls",  1);
   defaults->set("GAME", "highlightMeleeFocus", 0);
   defaults->set("GAME", "useQuickSaveKeys",    1);
+  defaults->set("ENGINE", "worldCacheMiB",    512);
 
   defaults->set("GAME", "animatedWindows",     1);
   defaults->set("GAME", "subTitles",           1);
 
@@ -554,8 +554,20 @@ struct DynamicWorld::BBoxList final {
   DynamicWorld&          wrld;
   };
 
-DynamicWorld::DynamicWorld(World* owner, const zenkit::Mesh& worldMesh) {
-  world.reset(new CollisionWorld());
+struct DynamicWorld::Landscape {
+  std::vector<std::string> sectors;
+  std::vector<btVector3> landVbo;
+  std::unique_ptr<PhysicVbo> landMesh, waterMesh;
+  std::unique_ptr<btCollisionShape> landShape, waterShape;
+  size_t bytes = 0;
+  };
+
+std::shared_ptr<const DynamicWorld::Landscape> DynamicWorld::buildLandscape(const zenkit::Mesh& worldMesh) {
+  auto result = std::make_shared<Landscape>();
+  auto& sectors = result->sectors;
+  auto& landVbo = result->landVbo;
+  auto& landMesh = result->landMesh;
+  auto& waterMesh = result->waterMesh;
 
   {
   PackedMesh pkg(worldMesh,PackedMesh::PK_Physic);
@@ -584,12 +596,38 @@ DynamicWorld::DynamicWorld(World* owner, const zenkit::Mesh& worldMesh) {
     }
   }
 
+  result->bytes = sizeof(Landscape) + landVbo.capacity()*sizeof(btVector3) + landMesh->byteSize() + waterMesh->byteSize();
+  result->bytes += sectors.capacity()*sizeof(std::string);
+  for(const auto& sector:sectors)
+    result->bytes += sector.capacity();
+  auto shape = [&](PhysicVbo& mesh) -> std::unique_ptr<btCollisionShape> {
+    if(mesh.isEmpty())
+      return nullptr;
+    auto value = std::make_unique<btMultimaterialTriangleMeshShape>(&mesh,mesh.useQuantization(),true);
+    result->bytes += sizeof(*value) + value->getOptimizedBvh()->calculateSerializeBufferSize();
+    return value;
+    };
+  result->landShape = shape(*landMesh);
+  result->waterShape = shape(*waterMesh);
+  return result;
+  }
+
+size_t DynamicWorld::landscapeBytes(const Landscape& landscape) {
+  return landscape.bytes;
+  }
+
+DynamicWorld::DynamicWorld(World* owner, const zenkit::Mesh& mesh)
+  :DynamicWorld(owner,buildLandscape(mesh)) {
+  }
+
+DynamicWorld::DynamicWorld(World* owner, std::shared_ptr<const Landscape> data) : landscape(std::move(data)) {
+  world.reset(new CollisionWorld());
+
   btVector3 bbox[2] = {btVector3(0,0,0), btVector3(0,0,0)};
-  if(!landMesh->isEmpty()) {
+  if(landscape->landShape) {
     Tempest::Matrix4x4 mt;
     mt.identity();
-    landShape.reset(new btMultimaterialTriangleMeshShape(landMesh.get(),landMesh->useQuantization(),true));
-    landBody = world->addCollisionBody(*landShape,mt,DynamicWorld::materialFriction(zenkit::MaterialGroup::NONE));
+    landBody = world->addCollisionBody(*landscape->landShape,mt,DynamicWorld::materialFriction(zenkit::MaterialGroup::NONE));
     landBody->setUserIndex(C_Landscape);
 
     btVector3 b[2] = {btVector3(0,0,0), btVector3(0,0,0)};
@@ -598,11 +636,10 @@ DynamicWorld::DynamicWorld(World* owner, const zenkit::Mesh& worldMesh) {
     bbox[1].setMax(b[1]);
     }
 
-  if(!waterMesh->isEmpty()) {
+  if(landscape->waterShape) {
     Tempest::Matrix4x4 mt;
     mt.identity();
-    waterShape.reset(new btMultimaterialTriangleMeshShape(waterMesh.get(),waterMesh->useQuantization(),true));
-    waterBody = world->addCollisionBody(*waterShape,mt,0);
+    waterBody = world->addCollisionBody(*landscape->waterShape,mt,0);
     waterBody->setUserIndex(C_Water);
     waterBody->setCollisionFlags(btCollisionObject::CF_STATIC_OBJECT | btCollisionObject::CF_NO_CONTACT_RESPONSE);
     // waterBody->setCollisionFlags(btCollisionObject::CO_HF_FLUID);
@@ -1120,7 +1157,7 @@ float DynamicWorld::rayBox(const Tempest::Vec3& orig, const Tempest::Vec3& dir,
   }
 
 std::string_view DynamicWorld::validateSectorName(std::string_view name) const {
-  return landMesh->validateSectorName(name);
+  return landscape->landMesh->validateSectorName(name);
   }
 
 bool DynamicWorld::hasCollision(const NpcItem& it, CollisionTest& out) {
 
@@ -41,7 +41,11 @@ class DynamicWorld final {
     static constexpr float bulletSpeed = 3; // centimeters per milliseconds
     static constexpr float spellSpeed  = 1; // centimeters per milliseconds
 
+    struct Landscape;
+    static std::shared_ptr<const Landscape> buildLandscape(const zenkit::Mesh& mesh);
+    static size_t landscapeBytes(const Landscape& landscape);
     DynamicWorld(World *world, const zenkit::Mesh& mesh);
+    DynamicWorld(World *world, std::shared_ptr<const Landscape> landscape);
     DynamicWorld(const DynamicWorld&)=delete;
     ~DynamicWorld();
 
@@ -304,16 +308,9 @@ class DynamicWorld final {
 
     std::unique_ptr<CollisionWorld>    world;
 
-    std::vector<std::string>           sectors;
-
-    std::vector<btVector3>             landVbo;
-    std::unique_ptr<PhysicVbo>         landMesh;
-    std::unique_ptr<btCollisionShape>  landShape;
+    std::shared_ptr<const Landscape>  landscape;
     std::unique_ptr<btRigidBody>       landBody;
-
-    std::unique_ptr<btCollisionShape>  waterShape;
     std::unique_ptr<btRigidBody>       waterBody;
-    std::unique_ptr<PhysicVbo>         waterMesh;
 
     std::unique_ptr<NpcBodyList>       npcList;
     std::unique_ptr<BulletsList>       bulletList;
 
@@ -98,6 +98,11 @@ bool PhysicVbo::isEmpty() const {
   return segments.size()==0;
   }
 
+size_t PhysicVbo::byteSize() const {
+  return sizeof(*this) + vStorage.capacity()*sizeof(btVector3) + id.capacity()*sizeof(uint32_t) +
+         segments.capacity()*sizeof(Segment) + size_t(m_indexedMeshes.capacity())*sizeof(btIndexedMesh);
+  }
+
 void PhysicVbo::adjustMesh(){
   for(int i=0;i<m_indexedMeshes.size();++i) {
     btIndexedMesh& meshIndex=m_indexedMeshes[i];
 
@@ -26,6 +26,7 @@ class PhysicVbo : public btTriangleIndexVertexArray {
     auto                    sectorName(size_t segment) const -> const char*;
     bool                    useQuantization() const;
     bool                    isEmpty() const;
+    size_t                  byteSize() const;
 
     void                    adjustMesh();
 
 
@@ -27,6 +27,11 @@
 #include "graphics/mesh/animation.h"
 #include "graphics/mesh/attachbinder.h"
 #include "graphics/material.h"
+#include "graphics/shaders.h"
+#include "utils/workers.h"
+#include "world/worlddata.h"
+#include <future>
+#include <stdexcept>
 #include "dmusic/directmusic.h"
 #include "utils/fileext.h"
 #include "utils/gthfont.h"
@@ -122,11 +127,15 @@ Resources::Resources(Tempest::Device &device)
   }
 
 void Resources::mountWork(const std::filesystem::path& path) {
+  std::lock_guard<std::mutex> guard(inst->syncWorld);
+  inst->worldCache.reset();
   inst->gothicAssets.mkdir("/_work");
   inst->gothicAssets.mount_host(path, "/_work", zenkit::VfsOverwriteBehavior::NONE);
   }
 
 void Resources::loadVdfs(const std::vector<std::u16string>& modvdfs, bool modFilter) {
+  std::lock_guard<std::mutex> guard(inst->syncWorld);
+  inst->worldCache.reset();
   std::vector<Archive> archives;
   inst->detectVdf(archives,Gothic::nestedPath({u"Data"},Dir::FT_Dir));
 
@@ -310,6 +319,69 @@ const zenkit::Vfs& Resources::vdfsIndex() {
   return inst->gothicAssets;
   }
 
+std::shared_ptr<const WorldData> Resources::loadWorld(std::string_view name, zenkit::GameVersion version) {
+  std::lock_guard<std::mutex> guard(inst->syncWorld);
+  const auto* source = vdfsIndex().find(name);
+  if(source==nullptr)
+    throw std::runtime_error("unable to open Zen-file: " + std::string(name));
+  const auto budget = size_t(std::clamp(Gothic::settingsGetI("ENGINE", "worldCacheMiB"),0,1024))*1024*1024;
+  const bool softwareRayTracing = Shaders::options().doSoftwareRT;
+  auto& cache = inst->worldCache;
+  if(cache && cache->source==source && cache->version==version &&
+     cache->softwareRayTracing==softwareRayTracing && cache->cacheBytes<=budget) {
+    return cache;
+    }
+  // Only one level is retained. Release it before preparing a different level.
+  cache.reset();
+  auto data = std::make_shared<WorldData>();
+  data->source = source;
+  data->version = version;
+  data->softwareRayTracing = softwareRayTracing;
+  auto input = source->open_read();
+  data->world.load(input.get(),version);
+
+  auto physics = std::async(std::launch::async, [&] {
+    Workers::setThreadName("Loading: BVH thread");
+    return DynamicWorld::buildLandscape(data->world.world_mesh);
+    });
+  data->visual = std::make_unique<PackedMesh>(data->world.world_mesh,PackedMesh::PK_VisualLnd);
+  data->landscape = physics.get();
+  // Discard the raw mesh after both prepared representations are ready.
+  data->world.world_mesh = zenkit::Mesh();
+  auto& mesh = *data->visual;
+  auto bytes = [](const auto& values) { return values.capacity()*sizeof(values[0]); };
+  auto& bsp = data->world.world_bsp_tree;
+  decltype(bsp.polygon_indices)().swap(bsp.polygon_indices);
+  decltype(bsp.leaf_polygons)().swap(bsp.leaf_polygons);
+  decltype(bsp.light_points)().swap(bsp.light_points);
+  decltype(bsp.portal_polygon_indices)().swap(bsp.portal_polygon_indices);
+  std::vector<const zenkit::VirtualObject*> pending;
+  for(const auto& vob:data->world.world_vobs)
+    pending.push_back(vob.get());
+  size_t vobCount = 0;
+  while(!pending.empty()) {
+    const auto* vob = pending.back();
+    pending.pop_back();
+    ++vobCount;
+    for(const auto& child:vob->children)
+      pending.push_back(child.get());
+    }
+  // Allow an additional KiB per vob for derived descriptors, strings and child lists.
+  // This is a cache estimate, not an allocator-level RAM limit.
+  size_t metadataBytes = vobCount*(sizeof(zenkit::VirtualObject)+1024) + bytes(bsp.nodes) + bytes(bsp.leaf_node_indices) + bytes(bsp.sectors);
+  for(const auto& sector:bsp.sectors)
+    metadataBytes += sector.name.capacity() + bytes(sector.node_indices) + bytes(sector.portal_polygon_indices);
+  if(data->world.way_net)
+    metadataBytes += data->world.way_net->points.size()*512 + bytes(data->world.way_net->edges);
+  const auto visualBytes = bytes(mesh.vertices) + bytes(mesh.verticesA) + bytes(mesh.indices) + bytes(mesh.indices8) +
+                           bytes(mesh.subMeshes) + bytes(mesh.meshletBounds) + bytes(mesh.verticesId) +
+                           bytes(mesh.bvhNodes) + bytes(mesh.bvh8Nodes);
+  data->cacheBytes = metadataBytes + visualBytes + DynamicWorld::landscapeBytes(*data->landscape);
+  if(data->cacheBytes<=budget)
+    cache = data;
+  return data;
+  }
+
 const Tempest::IndexBuffer<uint16_t>& Resources::cubeIbo() {
   return inst->cube;
   }
 
@@ -25,6 +25,7 @@ class Animation;
 class AttachBinder;
 class PfxEmitterMesh;
 class GthFont;
+struct WorldData;
 
 namespace Dx8 {
 class DirectMusic;
@@ -84,6 +85,7 @@ class Resources final {
     static const char*               renderer();
     static void                      mountWork(const std::filesystem::path& path);
     static void                      loadVdfs(const std::vector<std::u16string> &modvdfs, bool modFilter);
+    static std::shared_ptr<const WorldData> loadWorld(std::string_view name, zenkit::GameVersion version);
 
     static const Tempest::Sampler&   shadowSampler();
 
@@ -231,6 +233,8 @@ class Resources final {
     std::unique_ptr<Dx8::DirectMusic> dxMusic;
     DmLoader*                         dmLoader = nullptr;
     zenkit::Vfs                       gothicAssets;
+    std::mutex                       syncWorld;
+    std::shared_ptr<const WorldData>  worldCache;
 
     std::vector<uint8_t>              fBuff, ddsBuf;
     Tempest::IndexBuffer<uint16_t>    cube;
 
@@ -1,4 +1,5 @@
 #include "world.h"
+#include "worlddata.h"
 
 #include <functional>
 #include <future>
@@ -73,40 +74,34 @@ World::World(GameSession& game, std::string_view file, bool startup, std::functi
     }
 
   try {
-    auto          buf = entry->open_read();
-    zenkit::World world;
-    world.load(buf.get(), version().game == 1 ? zenkit::GameVersion::GOTHIC_1
-                                              : zenkit::GameVersion::GOTHIC_2);
+    const auto data = Resources::loadWorld(wname, version().game==1 ? zenkit::GameVersion::GOTHIC_1
+                                                                  : zenkit::GameVersion::GOTHIC_2);
+    const auto& world = data->world;
 
     loadProgress(20);
-    auto& worldMesh = world.world_mesh;
-
     auto wdynamicFut = std::async(std::launch::async, [&]() {
       Workers::setThreadName("Loading: BVH thread");
-      return std::unique_ptr<DynamicWorld>(new DynamicWorld(this,worldMesh));
+      return std::unique_ptr<DynamicWorld>(new DynamicWorld(this,data->landscape));
       });
     auto wviewFut = std::async(std::launch::async, [&]() {
       Workers::setThreadName("Loading: PackedMesh thread");
-      PackedMesh vmesh(worldMesh,PackedMesh::PK_VisualLnd);
-      return std::unique_ptr<WorldView>(new WorldView(vmesh, wname));
+      return std::unique_ptr<WorldView>(new WorldView(*data->visual, wname));
       });
 
     loadProgress(30);
 
     {
-      bsp.nodes             = std::move(world.world_bsp_tree.nodes);
-      bsp.sectors           = std::move(world.world_bsp_tree.sectors);
-      bsp.leaf_node_indices = std::move(world.world_bsp_tree.leaf_node_indices);
+      bsp.nodes             = world.world_bsp_tree.nodes;
+      bsp.sectors           = world.world_bsp_tree.sectors;
+      bsp.leaf_node_indices = world.world_bsp_tree.leaf_node_indices;
       bsp.sectorsData.resize(bsp.sectors.size());
-      world.world_bsp_tree  = zenkit::BspTree();
     }
     loadProgress(50);
 
     wview = wviewFut.get();
     loadProgress(60);
 
     wdynamic = wdynamicFut.get();
-    world.world_mesh = zenkit::Mesh();
     loadProgress(70);
 
     globFx.reset(new GlobalEffects(*this));
 
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <zenkit/World.hh>
+#include "graphics/mesh/submesh/packedmesh.h"
+#include "physics/dynamicworld.h"
+
+// Original level data only. Never retain a GameSession, renderer, NPC or script VM here.
+struct WorldData {
+  const zenkit::VfsNode* source = nullptr;
+  zenkit::GameVersion version = zenkit::GameVersion::GOTHIC_2;
+  bool softwareRayTracing = false;
+  zenkit::World world;
+  std::unique_ptr<const PackedMesh> visual;
+  std::shared_ptr<const DynamicWorld::Landscape> landscape;
+  size_t cacheBytes = 0;
+  };