From 89485dc592f138cd244d61ac6871d745c3e82e9d Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Thu, 22 Jan 2026 22:27:30 +0300
Subject: [PATCH 01/20] fix extra faces when dense mode is off

---
 src/graphics/render/BlocksRenderer.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/graphics/render/BlocksRenderer.cpp b/src/graphics/render/BlocksRenderer.cpp
index 36f12a196..b96890edb 100644
--- a/src/graphics/render/BlocksRenderer.cpp
+++ b/src/graphics/render/BlocksRenderer.cpp
@@ -750,7 +750,7 @@ void BlocksRenderer::build(const Chunk* chunk, const VoxelsVolume& volume) {
     size_t endIndex = indexCount;
     
     denseRender = true;
-    densePass = true;
+    densePass = settings.graphics.denseRender.get();
     render(voxels, beginEnds);
 
     denseIndexCount = indexCount;

From d5f8fed63315d64327ea1bb5e83b4dca4cf9f5d5 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Fri, 23 Jan 2026 12:48:54 +0300
Subject: [PATCH 02/20] add AssetsManagement

---
 src/engine/AssetsManagement.cpp | 53 +++++++++++++++++++++++++++++++++
 src/engine/AssetsManagement.hpp | 22 ++++++++++++++
 src/engine/Engine.cpp           | 34 ++++-----------------
 src/engine/Engine.hpp           |  3 +-
 4 files changed, 82 insertions(+), 30 deletions(-)
 create mode 100644 src/engine/AssetsManagement.cpp
 create mode 100644 src/engine/AssetsManagement.hpp

diff --git a/src/engine/AssetsManagement.cpp b/src/engine/AssetsManagement.cpp
new file mode 100644
index 000000000..2135f568f
--- /dev/null
+++ b/src/engine/AssetsManagement.cpp
@@ -0,0 +1,53 @@
+#include "AssetsManagement.hpp"
+
+#include "assets/Assets.hpp"
+#include "assets/AssetsLoader.hpp"
+#include "engine/Engine.hpp"
+#include "debug/Logger.hpp"
+#include "content/Content.hpp"
+#include "graphics/core/Shader.hpp"
+#include "EnginePaths.hpp"
+#include "coders/GLSLExtension.hpp"
+#include "graphics/render/ModelsGenerator.hpp"
+#include "graphics/ui/GUI.hpp"
+
+static debug::Logger logger("assets-management");
+
+AssetsManagement::AssetsManagement(Engine& engine) : engine(engine) {}
+
+const Assets* AssetsManagement::getStorage() const {
+    return assets.get();
+}
+
+Assets* AssetsManagement::getStorage() {
+    return assets.get();
+}
+
+void AssetsManagement::loadAssets(Content* content) {
+    const auto& paths = engine.getPaths();
+    logger.info() << "loading assets";
+    Shader::preprocessor->setPaths(&paths.resPaths);
+
+    auto new_assets = std::make_unique<Assets>();
+    AssetsLoader loader(engine, *new_assets, paths.resPaths);
+    AssetsLoader::addDefaults(loader, content);
+
+    // no need
+    // correct log messages order is more useful
+    // todo: before setting to true, check if GLSLExtension thread safe
+    bool threading = false; // look at three upper lines
+    if (threading) {
+        auto task = loader.startTask([=](){});
+        task->waitForEnd();
+    } else {
+        while (loader.hasNext()) {
+            loader.loadNext();
+        }
+    }
+    assets = std::move(new_assets);
+    if (content) {
+        ModelsGenerator::prepare(*content, *assets);
+    }
+    assets->setup();
+    engine.getGUI().onAssetsLoad(assets.get());
+}
diff --git a/src/engine/AssetsManagement.hpp b/src/engine/AssetsManagement.hpp
new file mode 100644
index 000000000..5b06e6d8c
--- /dev/null
+++ b/src/engine/AssetsManagement.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <memory>
+
+class Assets;
+class AssetsLoader;
+class Engine;
+class Content;
+
+class AssetsManagement {
+public:
+    AssetsManagement(Engine& engine);
+
+    void loadAssets(Content* content);
+    
+    Assets* getStorage();
+    const Assets* getStorage() const;
+private:
+    Engine& engine;
+    std::unique_ptr<Assets> assets;
+    std::unique_ptr<AssetsLoader> backgroundLoader;
+};
diff --git a/src/engine/Engine.cpp b/src/engine/Engine.cpp
index 5a63991bb..6cc976799 100644
--- a/src/engine/Engine.cpp
+++ b/src/engine/Engine.cpp
@@ -34,6 +34,7 @@
 #include "window/input.hpp"
 #include "window/Window.hpp"
 #include "world/Level.hpp"
+#include "AssetsManagement.hpp"
 #include "Mainloop.hpp"
 #include "ServerMainloop.hpp"
 #include "WindowControl.hpp"
@@ -84,6 +85,7 @@ void Engine::onContentLoad() {
 }
 
 void Engine::initializeClient() {
+    assets = std::make_unique<AssetsManagement>(*this);
     windowControl = std::make_unique<WindowControl>(*this);
     auto [window, input] = windowControl->initialize();
 
@@ -305,7 +307,7 @@ void Engine::renderFrame() {
     screen->draw(time.getDelta());
 
     DrawContext ctx(nullptr, *window, nullptr);
-    gui->draw(ctx, *assets);
+    gui->draw(ctx, *assets->getStorage());
 }
 
 void Engine::saveSettings() {
@@ -363,33 +365,7 @@ void Engine::setLevelConsumer(OnWorldOpen levelConsumer) {
 }
 
 void Engine::loadAssets() {
-    logger.info() << "loading assets";
-    Shader::preprocessor->setPaths(&paths->resPaths);
-
-    auto content = this->content->get();
-
-    auto new_assets = std::make_unique<Assets>();
-    AssetsLoader loader(*this, *new_assets, paths->resPaths);
-    AssetsLoader::addDefaults(loader, content);
-
-    // no need
-    // correct log messages order is more useful
-    // todo: before setting to true, check if GLSLExtension thread safe
-    bool threading = false; // look at three upper lines
-    if (threading) {
-        auto task = loader.startTask([=](){});
-        task->waitForEnd();
-    } else {
-        while (loader.hasNext()) {
-            loader.loadNext();
-        }
-    }
-    assets = std::move(new_assets);
-    if (content) {
-        ModelsGenerator::prepare(*content, *assets);
-    }
-    assets->setup();
-    gui->onAssetsLoad(assets.get());
+    assets->loadAssets(content->get());
 }
 
 void Engine::loadProject() {
@@ -442,7 +418,7 @@ EngineSettings& Engine::getSettings() {
 }
 
 Assets* Engine::getAssets() {
-    return assets.get();
+    return assets->getStorage();
 }
 
 EnginePaths& Engine::getPaths() {
diff --git a/src/engine/Engine.hpp b/src/engine/Engine.hpp
index 06246f8c6..7ecff05c6 100644
--- a/src/engine/Engine.hpp
+++ b/src/engine/Engine.hpp
@@ -10,6 +10,7 @@
 #include <string>
 
 class Assets;
+class AssetsManagement;
 class ContentControl;
 class EngineController;
 class EnginePaths;
@@ -52,7 +53,7 @@ class Engine : public util::ObjectsKeeper {
     std::unique_ptr<EnginePaths> paths;
     std::unique_ptr<Project> project;
     std::unique_ptr<SettingsHandler> settingsHandler;
-    std::unique_ptr<Assets> assets;
+    std::unique_ptr<AssetsManagement> assets;
     std::shared_ptr<Screen> screen;
     std::unique_ptr<ContentControl> content;
     std::unique_ptr<EngineController> controller;

From 245e040a1c068ad1673d56b4256823cfb5dcd0ed Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Fri, 23 Jan 2026 22:39:20 +0300
Subject: [PATCH 03/20] add jobsSource to ThreadPool

---
 src/util/ThreadPool.hpp | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/src/util/ThreadPool.hpp b/src/util/ThreadPool.hpp
index 98ebcce5b..e1f7f24d7 100644
--- a/src/util/ThreadPool.hpp
+++ b/src/util/ThreadPool.hpp
@@ -2,6 +2,7 @@
 
 #include <atomic>
 #include <chrono>
+#include <optional>
 #include <condition_variable>
 #include <functional>
 #include <iostream>
@@ -48,6 +49,7 @@ namespace util {
         std::atomic<int> busyWorkers = 0;
         std::atomic<uint> jobsDone = 0;
         std::atomic<bool> working = true;
+        supplier<std::optional<T>> jobsSource = nullptr;
         bool failed = false;
         bool standaloneResults = true;
         bool stopOnFail = true;
@@ -151,6 +153,10 @@ namespace util {
             return working;
         }
 
+        void setJobsSource(supplier<std::optional<T>>&& source) {
+            jobsSource = std::move(source);
+        }
+
         void terminate() override {
             if (!working) {
                 return;
@@ -221,6 +227,22 @@ namespace util {
                     }
                 }
             }
+            if (jobsSource) {
+                bool jobsAdded = false;
+                std::lock_guard<std::mutex> jobsLock(jobsMutex);
+                while (true) {
+                    auto job = jobsSource();
+                    if (job.has_value()) {
+                        jobs.push(std::move(job.value()));
+                        jobsAdded = true;
+                    } else {
+                        break;
+                    }
+                }
+                if (jobsAdded) {
+                    jobsMutexCondition.notify_one();
+                }
+            }
             if (failed) {
                 throw std::runtime_error("some job failed");
             }

From 0cf7d9b1ed6d02e2e7a3ec8c035eb055ebb2b77c Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Fri, 23 Jan 2026 22:40:57 +0300
Subject: [PATCH 04/20] add background assets loader

---
 src/assets/AssetsLoader.cpp               | 30 +++++++++------
 src/assets/AssetsLoader.hpp               |  3 +-
 src/engine/AssetsManagement.cpp           | 47 +++++++++++++++++++----
 src/engine/AssetsManagement.hpp           | 13 ++++++-
 src/engine/Engine.cpp                     | 40 ++++++++++---------
 src/engine/Engine.hpp                     |  3 ++
 src/engine/EnginePaths.cpp                |  3 ++
 src/logic/scripting/lua/libs/libpack.cpp  |  4 +-
 src/logic/scripting/lua/libs/libworld.cpp |  7 ++--
 9 files changed, 104 insertions(+), 46 deletions(-)

diff --git a/src/assets/AssetsLoader.cpp b/src/assets/AssetsLoader.cpp
index cf64a9c8e..ca9ee93df 100644
--- a/src/assets/AssetsLoader.cpp
+++ b/src/assets/AssetsLoader.cpp
@@ -319,28 +319,27 @@ void AssetsLoader::addDefaults(AssetsLoader& loader, const Content* content) {
 }
 
 bool AssetsLoader::loadExternalTexture(
-    Assets* assets,
+    AssetsLoader& loader,
     const std::string& name,
     const std::vector<io::path>& alternatives
 ) {
-    if (assets->get<Texture>(name) != nullptr) {
+    if (loader.getAssets().get<Texture>(name) != nullptr) {
         return true;
     }
     for (auto& path : alternatives) {
-        if (io::exists(path)) {
-            try {
-                auto image = imageio::read(path);
-                assets->store(Texture::from(image.get()), name);
-                return true;
-            } catch (const std::exception& err) {
-                logger.error() << "error while loading external "
-                               << path.string() << ": " << err.what();
-            }
+        logger.info() << (path.string() + ".png");
+        if (io::exists(path.string() + ".png")) {
+            loader.add(AssetType::TEXTURE, path.string(), name, nullptr);
+            return true; // TODO: fallbacks support
         }
     }
     return false;
 }
 
+Assets& AssetsLoader::getAssets() {
+    return assets;
+}
+
 Engine& AssetsLoader::getEngine() {
     return engine;
 }
@@ -376,6 +375,15 @@ std::shared_ptr<Task> AssetsLoader::startTask(runnable onDone) {
             [this](const assetload::postfunc& func) { func(&assets); }
         );
     pool->setOnComplete(std::move(onDone));
+    pool->setJobsSource([this]() -> std::optional<aloader_entry> {
+        if (entries.empty()) {
+            return std::nullopt;
+        }
+        aloader_entry entry = std::move(entries.front());
+        entries.pop();
+        return entry;
+    });
+
     while (!entries.empty()) {
         aloader_entry entry = std::move(entries.front());
         entries.pop();
diff --git a/src/assets/AssetsLoader.hpp b/src/assets/AssetsLoader.hpp
index 78152b6ac..c34eb822d 100644
--- a/src/assets/AssetsLoader.hpp
+++ b/src/assets/AssetsLoader.hpp
@@ -124,10 +124,11 @@ public:
     static void addDefaults(AssetsLoader& loader, const Content* content);
 
     static bool loadExternalTexture(
-        Assets* assets,
+        AssetsLoader& loader,
         const std::string& name,
         const std::vector<io::path>& alternatives
     );
 
+    Assets& getAssets();
     Engine& getEngine();
 };
diff --git a/src/engine/AssetsManagement.cpp b/src/engine/AssetsManagement.cpp
index 2135f568f..55bfb9401 100644
--- a/src/engine/AssetsManagement.cpp
+++ b/src/engine/AssetsManagement.cpp
@@ -1,13 +1,12 @@
 #include "AssetsManagement.hpp"
 
-#include "assets/Assets.hpp"
 #include "assets/AssetsLoader.hpp"
-#include "engine/Engine.hpp"
-#include "debug/Logger.hpp"
-#include "content/Content.hpp"
-#include "graphics/core/Shader.hpp"
-#include "EnginePaths.hpp"
 #include "coders/GLSLExtension.hpp"
+#include "content/Content.hpp"
+#include "debug/Logger.hpp"
+#include "engine/Engine.hpp"
+#include "EnginePaths.hpp"
+#include "graphics/core/Shader.hpp"
 #include "graphics/render/ModelsGenerator.hpp"
 #include "graphics/ui/GUI.hpp"
 
@@ -15,6 +14,10 @@ static debug::Logger logger("assets-management");
 
 AssetsManagement::AssetsManagement(Engine& engine) : engine(engine) {}
 
+AssetsManagement::~AssetsManagement() {
+    finishBackgroundLoader();
+}
+
 const Assets* AssetsManagement::getStorage() const {
     return assets.get();
 }
@@ -23,7 +26,23 @@ Assets* AssetsManagement::getStorage() {
     return assets.get();
 }
 
+AssetsLoader& AssetsManagement::acquireBackgroundLoader() {
+    if (backgroundLoader) {
+        return *backgroundLoader;
+    }
+    if (assets == nullptr) {
+        throw std::runtime_error("no assets storage available");
+    }
+    backgroundLoader = std::make_unique<AssetsLoader>(
+        engine, *assets, engine.getResPaths()
+    );
+    backgroundLoaderTask = backgroundLoader->startTask(nullptr);
+    return *backgroundLoader;
+}
+
 void AssetsManagement::loadAssets(Content* content) {
+    finishBackgroundLoader();
+
     const auto& paths = engine.getPaths();
     logger.info() << "loading assets";
     Shader::preprocessor->setPaths(&paths.resPaths);
@@ -34,7 +53,7 @@ void AssetsManagement::loadAssets(Content* content) {
 
     // no need
     // correct log messages order is more useful
-    // todo: before setting to true, check if GLSLExtension thread safe
+    // todo: before setting to true, check if GLSLExtension thread safe 
     bool threading = false; // look at three upper lines
     if (threading) {
         auto task = loader.startTask([=](){});
@@ -51,3 +70,17 @@ void AssetsManagement::loadAssets(Content* content) {
     assets->setup();
     engine.getGUI().onAssetsLoad(assets.get());
 }
+
+void AssetsManagement::update() {
+    if (backgroundLoaderTask) {
+        backgroundLoaderTask->update();
+    }
+}
+
+void AssetsManagement::finishBackgroundLoader() {
+    if (backgroundLoaderTask == nullptr) {
+        return;
+    }
+    backgroundLoaderTask.reset();
+    backgroundLoader.reset();
+}
diff --git a/src/engine/AssetsManagement.hpp b/src/engine/AssetsManagement.hpp
index 5b06e6d8c..f88bc281a 100644
--- a/src/engine/AssetsManagement.hpp
+++ b/src/engine/AssetsManagement.hpp
@@ -1,22 +1,31 @@
 #pragma once
 
+#include "assets/Assets.hpp"
+
 #include <memory>
 
-class Assets;
 class AssetsLoader;
 class Engine;
 class Content;
+class Task;
 
-class AssetsManagement {
+class AssetsManagement final {
 public:
     AssetsManagement(Engine& engine);
+    ~AssetsManagement();
 
     void loadAssets(Content* content);
+    void update();
     
     Assets* getStorage();
     const Assets* getStorage() const;
+
+    AssetsLoader& acquireBackgroundLoader();
 private:
+    void finishBackgroundLoader();
+
     Engine& engine;
     std::unique_ptr<Assets> assets;
     std::unique_ptr<AssetsLoader> backgroundLoader;
+    std::shared_ptr<Task> backgroundLoaderTask;
 };
diff --git a/src/engine/Engine.cpp b/src/engine/Engine.cpp
index 6cc976799..9afe0824a 100644
--- a/src/engine/Engine.cpp
+++ b/src/engine/Engine.cpp
@@ -4,48 +4,45 @@
 #define GLEW_STATIC
 #endif
 
-#include "debug/Logger.hpp"
-#include "assets/AssetsLoader.hpp"
+#include "AssetsManagement.hpp"
 #include "audio/audio.hpp"
+#include "coders/commons.hpp"
 #include "coders/GLSLExtension.hpp"
 #include "coders/toml.hpp"
-#include "coders/commons.hpp"
-#include "devtools/Editor.hpp"
-#include "devtools/Project.hpp"
-#include "devtools/DebuggingServer.hpp"
 #include "content/ContentControl.hpp"
 #include "core_defs.hpp"
-#include "io/io.hpp"
-#include "io/settings_io.hpp"
+#include "debug/Logger.hpp"
+#include "devtools/DebuggingServer.hpp"
+#include "devtools/Editor.hpp"
+#include "devtools/Project.hpp"
+#include "EnginePaths.hpp"
 #include "frontend/locale.hpp"
 #include "frontend/menu.hpp"
 #include "frontend/screens/Screen.hpp"
-#include "graphics/render/ModelsGenerator.hpp"
 #include "graphics/core/DrawContext.hpp"
 #include "graphics/core/Shader.hpp"
-#include "graphics/ui/GUI.hpp"
 #include "graphics/ui/elements/Menu.hpp"
-#include "logic/EngineController.hpp"
+#include "graphics/ui/GUI.hpp"
+#include "io/io.hpp"
+#include "io/settings_io.hpp"
 #include "logic/CommandsInterpreter.hpp"
-#include "logic/scripting/scripting.hpp"
+#include "logic/EngineController.hpp"
 #include "logic/scripting/scripting_hud.hpp"
+#include "logic/scripting/scripting.hpp"
+#include "Mainloop.hpp"
 #include "network/Network.hpp"
+#include "ServerMainloop.hpp"
 #include "util/platform.hpp"
+#include "util/stringutil.hpp"
 #include "window/input.hpp"
 #include "window/Window.hpp"
-#include "world/Level.hpp"
-#include "AssetsManagement.hpp"
-#include "Mainloop.hpp"
-#include "ServerMainloop.hpp"
 #include "WindowControl.hpp"
-#include "EnginePaths.hpp"
+#include "world/Level.hpp"
 
-#include <iostream>
 #include <assert.h>
 #include <glm/glm.hpp>
 #include <unordered_set>
 #include <functional>
-#include <utility>
 
 static debug::Logger logger("engine");
 
@@ -266,6 +263,7 @@ void Engine::applicationTick() {
 
 void Engine::updateFrontend() {
     double delta = time.getDelta();
+    assets->update();
     updateHotkeys();
     audio::update(delta);
     gui->act(delta, window->getSize());
@@ -421,6 +419,10 @@ Assets* Engine::getAssets() {
     return assets->getStorage();
 }
 
+AssetsLoader& Engine::acquireBackgroundLoader() {
+    return assets->acquireBackgroundLoader();
+}
+
 EnginePaths& Engine::getPaths() {
     return *paths;
 }
diff --git a/src/engine/Engine.hpp b/src/engine/Engine.hpp
index 7ecff05c6..4f4e68280 100644
--- a/src/engine/Engine.hpp
+++ b/src/engine/Engine.hpp
@@ -10,6 +10,7 @@
 #include <string>
 
 class Assets;
+class AssetsLoader;
 class AssetsManagement;
 class ContentControl;
 class EngineController;
@@ -110,6 +111,8 @@ public:
     /// @brief Get active assets storage instance
     Assets* getAssets();
 
+    AssetsLoader& acquireBackgroundLoader();
+
     /// @brief Get writeable engine settings structure instance
     EngineSettings& getSettings();
 
diff --git a/src/engine/EnginePaths.cpp b/src/engine/EnginePaths.cpp
index 7cb71079c..c61d27f89 100644
--- a/src/engine/EnginePaths.cpp
+++ b/src/engine/EnginePaths.cpp
@@ -274,6 +274,9 @@ ResPaths::ResPaths(std::vector<PathsRoot> roots)
 }
 
 io::path ResPaths::find(const std::string& filename) const {
+    if (filename.find(':') != std::string::npos) {
+        return filename;
+    }
     for (int i = roots.size() - 1; i >= 0; i--) {
         auto& root = roots[i];
         auto file = root.path / filename;
diff --git a/src/logic/scripting/lua/libs/libpack.cpp b/src/logic/scripting/lua/libs/libpack.cpp
index b7162b4d0..66fa86426 100644
--- a/src/logic/scripting/lua/libs/libpack.cpp
+++ b/src/logic/scripting/lua/libs/libpack.cpp
@@ -87,10 +87,10 @@ static int l_pack_get_info(
     lua::setfield(L, "path");
 
     if (!engine->isHeadless()) {
-        auto assets = engine->getAssets();
+        auto& assetsLoader = engine->acquireBackgroundLoader();
         std::string icon = pack.id + ".icon";
         if (!AssetsLoader::loadExternalTexture(
-                assets, icon, {pack.folder / "icon.png"}
+                assetsLoader, icon, {pack.folder / "icon"}
             )) {
             icon = "gui/no_icon";
         }
diff --git a/src/logic/scripting/lua/libs/libworld.cpp b/src/logic/scripting/lua/libs/libworld.cpp
index 9b28c719f..a9567ea97 100644
--- a/src/logic/scripting/lua/libs/libworld.cpp
+++ b/src/logic/scripting/lua/libs/libworld.cpp
@@ -56,13 +56,12 @@ static int l_get_list(lua::State* L) {
         lua::pushstring(L, name);
         lua::setfield(L, "name");
 
-        auto assets = engine->getAssets();
         std::string icon = "world#" + name + ".icon";
         if (!engine->isHeadless() && !AssetsLoader::loadExternalTexture(
-                assets,
+                engine->acquireBackgroundLoader(),
                 icon,
-                {worlds[i] / "icon.png",
-                 worlds[i] / "preview.png"}
+                {worlds[i] / "icon",
+                 worlds[i] / "preview"}
             )) {
             icon = "gui/no_world_icon";
         }

From 5a742b8a0f68ee7d44442435425c4580d988651a Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Sat, 24 Jan 2026 14:21:38 +0300
Subject: [PATCH 05/20] feat: post-runnables context now allowing to use
 content-related app.* functions

---
 res/layouts/pages/content.xml.lua |  4 +++-
 res/scripts/stdlib.lua            | 16 +++++++++++++++-
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/res/layouts/pages/content.xml.lua b/res/layouts/pages/content.xml.lua
index 89c230ed0..e77141cc4 100644
--- a/res/layouts/pages/content.xml.lua
+++ b/res/layouts/pages/content.xml.lua
@@ -28,7 +28,9 @@ local function include(id, is_include)
 end
 
 function apply()
-    core.reconfig_packs(add_packs, rem_packs)
+    time.post_runnable(function ()
+        app.reconfig_packs(add_packs, rem_packs)
+    end)
     if mode ~= "world" then
         menu:back()
     end
diff --git a/res/scripts/stdlib.lua b/res/scripts/stdlib.lua
index 4eb6dd17e..683f27e8a 100644
--- a/res/scripts/stdlib.lua
+++ b/res/scripts/stdlib.lua
@@ -25,6 +25,7 @@ function tb_frame_tostring(frame)
 end
 
 local __vc__app_script_coroutine
+local __vc__is_post_runnable = false
 
 local function complete_app_lib(app)
     local __app_load_content = app.load_content
@@ -44,6 +45,10 @@ local function complete_app_lib(app)
     app.tick = __app_tick
 
     local function call_in_app_script_co(func, ...)
+        if __vc__is_post_runnable then
+            func(...)
+            return
+        end
         local running = coroutine.running()
         if not running or running ~= __vc__app_script_coroutine then
             error("content must be reload in application script coroutine")
@@ -513,7 +518,7 @@ local fn_audio_reset_fetch_buffer = audio.__reset_fetch_buffer
 audio.__reset_fetch_buffer = nil
 core.get_core_token = audio.input.__get_core_token
 
-function __process_post_runnables()
+local function __vc__process_post_runnables()
     if #__post_runnables then
         for _, func in ipairs(__post_runnables) do
             local status, result = xpcall(func, __vc__error)
@@ -547,6 +552,15 @@ function __process_post_runnables()
     end
 end
 
+function __process_post_runnables()
+    __vc__is_post_runnable = true
+    local success, err = pcall(__vc__process_post_runnables)
+    if not success then
+        debug.error("an error ocurred while processing post-runnables: ".. err)
+    end
+    __vc__is_post_runnable = false
+end
+
 function time.post_runnable(runnable)
     table.insert(__post_runnables, runnable)
 end

From 3f5fc5376d8fb4c5f18ef76c93a31c1e2afe8733 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Sat, 24 Jan 2026 14:33:38 +0300
Subject: [PATCH 06/20] elevate minimum ore generation height by 6 before
 blocks generation priority added

---
 res/content/base/modules/generation/ores.lua | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/res/content/base/modules/generation/ores.lua b/res/content/base/modules/generation/ores.lua
index 3b2c2f915..64b0c2a64 100644
--- a/res/content/base/modules/generation/ores.lua
+++ b/res/content/base/modules/generation/ores.lua
@@ -18,7 +18,7 @@ function ores.place(placements, x, z, w, d, seed, hmap, chunk_height)
         for i=1,count do
             local sx = math.random() * w
             local sz = math.random() * d
-            local sy = math.random() * (chunk_height * 0.5)
+            local sy = math.random() * (chunk_height * 0.5) + 6
             if sy < hmap:at(sx, sz) * chunk_height - 6 then
                 table.insert(placements, {ore.struct, {sx, sy, sz}, math.random()*4, -1})
             end

From 279299274a2e868912fb99e92e342eb3f4d13e03 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Mon, 26 Jan 2026 21:52:49 +0300
Subject: [PATCH 07/20] feat: pre-set `world:` entry-point on world creation

---
 src/logic/EngineController.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/logic/EngineController.cpp b/src/logic/EngineController.cpp
index db956e150..4e653beb5 100644
--- a/src/logic/EngineController.cpp
+++ b/src/logic/EngineController.cpp
@@ -276,8 +276,8 @@ void EngineController::createWorld(
     auto folder = paths.getWorldsFolder() / name;
 
     call(engine, [this, &paths, folder]() {
-        engine.getContentControl().loadContent();
         paths.setCurrentWorldFolder(folder);
+        engine.getContentControl().loadContent();
     });
 
     auto& contentControl = engine.getContentControl();

From 18e7fb55a64aa3a35261ddcf37032ed28fa38001 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Tue, 27 Jan 2026 23:04:30 +0300
Subject: [PATCH 08/20] cleanup Image element & add fallback

---
 src/graphics/ui/elements/Image.cpp | 51 ++++++++++++++----------------
 src/graphics/ui/elements/Image.hpp | 22 +++++++++----
 2 files changed, 40 insertions(+), 33 deletions(-)

diff --git a/src/graphics/ui/elements/Image.cpp b/src/graphics/ui/elements/Image.cpp
index f321ddf8a..49eb3d874 100644
--- a/src/graphics/ui/elements/Image.cpp
+++ b/src/graphics/ui/elements/Image.cpp
@@ -3,6 +3,7 @@
 #include <utility>
 
 #include "assets/Assets.hpp"
+#include "assets/assets_util.hpp"
 #include "graphics/core/Atlas.hpp"
 #include "graphics/core/Batch2D.hpp"
 #include "graphics/core/DrawContext.hpp"
@@ -16,37 +17,25 @@ Image::Image(GUI& gui, std::string texture, glm::vec2 size)
     setInteractive(false);
 }
 
+util::TextureRegion Image::refreshTexture(const Assets& assets) {
+    auto region = util::get_texture_region(assets, texture, fallback);
+    if (region.texture && autoresize) {
+        setSize(glm::vec2(
+            region.texture->getWidth() * region.region.getWidth(),
+            region.texture->getHeight() * region.region.getHeight()
+        ));
+    }
+    return region;
+}
+
 void Image::draw(const DrawContext& pctx, const Assets& assets) {
     glm::vec2 pos = calcPos();
     auto batch = pctx.getBatch2D();
 
-    Texture* texture = nullptr;
-    auto separator = this->texture.find(':');
-    if (separator == std::string::npos) {
-        texture = assets.get<Texture>(this->texture);
-        batch->texture(texture);
-        if (texture && autoresize) {
-            setSize(glm::vec2(texture->getWidth(), texture->getHeight()));
-        }
-    } else {
-        auto atlasName = this->texture.substr(0, separator);
-        if (auto atlas = assets.get<Atlas>(atlasName)) {
-            if (auto region =
-                    atlas->getIf(this->texture.substr(separator + 1))) {
-                texture = atlas->getTexture();
-                batch->texture(atlas->getTexture());
-                batch->setRegion(*region);
-                if (autoresize) {
-                    setSize(glm::vec2(
-                        texture->getWidth() * region->getWidth(),
-                        texture->getHeight() * region->getHeight()
-                    ));
-                }
-            } else {
-                batch->texture(nullptr);
-            }
-        }
-    }
+    auto textureRegion = refreshTexture(assets);
+    
+    batch->setRegion(textureRegion.region);
+    batch->texture(textureRegion.texture);
     batch->rect(
         pos.x,
         pos.y,
@@ -73,10 +62,18 @@ const std::string& Image::getTexture() const {
     return texture;
 }
 
+const std::string& Image::getFallback() const {
+    return fallback;
+}
+
 void Image::setTexture(const std::string& name) {
     texture = name;
 }
 
+void Image::setFallback(const std::string& name) {
+    fallback = name;
+}
+
 void Image::setRegion(const UVRegion& region) {
     this->region = region;
 }
diff --git a/src/graphics/ui/elements/Image.hpp b/src/graphics/ui/elements/Image.hpp
index 40765a4c0..194619f7d 100644
--- a/src/graphics/ui/elements/Image.hpp
+++ b/src/graphics/ui/elements/Image.hpp
@@ -3,21 +3,31 @@
 #include "UINode.hpp"
 #include "maths/UVRegion.hpp"
 
+namespace util {
+    struct TextureRegion;
+}
+
 namespace gui {
-    class Image : public UINode {
+    class Image final : public UINode {
     protected:
         std::string texture;
+        std::string fallback;
         UVRegion region {};
         bool autoresize = false;
+        bool isFallback = false;
+
+        util::TextureRegion refreshTexture(const Assets& assets);
     public:
         Image(GUI& gui, std::string texture, glm::vec2 size=glm::vec2(32,32));
 
-        virtual void draw(const DrawContext& pctx, const Assets& assets) override;
+        void draw(const DrawContext& pctx, const Assets& assets) override;
 
-        virtual void setAutoResize(bool flag);
-        virtual bool isAutoResize() const;
-        virtual const std::string& getTexture() const;
-        virtual void setTexture(const std::string& name);
+        void setAutoResize(bool flag);
+        bool isAutoResize() const;
+        const std::string& getTexture() const;
+        const std::string& getFallback() const;
+        void setTexture(const std::string& name);
+        void setFallback(const std::string& name);
         void setRegion(const UVRegion& region);
         const UVRegion& getRegion() const;
     };

From 6aac90094eb721d8d9cc7169cbc808ae34bace62 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Tue, 27 Jan 2026 23:10:08 +0300
Subject: [PATCH 09/20] add 'fallback' property to xml and scripting

---
 res/layouts/templates/pack.xml          |  2 +-
 res/layouts/templates/world.xml         |  2 +-
 src/graphics/ui/elements/Image.hpp      |  1 -
 src/graphics/ui/gui_xml.cpp             |  4 +++-
 src/logic/scripting/lua/libs/libgui.cpp | 14 ++++++++++++++
 5 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/res/layouts/templates/pack.xml b/res/layouts/templates/pack.xml
index 3b24aa960..56bd50e50 100644
--- a/res/layouts/templates/pack.xml
+++ b/res/layouts/templates/pack.xml
@@ -11,5 +11,5 @@
     <label ifnot='%{error}' pos='80,28' size='355,50' multiline='true' color='#FFFFFFB2'>
         %{description}
     </label>
-    <image pos='8,8' src='%{icon}' size='64'/>
+    <image pos='8,8' src='%{icon}' fallback='gui/no_icon' size='64'/>
 </container>
diff --git a/res/layouts/templates/world.xml b/res/layouts/templates/world.xml
index 4ae936b6e..d20f78407 100644
--- a/res/layouts/templates/world.xml
+++ b/res/layouts/templates/world.xml
@@ -4,7 +4,7 @@
     hover-color='#162B3399'
     onclick='app.open_world("%{name}")'
 >
-    <image pos='1' src='%{icon}' size='96,64'></image>
+    <image pos='1' src='%{icon}' fallback='gui/no_world_icon' size='96,64'></image>
     <label pos='104,8'>%{name}</label>
     <button margin='4'
             gravity='center-right'
diff --git a/src/graphics/ui/elements/Image.hpp b/src/graphics/ui/elements/Image.hpp
index 194619f7d..cb0bf25dd 100644
--- a/src/graphics/ui/elements/Image.hpp
+++ b/src/graphics/ui/elements/Image.hpp
@@ -14,7 +14,6 @@ namespace gui {
         std::string fallback;
         UVRegion region {};
         bool autoresize = false;
-        bool isFallback = false;
 
         util::TextureRegion refreshTexture(const Assets& assets);
     public:
diff --git a/src/graphics/ui/gui_xml.cpp b/src/graphics/ui/gui_xml.cpp
index 9b40c3b72..bc3714e43 100644
--- a/src/graphics/ui/gui_xml.cpp
+++ b/src/graphics/ui/gui_xml.cpp
@@ -632,8 +632,10 @@ static std::shared_ptr<UINode> read_image(
     const UiXmlReader& reader, const xml::xmlelement& element
 ) {
     std::string src = element.attr("src", "").getText();
-    auto image = std::make_shared<Image>(reader.getGUI(), src);
+    std::string fallback = element.attr("fallback", "").getText();
+    auto image = std::make_shared<Image>(reader.getGUI(), std::move(src));
     read_uinode(reader, element, *image);
+    image->setFallback(std::move(fallback));
 
     if (element.has("region")) {
         auto vec = element.attr("region").asVec4();
diff --git a/src/logic/scripting/lua/libs/libgui.cpp b/src/logic/scripting/lua/libs/libgui.cpp
index cb98de7d7..fe4cabada 100644
--- a/src/logic/scripting/lua/libs/libgui.cpp
+++ b/src/logic/scripting/lua/libs/libgui.cpp
@@ -397,6 +397,13 @@ static int p_get_src(UINode* node, lua::State* L) {
     return 0;
 }
 
+static int p_get_fallback(UINode* node, lua::State* L) {
+    if (auto image = dynamic_cast<Image*>(node)) {
+        return lua::pushstring(L, image->getFallback());
+    }
+    return 0;
+}
+
 static int p_get_region(UINode* node, lua::State* L) {
     if (auto image = dynamic_cast<Image*>(node)) {
         const auto& region = image->getRegion();
@@ -663,6 +670,7 @@ static int l_gui_getattr(lua::State* L) {
             {"syntax", p_get_syntax},
             {"markup", p_get_markup},
             {"src", p_get_src},
+            {"fallback", p_get_fallback},
             {"value", p_get_value},
             {"min", p_get_min},
             {"max", p_get_max},
@@ -790,6 +798,11 @@ static void p_set_src(UINode* node, lua::State* L, int idx) {
         modelviewer->setModel(lua::require_string(L, idx));
     }
 }
+static void p_set_fallback(UINode* node, lua::State* L, int idx) {
+    if (auto image = dynamic_cast<Image*>(node)) {
+        image->setFallback(lua::require_string(L, idx));
+    }
+}
 static void p_set_region(UINode* node, lua::State* L, int idx) {
     if (auto image = dynamic_cast<Image*>(node)) {
         auto vec = lua::tovec4(L, idx);
@@ -962,6 +975,7 @@ static int l_gui_setattr(lua::State* L) {
             {"syntax", p_set_syntax},
             {"markup", p_set_markup},
             {"src", p_set_src},
+            {"fallback", p_set_fallback},
             {"caret", p_set_caret},
             {"value", p_set_value},
             {"min", p_set_min},

From 5ca0891c3d82823a997c48d7a7d5f536997d3a79 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Tue, 27 Jan 2026 23:15:14 +0300
Subject: [PATCH 10/20] update ui docs

---
 doc/en/scripting/ui.md   | 9 +++++----
 doc/en/xml-ui-layouts.md | 1 +
 doc/ru/scripting/ui.md   | 1 +
 doc/ru/xml-ui-layouts.md | 1 +
 4 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/doc/en/scripting/ui.md b/doc/en/scripting/ui.md
index 968a11929..04784b449 100644
--- a/doc/en/scripting/ui.md
+++ b/doc/en/scripting/ui.md
@@ -167,10 +167,11 @@ Properties:
 
 Properties:
 
-| Name   | Type   | Read | Write | Description      |
-| ------ | ------ | ---- | ----- | ---------------- |
-| src    | string | yes  | yes   | texture name     |
-| region | vec4   | yes  | yes   | image sub-region |
+| Name     | Type   | Read | Write | Description      |
+| -------- | ------ | ---- | ----- | ---------------- |
+| src      | string | yes  | yes   | texture name     |
+| fallback | string | yes  | yes   | fallback texture |
+| region   | vec4   | yes  | yes   | image sub-region |
 
 ## Canvas
 
diff --git a/doc/en/xml-ui-layouts.md b/doc/en/xml-ui-layouts.md
index b7126a088..97b36d1f6 100644
--- a/doc/en/xml-ui-layouts.md
+++ b/doc/en/xml-ui-layouts.md
@@ -120,6 +120,7 @@ Inner text is a button text.
 
 - `src` - name of an image stored in textures folder. Extension is not specified. Type: string.
   Example: *gui/error*
+- `fallback` - a fallback texture displayed when the main texture is missing / loading.
 - `region` - image region x1, y1, x2, y2 from 0.0, 0.0 (upper left corner), 1.0, 1.0 (lower right corner)
 
 ## *canvas*
diff --git a/doc/ru/scripting/ui.md b/doc/ru/scripting/ui.md
index 4371c931e..ad53ad824 100644
--- a/doc/ru/scripting/ui.md
+++ b/doc/ru/scripting/ui.md
@@ -170,6 +170,7 @@ document["worlds-panel"]:clear()
 | Название | Тип    | Чтение | Запись | Описание               |
 | -------- | ------ | ------ | ------ | ---------------------- |
 | src      | string | да     | да     | отображаемая текстура  |
+| fallback | string | да     | да     | резервная текстура     |
 | region   | vec4   | да     | да     | под-регион изображения |
 
 ## Холст (canvas)
diff --git a/doc/ru/xml-ui-layouts.md b/doc/ru/xml-ui-layouts.md
index 1362f6307..aeb669b3f 100644
--- a/doc/ru/xml-ui-layouts.md
+++ b/doc/ru/xml-ui-layouts.md
@@ -121,6 +121,7 @@
 ## Изображение - *image*
 
 - `src` - имя изображения в папке textures без указания расширения. Тип: строка. Например `gui/error`
+- `fallback` - резервная текстура, отображаемая при отсутствии / фоновой загрузке основной
 - `region` - под-регион изображения x1, y1, x2, y2 от 0.0, 0.0 (левый верхний угол), 1.0, 1.0 (правый нижний угол)
 
 ## Холст - *canvas*

From 6afb5c8c0f252524996e0ab480a5dac07ba79230 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Wed, 28 Jan 2026 12:48:10 +0300
Subject: [PATCH 11/20] add assets.request_texture

---
 doc/en/scripting/builtins/libassets.md     |  7 +++++++
 doc/ru/scripting/builtins/libassets.md     | 10 +++++++++-
 src/logic/scripting/lua/libs/libassets.cpp | 10 ++++++++++
 3 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/doc/en/scripting/builtins/libassets.md b/doc/en/scripting/builtins/libassets.md
index b39239a5b..6451995b9 100644
--- a/doc/en/scripting/builtins/libassets.md
+++ b/doc/en/scripting/builtins/libassets.md
@@ -5,6 +5,13 @@ A library for working with audio/visual assets.
 ## Functions
 
 ```lua
+-- Requests background texture loading
+assets.request_texture(
+    -- Image file
+    filename: string,
+    -- Texture name after loading
+    name: string,
+)
 -- Loads a texture
 assets.load_texture(
     -- Array of bytes of an image file
diff --git a/doc/ru/scripting/builtins/libassets.md b/doc/ru/scripting/builtins/libassets.md
index f80b710ad..c63c7aebe 100644
--- a/doc/ru/scripting/builtins/libassets.md
+++ b/doc/ru/scripting/builtins/libassets.md
@@ -5,6 +5,14 @@
 ## Функции
 
 ```lua
+-- Запрашивает фоновую загрузку текстуры
+assets.request_texture(
+    -- Файла изображения
+    filename: string,
+    -- Имя текстуры после загрузки
+    name: string,
+)
+
 -- Загружает текстуру
 assets.load_texture(
     -- Массив байт файла изображения
@@ -33,4 +41,4 @@ assets.to_canvas(
     -- так и находящиеся в атласе ("атлас:имя_текстуры").
     name: string
 ) -> Canvas
-```
\ No newline at end of file
+```
diff --git a/src/logic/scripting/lua/libs/libassets.cpp b/src/logic/scripting/lua/libs/libassets.cpp
index 6a16c3cfd..0921f1b9c 100644
--- a/src/logic/scripting/lua/libs/libassets.cpp
+++ b/src/logic/scripting/lua/libs/libassets.cpp
@@ -1,6 +1,7 @@
 #include "api_lua.hpp"
 
 #include "assets/Assets.hpp"
+#include "assets/AssetsLoader.hpp"
 #include "coders/png.hpp"
 #include "coders/vcm.hpp"
 #include "debug/Logger.hpp"
@@ -24,6 +25,14 @@ static void load_texture(
     }
 }
 
+static int l_request_texture(lua::State* L) {
+    std::string filename = lua::require_string(L, 1);
+    std::string alias = lua::require_string(L, 2);
+    auto& loader = engine->acquireBackgroundLoader();
+    loader.add(AssetType::TEXTURE, filename, alias);
+    return 0;
+}
+
 static int l_load_texture(lua::State* L) {
     if (lua::isstring(L, 3) && lua::require_lstring(L, 3) != "png") {
         throw std::runtime_error("unsupportd image format");
@@ -108,6 +117,7 @@ static int l_to_canvas(lua::State* L) {
 }
 
 const luaL_Reg assetslib[] = {
+    {"request_texture", lua::wrap<l_request_texture>},
     {"load_texture", lua::wrap<l_load_texture>},
     {"parse_model", lua::wrap<l_parse_model>},
     {"to_canvas", lua::wrap<l_to_canvas>},

From 1cf4fb8703bd4e8a5c4d28eaae1428b362348f89 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Wed, 28 Jan 2026 19:25:45 +0300
Subject: [PATCH 12/20] small fixes

---
 doc/ru/scripting/builtins/libassets.md |  2 +-
 src/assets/AssetsLoader.cpp            | 12 ++++++++----
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/doc/ru/scripting/builtins/libassets.md b/doc/ru/scripting/builtins/libassets.md
index c63c7aebe..161bb6cfb 100644
--- a/doc/ru/scripting/builtins/libassets.md
+++ b/doc/ru/scripting/builtins/libassets.md
@@ -7,7 +7,7 @@
 ```lua
 -- Запрашивает фоновую загрузку текстуры
 assets.request_texture(
-    -- Файла изображения
+    -- Файл изображения
     filename: string,
     -- Имя текстуры после загрузки
     name: string,
diff --git a/src/assets/AssetsLoader.cpp b/src/assets/AssetsLoader.cpp
index ca9ee93df..55806ac3e 100644
--- a/src/assets/AssetsLoader.cpp
+++ b/src/assets/AssetsLoader.cpp
@@ -327,10 +327,14 @@ bool AssetsLoader::loadExternalTexture(
         return true;
     }
     for (auto& path : alternatives) {
-        logger.info() << (path.string() + ".png");
-        if (io::exists(path.string() + ".png")) {
-            loader.add(AssetType::TEXTURE, path.string(), name, nullptr);
-            return true; // TODO: fallbacks support
+        if (io::exists(path)) {
+            loader.add(
+                AssetType::TEXTURE,
+                (path.parent() / path.stem()).string(),
+                name,
+                nullptr
+            );
+            return true;
         }
     }
     return false;

From 63024133be46ed21582d25caf5713675d14f478e Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Wed, 28 Jan 2026 20:06:00 +0300
Subject: [PATCH 13/20] add 'system.max-bg-asset-loaders' setting

---
 src/assets/AssetsLoader.cpp               |  5 +++--
 src/assets/AssetsLoader.hpp               |  2 +-
 src/engine/AssetsManagement.cpp           | 12 +++++++++---
 src/engine/AssetsManagement.hpp           |  2 ++
 src/io/settings_io.cpp                    |  3 +++
 src/logic/scripting/lua/libs/libpack.cpp  |  2 +-
 src/logic/scripting/lua/libs/libworld.cpp |  4 ++--
 src/settings.hpp                          |  5 +++++
 8 files changed, 26 insertions(+), 9 deletions(-)

diff --git a/src/assets/AssetsLoader.cpp b/src/assets/AssetsLoader.cpp
index 55806ac3e..4543a054b 100644
--- a/src/assets/AssetsLoader.cpp
+++ b/src/assets/AssetsLoader.cpp
@@ -371,12 +371,13 @@ public:
     }
 };
 
-std::shared_ptr<Task> AssetsLoader::startTask(runnable onDone) {
+std::shared_ptr<Task> AssetsLoader::startTask(runnable onDone, int maxWorkers) {
     auto pool =
         std::make_shared<util::ThreadPool<aloader_entry, assetload::postfunc>>(
             "assets-loader-pool",
             [=]() { return std::make_shared<LoaderWorker>(this); },
-            [this](const assetload::postfunc& func) { func(&assets); }
+            [this](const assetload::postfunc& func) { func(&assets); },
+            maxWorkers
         );
     pool->setOnComplete(std::move(onDone));
     pool->setJobsSource([this]() -> std::optional<aloader_entry> {
diff --git a/src/assets/AssetsLoader.hpp b/src/assets/AssetsLoader.hpp
index c34eb822d..3d1704545 100644
--- a/src/assets/AssetsLoader.hpp
+++ b/src/assets/AssetsLoader.hpp
@@ -113,7 +113,7 @@ public:
     /// @throws assetload::error
     void loadNext();
 
-    std::shared_ptr<Task> startTask(runnable onDone);
+    std::shared_ptr<Task> startTask(runnable onDone, int maxWorkers);
 
     const ResPaths& getPaths() const;
     aloader_func getLoader(AssetType tag);
diff --git a/src/engine/AssetsManagement.cpp b/src/engine/AssetsManagement.cpp
index 55bfb9401..578a0e45b 100644
--- a/src/engine/AssetsManagement.cpp
+++ b/src/engine/AssetsManagement.cpp
@@ -12,7 +12,9 @@
 
 static debug::Logger logger("assets-management");
 
-AssetsManagement::AssetsManagement(Engine& engine) : engine(engine) {}
+AssetsManagement::AssetsManagement(Engine& engine)
+    : engine(engine), settings(engine.getSettings()) {
+}
 
 AssetsManagement::~AssetsManagement() {
     finishBackgroundLoader();
@@ -36,7 +38,9 @@ AssetsLoader& AssetsManagement::acquireBackgroundLoader() {
     backgroundLoader = std::make_unique<AssetsLoader>(
         engine, *assets, engine.getResPaths()
     );
-    backgroundLoaderTask = backgroundLoader->startTask(nullptr);
+    backgroundLoaderTask = backgroundLoader->startTask(
+        nullptr, settings.system.maxBgAssetLoaders.get()
+    );
     return *backgroundLoader;
 }
 
@@ -56,7 +60,9 @@ void AssetsManagement::loadAssets(Content* content) {
     // todo: before setting to true, check if GLSLExtension thread safe 
     bool threading = false; // look at three upper lines
     if (threading) {
-        auto task = loader.startTask([=](){});
+        auto task = loader.startTask(
+            [=]() {}, 0
+        );
         task->waitForEnd();
     } else {
         while (loader.hasNext()) {
diff --git a/src/engine/AssetsManagement.hpp b/src/engine/AssetsManagement.hpp
index f88bc281a..4e14c9305 100644
--- a/src/engine/AssetsManagement.hpp
+++ b/src/engine/AssetsManagement.hpp
@@ -8,6 +8,7 @@ class AssetsLoader;
 class Engine;
 class Content;
 class Task;
+struct EngineSettings;
 
 class AssetsManagement final {
 public:
@@ -25,6 +26,7 @@ private:
     void finishBackgroundLoader();
 
     Engine& engine;
+    const EngineSettings& settings;
     std::unique_ptr<Assets> assets;
     std::unique_ptr<AssetsLoader> backgroundLoader;
     std::shared_ptr<Task> backgroundLoaderTask;
diff --git a/src/io/settings_io.cpp b/src/io/settings_io.cpp
index bc9d3c0a7..da0027c4d 100644
--- a/src/io/settings_io.cpp
+++ b/src/io/settings_io.cpp
@@ -94,6 +94,9 @@ SettingsHandler::SettingsHandler(EngineSettings& settings) {
     builder.add("do-write-lights", &settings.debug.doWriteLights);
     builder.add("do-trace-shaders", &settings.debug.doTraceShaders);
     builder.add("enable-experimental", &settings.debug.enableExperimental);
+
+    builder.addSection("system");
+    builder.add("max-bg-asset-loaders", &settings.system.maxBgAssetLoaders);
 }
 
 dv::value SettingsHandler::getValue(const std::string& name) const {
diff --git a/src/logic/scripting/lua/libs/libpack.cpp b/src/logic/scripting/lua/libs/libpack.cpp
index 66fa86426..13171490c 100644
--- a/src/logic/scripting/lua/libs/libpack.cpp
+++ b/src/logic/scripting/lua/libs/libpack.cpp
@@ -90,7 +90,7 @@ static int l_pack_get_info(
         auto& assetsLoader = engine->acquireBackgroundLoader();
         std::string icon = pack.id + ".icon";
         if (!AssetsLoader::loadExternalTexture(
-                assetsLoader, icon, {pack.folder / "icon"}
+                assetsLoader, icon, {pack.folder / "icon.png"}
             )) {
             icon = "gui/no_icon";
         }
diff --git a/src/logic/scripting/lua/libs/libworld.cpp b/src/logic/scripting/lua/libs/libworld.cpp
index a9567ea97..30a619788 100644
--- a/src/logic/scripting/lua/libs/libworld.cpp
+++ b/src/logic/scripting/lua/libs/libworld.cpp
@@ -60,8 +60,8 @@ static int l_get_list(lua::State* L) {
         if (!engine->isHeadless() && !AssetsLoader::loadExternalTexture(
                 engine->acquireBackgroundLoader(),
                 icon,
-                {worlds[i] / "icon",
-                 worlds[i] / "preview"}
+                {worlds[i] / "icon.png",
+                 worlds[i] / "preview.png"}
             )) {
             icon = "gui/no_world_icon";
         }
diff --git a/src/settings.hpp b/src/settings.hpp
index 070a607cf..0a0754235 100644
--- a/src/settings.hpp
+++ b/src/settings.hpp
@@ -115,6 +115,10 @@ struct UiSettings {
 struct NetworkSettings {
 };
 
+struct SystemSettings {
+    IntegerSetting maxBgAssetLoaders {3, -4, 16};
+};
+
 struct EngineSettings {
     AudioSettings audio;
     DisplaySettings display;
@@ -125,4 +129,5 @@ struct EngineSettings {
     UiSettings ui;
     NetworkSettings network;
     PathfindingSettings pathfinding;
+    SystemSettings system;
 };

From f1a015d3e7fb3857cf656ca36685216178f40e1a Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Wed, 28 Jan 2026 23:04:06 +0300
Subject: [PATCH 14/20] optimize BlocksController::randomTick & reduce small
 allocations count

---
 src/logic/BlocksController.cpp | 17 +++--------------
 src/logic/BlocksController.hpp |  1 +
 src/voxels/Chunk.hpp           |  2 ++
 3 files changed, 6 insertions(+), 14 deletions(-)

diff --git a/src/logic/BlocksController.cpp b/src/logic/BlocksController.cpp
index 08e2aae7c..f859a8455 100644
--- a/src/logic/BlocksController.cpp
+++ b/src/logic/BlocksController.cpp
@@ -1,7 +1,5 @@
 #include "BlocksController.hpp"
 
-#include <set>
-
 #include "content/Content.hpp"
 #include "items/Inventories.hpp"
 #include "items/Inventory.hpp"
@@ -175,12 +173,8 @@ void BlocksController::randomTick(
 void BlocksController::randomTick(int tickid, int parts, uint padding) {
     auto indices = level.content.getIndices();
 
-    std::set<uint64_t> chunksIterated;
-
     for (const auto& [pid, player] : *level.players) {
         const auto& chunks = *player->chunks;
-        int offsetX = chunks.getOffsetX();
-        int offsetY = chunks.getOffsetY();
         int width = chunks.getWidth();
         int height = chunks.getHeight();
         int segments = 4;
@@ -195,20 +189,15 @@ void BlocksController::randomTick(int tickid, int parts, uint padding) {
                 if (chunk == nullptr || !chunk->flags.lighted) {
                     continue;
                 }
-                union {
-                    int32_t pos[2];
-                    uint64_t key;
-                } posU;
-                posU.pos[0] = x + offsetX;
-                posU.pos[1] = z + offsetY;
-                if (chunksIterated.find(posU.key) != chunksIterated.end()) {
+                if (chunk->lastRandomTickId == randomTickId) {
                     continue;
                 }
-                chunksIterated.insert(posU.key);
+                chunk->lastRandomTickId = randomTickId;
                 randomTick(*chunk, segments, indices);
             }
         }
     }
+    randomTickId++;
 }
 
 int64_t BlocksController::createBlockInventory(int x, int y, int z) {
diff --git a/src/logic/BlocksController.hpp b/src/logic/BlocksController.hpp
index f3fa5f67a..8b26e0190 100644
--- a/src/logic/BlocksController.hpp
+++ b/src/logic/BlocksController.hpp
@@ -33,6 +33,7 @@ class BlocksController {
     util::Clock worldTickClock;
     FastRandom random {};
     std::vector<on_block_interaction> blockInteractionCallbacks;
+    uint64_t randomTickId = 0;
 public:
     BlocksController(const Level& level, Lighting* lighting);
 
diff --git a/src/voxels/Chunk.hpp b/src/voxels/Chunk.hpp
index 393f05f8a..5d45629ea 100644
--- a/src/voxels/Chunk.hpp
+++ b/src/voxels/Chunk.hpp
@@ -40,6 +40,8 @@ public:
         bool dirtyHeights : 1;
     } flags {};
 
+    uint64_t lastRandomTickId = -1;
+
     /// @brief Block inventories map where key is index of block in voxels array
     ChunkInventoriesMap inventories;
     /// @brief Blocks metadata heap

From 99f06c96253ef17d1733cd3bf8159f70db46c9e2 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Thu, 29 Jan 2026 18:36:23 +0300
Subject: [PATCH 15/20] add util::array_queue

---
 src/util/array_queue.hpp | 76 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 76 insertions(+)
 create mode 100644 src/util/array_queue.hpp

diff --git a/src/util/array_queue.hpp b/src/util/array_queue.hpp
new file mode 100644
index 000000000..3e8799152
--- /dev/null
+++ b/src/util/array_queue.hpp
@@ -0,0 +1,76 @@
+#pragma once
+
+#include <memory>
+#include <cstring>
+#include <stdexcept>
+
+namespace util {
+    template <typename T>
+    class array_queue {
+    public:
+        array_queue(size_t initCapacity = 8)
+        : _capacity(initCapacity),
+            _size(0),
+            _front(0),
+            _back(0),
+            _data(new T[_capacity]) {
+            if (initCapacity == 0 || (initCapacity & (initCapacity - 1)) != 0) {
+                throw std::invalid_argument("initCapacity must be positive power of 2");
+            }
+        }
+
+        ~array_queue() {
+            // todo
+            delete[] _data;
+        }
+
+        void push(T&& value) {
+            if (_back == _front && _size) {
+                grow();
+            }
+            _data[_back] = std::forward<T>(value);
+            _back = (_back + 1) & (_capacity - 1);
+            ++_size;
+        }
+
+        T& front() {
+            return _data[_front];
+        }
+
+        void pop() {
+            _data[_front].~T();
+            _front = (_front + 1) & (_capacity - 1);
+            --_size;
+        }
+
+        bool empty() const {
+            return _size == 0;
+        }
+
+        size_t size() const {
+            return _size;
+        }
+
+    private:
+        size_t _capacity;
+        size_t _size;
+        size_t _front;
+        size_t _back;
+        T* _data;
+
+        void grow() {
+            size_t newCapacity = _capacity * 2;
+            T* newData = new T[newCapacity];
+
+            std::move(_data + _front, _data + _capacity, newData);
+            std::move(_data, _data + _front, newData + (_capacity - _front));
+
+            _back = _size;
+            _front = 0;
+
+            delete[] _data;
+            _data = newData;
+            _capacity = newCapacity;
+        }
+    };
+}

From 5c64d567667355eb5eea0e1a1ff24264ae2e3d6f Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Thu, 29 Jan 2026 18:37:20 +0300
Subject: [PATCH 16/20] replace deque with array_queue in LightSolver

---
 src/lighting/LightSolver.cpp | 49 ++++++++++++++++++------------------
 src/lighting/LightSolver.hpp |  6 ++---
 2 files changed, 28 insertions(+), 27 deletions(-)

diff --git a/src/lighting/LightSolver.cpp b/src/lighting/LightSolver.cpp
index cda3ccc88..b6091fdc5 100644
--- a/src/lighting/LightSolver.cpp
+++ b/src/lighting/LightSolver.cpp
@@ -55,7 +55,7 @@ void LightSolver::remove(int x, int y, int z) {
     lightmap.set(x-chunk->x*CHUNK_W, y, z-chunk->z*CHUNK_D, channel, 0);
 }
 
-void LightSolver::solve(){
+void LightSolver::solve() {
     const int coords[] = {
             0, 0, 1,
             0, 0,-1,
@@ -66,47 +66,48 @@ void LightSolver::solve(){
     };
 
     while (!remqueue.empty()){
-        const lightentry entry = remqueue.front();
+        lightentry entry = std::move(remqueue.front());
         remqueue.pop();
 
         for (int i = 0; i < 6; i++) {
-            int imul3 = i*3;
+            int imul3 = i * 3;
             int x = entry.x+coords[imul3];
             int y = entry.y+coords[imul3+1];
             int z = entry.z+coords[imul3+2];
             
             Chunk* chunk = chunks.getChunkByVoxel(x,y,z);
-            if (chunk) {
-                int lx = x - chunk->x * CHUNK_W;
-                int lz = z - chunk->z * CHUNK_D;
-                chunk->flags.modified = true;
+            if (chunk == nullptr) {
+                continue;
+            }
+            int lx = x - chunk->x * CHUNK_W;
+            int lz = z - chunk->z * CHUNK_D;
+            chunk->flags.modified = true;
 
-                assert(chunk->lightmap != nullptr);
-                auto& lightmap = *chunk->lightmap;
+            assert(chunk->lightmap != nullptr);
+            auto& lightmap = *chunk->lightmap;
 
-                ubyte light = lightmap.get(lx,y,lz, channel);
-                if (light != 0 && light == entry.light-1){
-                    voxel* vox = chunks.get(x, y, z);
-                    if (vox && vox->id != 0) {
-                        const Block* block = blockDefs[vox->id];
-                        if (uint8_t emission = block->emission[channel]) {
-                            addqueue.push(lightentry {x, y, z, emission});
-                            lightmap.set(lx, y, lz, channel, emission);
-                        }
-                        else lightmap.set(lx, y, lz, channel, 0);
+            ubyte light = lightmap.get(lx,y,lz, channel);
+            if (light != 0 && light == entry.light-1) {
+                voxel* vox = chunks.get(x, y, z);
+                if (vox && vox->id != 0) {
+                    const Block* block = blockDefs[vox->id];
+                    if (uint8_t emission = block->emission[channel]) {
+                        addqueue.push(lightentry {x, y, z, emission});
+                        lightmap.set(lx, y, lz, channel, emission);
                     }
                     else lightmap.set(lx, y, lz, channel, 0);
-                    remqueue.push(lightentry {x, y, z, light});
-                }
-                else if (light >= entry.light){
-                    addqueue.push(lightentry {x, y, z, light});
                 }
+                else lightmap.set(lx, y, lz, channel, 0);
+                remqueue.push(lightentry {x, y, z, light});
+            }
+            else if (light >= entry.light) {
+                addqueue.push(lightentry {x, y, z, light});
             }
         }
     }
 
     while (!addqueue.empty()){
-        const lightentry entry = addqueue.front();
+        lightentry entry = std::move(addqueue.front());
         addqueue.pop();
 
         for (int i = 0; i < 6; i++) {
diff --git a/src/lighting/LightSolver.hpp b/src/lighting/LightSolver.hpp
index e51863e1e..1e36a0e1d 100644
--- a/src/lighting/LightSolver.hpp
+++ b/src/lighting/LightSolver.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <queue>
+#include "util/array_queue.hpp"
 
 class Chunks;
 class ContentIndices;
@@ -14,8 +14,8 @@ struct lightentry {
 };
 
 class LightSolver {
-    std::queue<lightentry> addqueue;
-    std::queue<lightentry> remqueue;
+    util::array_queue<lightentry> addqueue;
+    util::array_queue<lightentry> remqueue;
     const Block* const* blockDefs;
     Chunks& chunks;
     int channel;

From 117199a3ecc43a32eed6324ab1c4193e9c49b6cb Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Thu, 29 Jan 2026 19:28:24 +0300
Subject: [PATCH 17/20] update array_queue memory management

---
 src/util/array_queue.hpp | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/util/array_queue.hpp b/src/util/array_queue.hpp
index 3e8799152..649ec2282 100644
--- a/src/util/array_queue.hpp
+++ b/src/util/array_queue.hpp
@@ -9,19 +9,20 @@ namespace util {
     class array_queue {
     public:
         array_queue(size_t initCapacity = 8)
-        : _capacity(initCapacity),
-            _size(0),
-            _front(0),
-            _back(0),
-            _data(new T[_capacity]) {
+            : _capacity(initCapacity),
+              _size(0),
+              _front(0),
+              _back(0),
+              _data(std::make_unique<T[]>(_capacity)) {
             if (initCapacity == 0 || (initCapacity & (initCapacity - 1)) != 0) {
                 throw std::invalid_argument("initCapacity must be positive power of 2");
             }
         }
 
         ~array_queue() {
-            // todo
-            delete[] _data;
+            while (!empty()) {
+                pop();
+            }
         }
 
         void push(T&& value) {
@@ -56,20 +57,19 @@ namespace util {
         size_t _size;
         size_t _front;
         size_t _back;
-        T* _data;
+        std::unique_ptr<T[]> _data;
 
         void grow() {
             size_t newCapacity = _capacity * 2;
-            T* newData = new T[newCapacity];
+            auto newData = std::make_unique<T[]>(newCapacity);
 
-            std::move(_data + _front, _data + _capacity, newData);
-            std::move(_data, _data + _front, newData + (_capacity - _front));
+            std::move(_data.get() + _front, _data.get() + _capacity, newData.get());
+            std::move(_data.get(), _data.get() + _front, newData.get() + (_capacity - _front));
 
             _back = _size;
             _front = 0;
 
-            delete[] _data;
-            _data = newData;
+            _data.reset(newData.release());
             _capacity = newCapacity;
         }
     };

From bf7732f68a53d99c57a4e41d87a4f7fdc3c142d7 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Thu, 29 Jan 2026 19:52:47 +0300
Subject: [PATCH 18/20] reduce Chunks.getChunkByVoxel calls in LightSolver

---
 src/lighting/LightSolver.cpp | 27 +++++++++++++++++--------
 src/lighting/LightSolver.hpp |  3 ++-
 src/lighting/Lighting.cpp    | 38 +++++++++++++++++++-----------------
 src/voxels/Chunk.hpp         |  6 ++++++
 4 files changed, 47 insertions(+), 27 deletions(-)

diff --git a/src/lighting/LightSolver.cpp b/src/lighting/LightSolver.cpp
index b6091fdc5..f43b4d487 100644
--- a/src/lighting/LightSolver.cpp
+++ b/src/lighting/LightSolver.cpp
@@ -1,6 +1,3 @@
-#include <iostream>
-#include <assert.h>
-
 #include "LightSolver.hpp"
 #include "Lightmap.hpp"
 #include "content/Content.hpp"
@@ -9,6 +6,8 @@
 #include "voxels/voxel.hpp"
 #include "voxels/Block.hpp"
 
+#include <assert.h>
+
 LightSolver::LightSolver(const ContentIndices& contentIds, Chunks& chunks, int channel) 
     : blockDefs(contentIds.blocks.getDefs()),
       chunks(chunks), 
@@ -55,7 +54,7 @@ void LightSolver::remove(int x, int y, int z) {
     lightmap.set(x-chunk->x*CHUNK_W, y, z-chunk->z*CHUNK_D, channel, 0);
 }
 
-void LightSolver::solve() {
+void LightSolver::solve(Chunk* prevailingChunk) {
     const int coords[] = {
             0, 0, 1,
             0, 0,-1,
@@ -75,10 +74,16 @@ void LightSolver::solve() {
             int y = entry.y+coords[imul3+1];
             int z = entry.z+coords[imul3+2];
             
-            Chunk* chunk = chunks.getChunkByVoxel(x,y,z);
-            if (chunk == nullptr) {
+            Chunk* chunk = prevailingChunk;
+            if (chunk == nullptr || !chunk->isBlockInside(x, z)) {
+                chunk = chunks.getChunkByVoxel(x,y,z);
+                if (chunk == nullptr) {
+                    continue;
+                }
+            } else if (y < 0 || y >= CHUNK_H) {
                 continue;
             }
+
             int lx = x - chunk->x * CHUNK_W;
             int lz = z - chunk->z * CHUNK_D;
             chunk->flags.modified = true;
@@ -116,10 +121,16 @@ void LightSolver::solve() {
             int y = entry.y+coords[imul3+1];
             int z = entry.z+coords[imul3+2];
 
-            Chunk* chunk = chunks.getChunkByVoxel(x,y,z);
-            if (chunk == nullptr) {
+            Chunk* chunk = prevailingChunk;
+            if (chunk == nullptr || !chunk->isBlockInside(x, z)) {
+                chunk = chunks.getChunkByVoxel(x,y,z);
+                if (chunk == nullptr) {
+                    continue;
+                }
+            } else if (y < 0 || y >= CHUNK_H) {
                 continue;
             }
+
             assert(chunk->lightmap != nullptr);
             auto& lightmap = *chunk->lightmap;
             int lx = x - chunk->x * CHUNK_W;
diff --git a/src/lighting/LightSolver.hpp b/src/lighting/LightSolver.hpp
index 1e36a0e1d..31c33a804 100644
--- a/src/lighting/LightSolver.hpp
+++ b/src/lighting/LightSolver.hpp
@@ -2,6 +2,7 @@
 
 #include "util/array_queue.hpp"
 
+class Chunk;
 class Chunks;
 class ContentIndices;
 class Block;
@@ -25,5 +26,5 @@ public:
     void add(int x, int y, int z);
     void add(int x, int y, int z, int emission);
     void remove(int x, int y, int z);
-    void solve();
+    void solve(Chunk* prevailingChunk = nullptr);
 };
diff --git a/src/lighting/Lighting.cpp b/src/lighting/Lighting.cpp
index 9101c72ac..8f90540bb 100644
--- a/src/lighting/Lighting.cpp
+++ b/src/lighting/Lighting.cpp
@@ -167,10 +167,10 @@ void Lighting::onChunkLoaded(int cx, int cz, bool expand) {
             }
         }
     }
-    solverR.solve();
-    solverG.solve();
-    solverB.solve();
-    solverS.solve();
+    solverR.solve(chunk);
+    solverG.solve(chunk);
+    solverB.solve(chunk);
+    solverS.solve(chunk);
 }
 
 void Lighting::onBlockSet(int x, int y, int z, blockid_t id){
@@ -180,9 +180,10 @@ void Lighting::onBlockSet(int x, int y, int z, blockid_t id){
     solverB->remove(x,y,z);
 
     if (id == 0){
-        solverR->solve();
-        solverG->solve();
-        solverB->solve();
+        auto chunk = chunks.getChunkByVoxel(glm::ivec3{x, y, z});
+        solverR->solve(chunk);
+        solverG->solve(chunk);
+        solverB->solve(chunk);
         if (chunks.getLight(x,y+1,z, 3) == 0xF){
             for (int i = y; i >= 0; i--){
                 voxel* vox = chunks.get(x,i,z);
@@ -197,11 +198,12 @@ void Lighting::onBlockSet(int x, int y, int z, blockid_t id){
         solverR->add(x-1,y,z); solverG->add(x-1,y,z); solverB->add(x-1,y,z); solverS->add(x-1,y,z);
         solverR->add(x,y,z+1); solverG->add(x,y,z+1); solverB->add(x,y,z+1); solverS->add(x,y,z+1);
         solverR->add(x,y,z-1); solverG->add(x,y,z-1); solverB->add(x,y,z-1); solverS->add(x,y,z-1);
-        solverR->solve();
-        solverG->solve();
-        solverB->solve();
-        solverS->solve();
+        solverR->solve(chunk);
+        solverG->solve(chunk);
+        solverB->solve(chunk);
+        solverS->solve(chunk);
     } else {
+        auto chunk = chunks.getChunkByVoxel(glm::ivec3{x, y, z});
         if (!block.skyLightPassing){
             solverS->remove(x,y,z);
             for (int i = y-1; i >= 0; i--){
@@ -210,19 +212,19 @@ void Lighting::onBlockSet(int x, int y, int z, blockid_t id){
                     break;
                 }
             }
-            solverS->solve();
+            solverS->solve(chunk);
         }
-        solverR->solve();
-        solverG->solve();
-        solverB->solve();
+        solverR->solve(chunk);
+        solverG->solve(chunk);
+        solverB->solve(chunk);
 
         if (block.emission[0] || block.emission[1] || block.emission[2]){
             solverR->add(x,y,z,block.emission[0]);
             solverG->add(x,y,z,block.emission[1]);
             solverB->add(x,y,z,block.emission[2]);
-            solverR->solve();
-            solverG->solve();
-            solverB->solve();
+            solverR->solve(chunk);
+            solverG->solve(chunk);
+            solverB->solve(chunk);
         }
     }
 }
diff --git a/src/voxels/Chunk.hpp b/src/voxels/Chunk.hpp
index 5d45629ea..5377df020 100644
--- a/src/voxels/Chunk.hpp
+++ b/src/voxels/Chunk.hpp
@@ -83,4 +83,10 @@ public:
             glm::vec3((x + 1) * CHUNK_W, INFINITY, (z + 1) * CHUNK_D)
         );
     }
+
+    bool isBlockInside(int x, int z) const {
+        x -= this->x * CHUNK_W;
+        z -= this->z * CHUNK_D;
+        return x >= 0 && z >= 0 && x < CHUNK_W && z < CHUNK_D;
+    }
 };

From 0012419651c938896709a9a2c29355d192d44773 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Thu, 29 Jan 2026 20:30:38 +0300
Subject: [PATCH 19/20] test content events names cache

---
 src/content/ContentLoader.cpp     |  3 ++-
 src/items/ItemDef.hpp             |  5 +++++
 src/logic/scripting/scripting.cpp | 23 ++++++++++++++---------
 src/logic/scripting/scripting.hpp |  8 ++++++--
 src/voxels/Block.hpp              |  7 +++++++
 5 files changed, 34 insertions(+), 12 deletions(-)

diff --git a/src/content/ContentLoader.cpp b/src/content/ContentLoader.cpp
index e2bf81f2d..e2a463cac 100644
--- a/src/content/ContentLoader.cpp
+++ b/src/content/ContentLoader.cpp
@@ -441,7 +441,8 @@ static void load_script(const Content& content, T& def) {
             def.name,
             scriptfile,
             def.scriptFile,
-            def.rt.funcsset
+            def.rt.funcsset,
+            def.rt.eventNames
         );
     }
 }
diff --git a/src/items/ItemDef.hpp b/src/items/ItemDef.hpp
index ee37215a6..3f16e04b1 100644
--- a/src/items/ItemDef.hpp
+++ b/src/items/ItemDef.hpp
@@ -15,6 +15,9 @@ struct ItemFuncsSet {
     bool on_block_break_by : 1;
 };
 
+struct ItemFuncNamesCache {
+};
+
 enum class ItemIconType {
     NONE,    // invisible (core:empty) must not be rendered
     SPRITE,  // textured quad: icon is `atlas_name:texture_name`
@@ -75,6 +78,8 @@ struct ItemDef {
         bool emissive = false;
 
         std::set<int> tags;
+
+        ItemFuncNamesCache eventNames;
     } rt {};
 
     ItemDef(const std::string& name);
diff --git a/src/logic/scripting/scripting.cpp b/src/logic/scripting/scripting.cpp
index 4af1a4287..ca1ab3164 100644
--- a/src/logic/scripting/scripting.cpp
+++ b/src/logic/scripting/scripting.cpp
@@ -1,8 +1,5 @@
 #include "scripting.hpp"
 
-#include <iostream>
-#include <stdexcept>
-
 #include "scripting_commons.hpp"
 #include "content/Content.hpp"
 #include "content/ContentPack.hpp"
@@ -28,6 +25,9 @@
 #include "world/World.hpp"
 #include "interfaces/Process.hpp"
 
+#include <iostream>
+#include <stdexcept>
+
 using namespace scripting;
 
 static debug::Logger logger("scripting");
@@ -391,15 +391,15 @@ void scripting::on_blocks_tick(const Block& block, int tps) {
 }
 
 void scripting::update_block(const Block& block, const glm::ivec3& pos) {
-    std::string name = block.name + ".update";
-    lua::emit_event(lua::get_main_state(), name, [pos](auto L) {
+    lua::emit_event(lua::get_main_state(), block.rt.eventNames.update,
+    [pos](auto L) {
         return lua::pushivec_stack(L, pos);
     });
 }
 
 void scripting::random_update_block(const Block& block, const glm::ivec3& pos) {
-    std::string name = block.name + ".randupdate";
-    lua::emit_event(lua::get_main_state(), name, [pos](auto L) {
+    lua::emit_event(lua::get_main_state(), block.rt.eventNames.randomUpdate,
+    [pos](auto L) {
         return lua::pushivec_stack(L, pos);
     });
 }
@@ -660,7 +660,8 @@ void scripting::load_content_script(
     const std::string& prefix,
     const io::path& file,
     const std::string& fileName,
-    BlockFuncsSet& funcsset
+    BlockFuncsSet& funcsset,
+    BlockFuncNamesCache& namesCache
 ) {
     int env = *senv;
     lua::pop(lua::get_main_state(), load_script(env, "block", file, fileName));
@@ -686,6 +687,9 @@ void scripting::load_content_script(
         register_event(env, "on_block_present", prefix + ".blockpresent");
     funcsset.onblockremoved =
         register_event(env, "on_block_removed", prefix + ".blockremoved");
+
+    namesCache.randomUpdate = prefix + ".update";
+    namesCache.randomUpdate = prefix + ".randupdate";
 }
 
 void scripting::load_content_script(
@@ -693,7 +697,8 @@ void scripting::load_content_script(
     const std::string& prefix,
     const io::path& file,
     const std::string& fileName,
-    ItemFuncsSet& funcsset
+    ItemFuncsSet& funcsset,
+    ItemFuncNamesCache& namesCache
 ) {
     int env = *senv;
     lua::pop(lua::get_main_state(), load_script(env, "item", file, fileName));
diff --git a/src/logic/scripting/scripting.hpp b/src/logic/scripting/scripting.hpp
index 298130c99..64fa1a3d1 100644
--- a/src/logic/scripting/scripting.hpp
+++ b/src/logic/scripting/scripting.hpp
@@ -23,7 +23,9 @@ struct ItemDef;
 class Inventory;
 class UiDocument;
 struct BlockFuncsSet;
+struct BlockFuncNamesCache;
 struct ItemFuncsSet;
+struct ItemFuncNamesCache;
 struct WorldFuncsSet;
 struct UserComponent;
 struct uidocscript;
@@ -168,7 +170,8 @@ namespace scripting {
         const std::string& prefix,
         const io::path& file,
         const std::string& fileName,
-        BlockFuncsSet& funcsset
+        BlockFuncsSet& funcsset,
+        BlockFuncNamesCache& namesCache
     );
 
     /// @brief Load script associated with an Item
@@ -182,7 +185,8 @@ namespace scripting {
         const std::string& prefix,
         const io::path& file,
         const std::string& fileName,
-        ItemFuncsSet& funcsset
+        ItemFuncsSet& funcsset,
+        ItemFuncNamesCache& namesCache
     );
 
     /// @brief Load component script
diff --git a/src/voxels/Block.hpp b/src/voxels/Block.hpp
index 96620c8f9..99b9dee70 100644
--- a/src/voxels/Block.hpp
+++ b/src/voxels/Block.hpp
@@ -54,6 +54,11 @@ struct BlockFuncsSet {
     bool onblockremoved : 1;
 };
 
+struct BlockFuncNamesCache {
+    std::string update;
+    std::string randomUpdate;
+};
+
 struct CoordSystem {
     std::array<glm::ivec3, 3> axes;
     /// @brief Grid 3d position fix offset (for negative vectors)
@@ -296,6 +301,8 @@ public:
         blockid_t surfaceReplacement = 0;
 
         std::set<int> tags;
+
+        BlockFuncNamesCache eventNames;
     } rt {};
 
     Block(const std::string& name);

From 9c4c82376a5906775966bc36e35ece98f0389c32 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Thu, 29 Jan 2026 21:21:13 +0300
Subject: [PATCH 20/20] cleanup a bit

---
 src/lighting/Lighting.cpp | 32 ++++++++++++++++++++++----------
 1 file changed, 22 insertions(+), 10 deletions(-)

diff --git a/src/lighting/Lighting.cpp b/src/lighting/Lighting.cpp
index 8f90540bb..b17b6f333 100644
--- a/src/lighting/Lighting.cpp
+++ b/src/lighting/Lighting.cpp
@@ -192,16 +192,28 @@ void Lighting::onBlockSet(int x, int y, int z, blockid_t id){
                 solverS->add(x,i,z, 0xF);
             }
         }
-        solverR->add(x,y+1,z); solverG->add(x,y+1,z); solverB->add(x,y+1,z); solverS->add(x,y+1,z);
-        solverR->add(x,y-1,z); solverG->add(x,y-1,z); solverB->add(x,y-1,z); solverS->add(x,y-1,z);
-        solverR->add(x+1,y,z); solverG->add(x+1,y,z); solverB->add(x+1,y,z); solverS->add(x+1,y,z);
-        solverR->add(x-1,y,z); solverG->add(x-1,y,z); solverB->add(x-1,y,z); solverS->add(x-1,y,z);
-        solverR->add(x,y,z+1); solverG->add(x,y,z+1); solverB->add(x,y,z+1); solverS->add(x,y,z+1);
-        solverR->add(x,y,z-1); solverG->add(x,y,z-1); solverB->add(x,y,z-1); solverS->add(x,y,z-1);
-        solverR->solve(chunk);
-        solverG->solve(chunk);
-        solverB->solve(chunk);
-        solverS->solve(chunk);
+        const int coords[] = {
+            0, 0, 1,
+            0, 0,-1,
+            0, 1, 0,
+            0,-1, 0,
+            1, 0, 0,
+            -1, 0, 0
+        };
+        for (int i = 0; i < 6; i++) {
+            int lx = x + coords[i * 3];
+            int ly = y + coords[i * 3 + 1];
+            int lz = z + coords[i * 3 + 2];
+
+            solverR->add(lx, ly, lz);
+            solverG->add(lx, ly, lz);
+            solverB->add(lx, ly, lz);
+            solverS->add(lx, ly, lz);
+            solverR->solve(chunk);
+            solverG->solve(chunk);
+            solverB->solve(chunk);
+            solverS->solve(chunk);
+        }
     } else {
         auto chunk = chunks.getChunkByVoxel(glm::ivec3{x, y, z});
         if (!block.skyLightPassing){