diff --git a/.github/workflows/appimage.yml b/.github/workflows/appimage.yml
index 250fd001a..54046d33c 100644
--- a/.github/workflows/appimage.yml
+++ b/.github/workflows/appimage.yml
@@ -1,4 +1,4 @@
-name: C/C++ AppImage
+name: x86-64 AppImage
 
 on:
   push:
@@ -20,24 +20,33 @@ jobs:
       - uses: actions/checkout@v2
         with:
           submodules: 'true'
-      - name: install dependencies
+      - name: Install dependencies
         run: |
           sudo apt-get update
           sudo apt-get install -y build-essential libglfw3-dev libglfw3 libglew-dev \
-            libglm-dev libpng-dev libopenal-dev libluajit-5.1-dev libvorbis-dev libcurl4-openssl-dev cmake squashfs-tools
+            libglm-dev libpng-dev libopenal-dev libluajit-5.1-dev libvorbis-dev \
+            libcurl4-openssl-dev libgtest-dev cmake squashfs-tools valgrind
           # fix luajit paths
           sudo ln -s /usr/lib/x86_64-linux-gnu/libluajit-5.1.a /usr/lib/x86_64-linux-gnu/liblua5.1.a
           sudo ln -s /usr/include/luajit-2.1 /usr/include/lua
           # install EnTT
           git clone https://github.com/skypjack/entt.git
           cd entt/build
-          cmake -DCMAKE_BUILD_TYPE=Release ..
+          cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo ..
           sudo make install
           cd ../..
-      - name: configure
-        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DVOXELENGINE_BUILD_APPDIR=1
-      - name: build
+      - name: Configure
+        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo -DVOXELENGINE_BUILD_APPDIR=1 -DVOXELENGINE_BUILD_TESTS=ON
+      - name: Build
         run: cmake --build build -t install
+      - name: Run tests
+        run: ctest --test-dir build
+      - name: Run engine tests
+        timeout-minutes: 1
+        run: |
+            chmod +x build/VoxelEngine
+            chmod +x AppDir/usr/bin/vctest
+            AppDir/usr/bin/vctest -e build/VoxelEngine -d dev/tests -u build
       - name: Build AppImage
         uses: AppImageCrafters/build-appimage-action@fe2205a4d6056be47051f7b1b3811106e9814910
         env:
diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
index e4ddf55ab..2942ee9aa 100644
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@@ -39,6 +39,12 @@ jobs:
       - name: Run tests
         run: ctest --output-on-failure --test-dir build
 
+      - name: Run engine tests
+        timeout-minutes: 1
+        run: |
+          chmod +x build/VoxelEngine
+          chmod +x AppDir/usr/bin/vctest
+          AppDir/usr/bin/vctest -e build/VoxelEngine -d dev/tests -u build
       - name: Create DMG
         run: |
           mkdir VoxelEngineDmgContent
diff --git a/.github/workflows/windows-clang.yml b/.github/workflows/windows-clang.yml
new file mode 100644
index 000000000..7722ce4e8
--- /dev/null
+++ b/.github/workflows/windows-clang.yml
@@ -0,0 +1,70 @@
+name: Windows Build (CLang)
+
+on:
+  push:
+    branches: [ "main", "release-**"]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build-windows:
+
+    strategy:
+      matrix:
+        include:
+          - os: windows-latest
+            compiler: clang
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'true'
+      - uses: msys2/setup-msys2@v2
+        id: msys2
+        name: Setup MSYS2
+        with:
+            msystem: clang64
+            install: >-
+                mingw-w64-clang-x86_64-toolchain 
+                mingw-w64-clang-x86_64-cmake 
+                mingw-w64-clang-x86_64-make 
+                mingw-w64-clang-x86_64-luajit 
+                git
+      - name: Set up vcpkg
+        shell: msys2 {0}
+        run: |
+            git clone https://github.com/microsoft/vcpkg.git
+            cd vcpkg
+            ./bootstrap-vcpkg.bat
+            ./vcpkg integrate install
+            cd ..
+      - name: Configure project with CMake and vcpkg
+        shell: msys2 {0}
+        run: |
+            export VCPKG_DEFAULT_TRIPLET=x64-mingw-static
+            export VCPKG_DEFAULT_HOST_TRIPLET=x64-mingw-static
+            export VCPKG_ROOT=./vcpkg
+            mkdir build
+            cd build
+            cmake -G "MinGW Makefiles" -DVCPKG_TARGET_TRIPLET=x64-mingw-static -DCMAKE_BUILD_TYPE=Release -DCMAKE_TOOLCHAIN_FILE=./vcpkg/scripts/buildsystems/vcpkg.cmake ..
+            cmake --build . --config Release
+      - name: Package for Windows
+        run: |
+          mkdir packaged
+          mkdir packaged/res
+          cp build/VoxelEngine.exe packaged/
+          cp build/vctest/vctest.exe packaged/
+          cp build/*.dll packaged/
+          cp -r build/res/* packaged/res/
+          mv packaged/VoxelEngine.exe packaged/VoxelCore.exe
+      - uses: actions/upload-artifact@v4
+        with:
+          name: Windows-Build
+          path: 'packaged/*'
+      - name: Run engine tests
+        shell: msys2 {0}
+        working-directory: ${{ github.workspace }}
+        run: |
+          packaged/vctest.exe -e packaged/VoxelCore.exe -d dev/tests -u build
diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml
index b14c32d0c..3f7efc9c3 100644
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@@ -1,4 +1,4 @@
-name: Windows Build
+name: MSVC Build
 
 on:
   push:
@@ -21,29 +21,33 @@ jobs:
         with:
           submodules: 'true'
 
-      - name: Set up vcpkg
+      - name: Bootstrap vcpkg
+        shell: pwsh
         run: |
           git clone https://github.com/microsoft/vcpkg.git
-          cd vcpkg
-          .\bootstrap-vcpkg.bat
-          .\vcpkg integrate install
-          cd ..
+          ${{ github.workspace }}/vcpkg/bootstrap-vcpkg.bat
+
       - name: Configure and build project with CMake and vcpkg
+        env:
+          VCPKG_ROOT: ${{ github.workspace }}/vcpkg
+        run: |
+          cmake --preset default-vs-msvc-windows
+          cmake --build --preset default-vs-msvc-windows --config Release
+      - name: Run tests
+        run: ctest --preset default-vs-msvc-windows
+      - name: Run engine tests
         run: |
-          mkdir build
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=Release -DVOXELENGINE_BUILD_WINDOWS_VCPKG=ON -DVOXELENGINE_BUILD_TESTS=ON ..
-          cmake --build . --config Release
+            build/vctest/Release/vctest.exe -e build/Release/VoxelEngine.exe -d dev/tests -u build
+        timeout-minutes: 1
       - name: Package for Windows
         run: |
           mkdir packaged
-          cp -r build/* packaged/
-          cp C:/Windows/System32/msvcp140.dll packaged/Release/msvcp140.dll
-          mv packaged/Release/VoxelEngine.exe packaged/Release/VoxelCore.exe
+          cp -r build/Release/* packaged/
+          cp build/vctest/Release/vctest.exe packaged/
+          cp C:/Windows/System32/msvcp140.dll packaged/msvcp140.dll
+          mv packaged/VoxelEngine.exe packaged/VoxelCore.exe
         working-directory: ${{ github.workspace }}
-      - name: Run tests
-        run: ctest --output-on-failure --test-dir build
       - uses: actions/upload-artifact@v4
         with:
           name: Windows-Build
-          path: 'packaged/Release/*'
+          path: 'packaged/*'
diff --git a/.gitignore b/.gitignore
index a1ce6e33c..9056cce5b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -36,10 +36,6 @@ Debug/voxel_engine
 AppDir
 appimage-build/
 
-# for vcpkg
-/vcpkg/
-.gitmodules
-
 # macOS folder attributes
 *.DS_Store
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index a56457bd2..4b5c6fc84 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,18 +1,24 @@
-option(VOXELENGINE_BUILD_WINDOWS_VCPKG ON)
-if(VOXELENGINE_BUILD_WINDOWS_VCPKG AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/vcpkg/scripts/buildsystems/vcpkg.cmake")
-  set(CMAKE_TOOLCHAIN_FILE "${CMAKE_CURRENT_SOURCE_DIR}/vcpkg/scripts/buildsystems/vcpkg.cmake" CACHE STRING "")
-endif()
-
-cmake_minimum_required(VERSION 3.15)
+cmake_minimum_required(VERSION 3.26)
 project(VoxelEngine)
 
-option(VOXELENGINE_BUILD_APPDIR OFF)
-option(VOXELENGINE_BUILD_TESTS OFF)
+option(VOXELENGINE_BUILD_APPDIR "" OFF)
+option(VOXELENGINE_BUILD_TESTS "" OFF)
 
 set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
+  # We use two types linking: for clang build is static (vcpkg triplet x64-windows-static)
+  # and for msvc build is dynamic linking (vcpkg triplet x64-windows)
+  # By default CMAKE_MSVC_RUNTIME_LIBRARY set by MultiThreaded$<$<CONFIG:Debug>:Debug>DLL
+  if (VCPKG_TARGET_TRIPLET MATCHES "static")
+    set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+  endif()
+endif()
 
 add_subdirectory(src)
-add_executable(${PROJECT_NAME} src/voxel_engine.cpp)
+add_executable(${PROJECT_NAME} src/main.cpp)
 target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src)
 
 if(VOXELENGINE_BUILD_APPDIR)
@@ -24,7 +30,6 @@ if(MSVC)
       set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
     endif()
     if((CMAKE_BUILD_TYPE EQUAL "Release") OR (CMAKE_BUILD_TYPE EQUAL "RelWithDebInfo"))
-      set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Release>:Release>")
       target_compile_options(${PROJECT_NAME} PRIVATE /W4 /MT /O2)
     else()
       target_compile_options(${PROJECT_NAME} PRIVATE /W4)
@@ -39,31 +44,9 @@ else()
   if (CMAKE_BUILD_TYPE MATCHES "Debug")
     target_compile_options(${PROJECT_NAME} PRIVATE -Og)
   endif()
-endif()
-
-if(VOXELENGINE_BUILD_WINDOWS_VCPKG AND WIN32)
-  if(NOT EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/vcpkg/.git")
-    find_package(Git QUIET)
-    if(GIT_FOUND)
-      message(STATUS "Adding vcpkg as a git submodule...")
-      execute_process(COMMAND ${GIT_EXECUTABLE} submodule add https://github.com/microsoft/vcpkg.git vcpkg WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-    else()
-      message(FATAL_ERROR "Git not found, cannot add vcpkg submodule.")
-    endif()
-  endif()
-
-  if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/vcpkg/.git")
-    message(STATUS "Initializing and updating vcpkg submodule...")
-    execute_process(COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-    execute_process(COMMAND ${CMAKE_COMMAND} -E chdir vcpkg ./bootstrap-vcpkg.bat WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  if (WIN32)
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static")
   endif()
-
-  foreach(CONFIG_TYPE ${CMAKE_CONFIGURATION_TYPES})
-    string(TOUPPER ${CONFIG_TYPE} CONFIG_TYPE_UPPER)
-    add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
-                       COMMAND ${CMAKE_COMMAND} -E copy_directory
-                       ${CMAKE_SOURCE_DIR}/res ${CMAKE_BINARY_DIR}/${CONFIG_TYPE_UPPER}/res)
-  endforeach()
 endif()
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
@@ -76,9 +59,18 @@ endif()
 
 target_link_libraries(${PROJECT_NAME} VoxelEngineSrc ${CMAKE_DL_LIBS})
 
-file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/res DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+# Deploy res to build dir
+add_custom_command(
+  TARGET ${PROJECT_NAME} 
+  POST_BUILD 
+  COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different 
+          ${CMAKE_CURRENT_SOURCE_DIR}/res 
+          $<TARGET_FILE_DIR:${PROJECT_NAME}>/res
+  )
 
 if (VOXELENGINE_BUILD_TESTS)
     enable_testing()
     add_subdirectory(test)
-endif()
\ No newline at end of file
+endif()
+
+add_subdirectory(vctest)
diff --git a/CMakePresets.json b/CMakePresets.json
new file mode 100644
index 000000000..d4c6aa47f
--- /dev/null
+++ b/CMakePresets.json
@@ -0,0 +1,35 @@
+{
+    "version": 6,
+    "configurePresets": [
+        {
+            "name": "default-vs-msvc-windows",
+            "condition": {
+                "type": "equals",
+                "rhs": "${hostSystemName}",
+                "lhs": "Windows"
+            },
+            "generator": "Visual Studio 17 2022",
+            "binaryDir": "${sourceDir}/build",
+            "cacheVariables": {
+                "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
+                "VOXELENGINE_BUILD_TESTS": "ON"
+            }
+        }
+    ],
+    "buildPresets": [
+        {
+            "name": "default-vs-msvc-windows",
+            "configurePreset": "default-vs-msvc-windows",
+            "configuration": "Debug"
+        }
+    ],
+    "testPresets": [
+        {
+            "name": "default-vs-msvc-windows",
+            "configurePreset": "default-vs-msvc-windows",
+            "output": {
+                "outputOnFailure": true
+            }
+        }
+    ]
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index 418d372cb..e31e1436f 100644
--- a/README.md
+++ b/README.md
@@ -108,28 +108,32 @@ cmake --build .
 >[!NOTE]
 > Requirement:
 >
-> vcpkg, CMake
+> vcpkg, CMake, Git
+There are two options to use vcpkg:
+1. If you have Visual Studio installed, most likely the **VCPKG_ROOT** environment variable will already exist in **Developer Command Prompt for VS**
+2. If you want use **vcpkg**, install **vcpkg** from git to you system:
+```PowerShell
+cd C:/
+git clone https://github.com/microsoft/vcpkg.git
+cd vcpkg
+.\bootstrap-vcpkg.bat
+```
+After installing **vcpkg**, setup env variable **VCPKG_ROOT** and add it to **PATH**:
+```PowerShell
+$env:VCPKG_ROOT = "C:\path\to\vcpkg"
+$env:PATH = "$env:VCPKG_ROOT;$env:PATH"
+```
+>[!TIP]
+>For troubleshooting you can read full [documentation](https://learn.microsoft.com/ru-ru/vcpkg/get_started/get-started?pivots=shell-powershell) for **vcpkg**
 
-```sh
+After installing **vcpkg** you can build project:
+```PowerShell
 git clone --recursive https://github.com/MihailRis/VoxelEngine-Cpp.git
 cd VoxelEngine-Cpp
-mkdir build
-cd build
-cmake -DCMAKE_BUILD_TYPE=Release -DVOXELENGINE_BUILD_WINDOWS_VCPKG=ON ..
-del CMakeCache.txt
-rmdir /s /q CMakeFiles
-cmake -DCMAKE_BUILD_TYPE=Release -DVOXELENGINE_BUILD_WINDOWS_VCPKG=ON ..
-cmake --build . --config Release
+cmake --preset default-vs-msvc-windows
+cmake --build --preset default-vs-msvc-windows
 ```
 
-> [!TIP]
-> You can use ```rm CMakeCache.txt``` and ```rm -rf CMakeFiles``` while using Git Bash
-
-> [!WARNING]
-> If you have issues during the vcpkg integration, try navigate to ```vcpkg\downloads```
-> and extract PowerShell-[version]-win-x86 to ```vcpkg\downloads\tools``` as powershell-core-[version]-windows.
-> Then rerun ```cmake -DCMAKE_BUILD_TYPE=Release -DVOXELENGINE_BUILD_WINDOWS_VCPKG=ON ..```
-
 ## Build using Docker
 
 ### Step 0. Install docker on your system
diff --git a/dev/tests/base_entities.lua b/dev/tests/base_entities.lua
new file mode 100644
index 000000000..7b0e2e776
--- /dev/null
+++ b/dev/tests/base_entities.lua
@@ -0,0 +1,24 @@
+local util = require("core:tests_util")
+
+-- Create world and prepare settings
+util.create_demo_world("core:default")
+app.set_setting("chunks.load-distance", 3)
+app.set_setting("chunks.load-speed", 1)
+
+-- Create player
+local pid = player.create("Xerxes")
+player.set_spawnpoint(pid, 0, 100, 0)
+player.set_pos(pid, 0, 100, 0)
+
+-- Wait for chunk to load
+app.sleep_until(function () return block.get(0, 0, 0) ~= -1 end)
+
+-- Place a falling block
+block.place(0, 2, 0, block.index("base:sand"), 0, pid)
+app.tick()
+
+-- Check if the block is falling
+assert(block.get(0, 2, 0) == 0)
+
+-- Wait for the block to fall
+app.sleep_until(function () return block.get(0, 1, 0) == block.index("base:sand") end, 100)
diff --git a/dev/tests/chunks.lua b/dev/tests/chunks.lua
new file mode 100644
index 000000000..fcbaeb1ff
--- /dev/null
+++ b/dev/tests/chunks.lua
@@ -0,0 +1,30 @@
+local util = require "core:tests_util"
+util.create_demo_world()
+
+app.set_setting("chunks.load-distance", 3)
+app.set_setting("chunks.load-speed", 1)
+
+local pid1 = player.create("Xerxes")
+assert(player.get_name(pid1) == "Xerxes")
+
+local pid2 = player.create("Segfault")
+assert(player.get_name(pid2) == "Segfault")
+
+local seed = math.floor(math.random() * 1e6)
+print("random seed", seed)
+math.randomseed(seed)
+
+for i=1,25 do
+    if i % 5 == 0 then
+        print(tostring(i*4).." % done")
+        print("chunks loaded", world.count_chunks())
+    end
+    player.set_pos(pid1, math.random() * 100 - 50, 100, math.random() * 100 - 50)
+    player.set_pos(pid2, math.random() * 200 - 100, 100, math.random() * 200 - 100)
+    app.tick()
+end
+
+player.delete(pid2)
+
+app.close_world(true)
+app.delete_world("demo")
diff --git a/dev/tests/filesystem.lua b/dev/tests/filesystem.lua
new file mode 100644
index 000000000..a9ff58ce0
--- /dev/null
+++ b/dev/tests/filesystem.lua
@@ -0,0 +1,50 @@
+debug.log("check initial state")
+assert(file.exists("config:"))
+
+debug.log("write text file")
+assert(file.write("config:text.txt", "example, пример"))
+assert(file.exists("config:text.txt"))
+
+debug.log("read text file")
+assert(file.read("config:text.txt") == "example, пример")
+
+debug.log("delete file")
+file.remove("config:text.txt")
+assert(not file.exists("config:text.txt"))
+
+debug.log("create directory")
+file.mkdir("config:dir")
+assert(file.isdir("config:dir"))
+
+debug.log("remove directory")
+file.remove("config:dir")
+
+debug.log("create directories")
+file.mkdirs("config:dir/subdir/other")
+assert(file.isdir("config:dir/subdir/other"))
+
+debug.log("remove tree")
+file.remove_tree("config:dir")
+assert(not file.isdir("config:dir"))
+
+debug.log("write binary file")
+local bytes = {0xDE, 0xAD, 0xC0, 0xDE}
+file.write_bytes("config:binary", bytes)
+assert(file.exists("config:binary"))
+
+debug.log("read binary file")
+local rbytes = file.read_bytes("config:binary")
+assert(#rbytes == #bytes)
+for i, b in ipairs(bytes) do
+    assert(rbytes[i] == b)
+end
+
+debug.log("delete file")
+file.remove("config:binary")
+assert(not file.exists("config:binary"))
+
+debug.log("checking entry points for writeability")
+assert(file.is_writeable("config:"))
+assert(file.is_writeable("export:"))
+assert(not file.is_writeable("user:"))
+assert(not file.is_writeable("res:"))
diff --git a/dev/tests/world.lua b/dev/tests/world.lua
new file mode 100644
index 000000000..db1ffca53
--- /dev/null
+++ b/dev/tests/world.lua
@@ -0,0 +1,30 @@
+-- Create/close/open/close world
+
+-- Open
+app.reconfig_packs({"base"}, {})
+app.new_world("demo", "2019", "core:default")
+assert(world.is_open())
+assert(world.get_generator() == "core:default")
+app.sleep(1)
+assert(world.get_total_time() > 0.0)
+print(world.get_total_time())
+
+-- Close
+app.close_world(true)
+assert(not world.is_open())
+
+-- Reopen
+app.open_world("demo") 
+assert(world.is_open())
+assert(world.get_total_time() > 0.0)
+assert(world.get_seed() == 2019)
+app.tick()
+
+-- Remove base pack
+app.reconfig_packs({}, {"base"})
+-- World is reopened in post-runnable
+app.tick()
+
+-- Close
+app.close_world(true)
+app.delete_world("demo")
diff --git a/dev/valgrind.suppress b/dev/valgrind.suppress
new file mode 100644
index 000000000..7e12d4735
--- /dev/null
+++ b/dev/valgrind.suppress
@@ -0,0 +1,46 @@
+# Valgrind suppression file for VoxelCore
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Cond
+   obj:/usr/lib/x86_64-linux-gnu/libluajit-5.1.so.2.1.0
+   fun:lua_getfield
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Cond
+   obj:/usr/lib/x86_64-linux-gnu/libluajit-5.1.so.2.1.0
+   fun:lua_setfield
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Cond
+   obj:/usr/lib/x86_64-linux-gnu/libluajit-5.1.so.2.1.0
+   obj:/usr/lib/x86_64-linux-gnu/libluajit-5.1.so.2.1.0
+   obj:/usr/lib/x86_64-linux-gnu/libluajit-5.1.so.2.1.0
+   obj:/usr/lib/x86_64-linux-gnu/libluajit-5.1.so.2.1.0
+   fun:lua_loadx
+   fun:luaL_loadbufferx
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Cond
+   obj:/usr/lib/x86_64-linux-gnu/libluajit-5.1.so.2.1.0
+   fun:lua_pushstring
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Cond
+   obj:/usr/lib/x86_64-linux-gnu/libluajit-5.1.so.2.1.0
+   fun:lua_pushlstring
+}
+{
+   glewInit internal leak
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   obj:*
+   obj:*
+   fun:glXGetClientString
+   fun:glxewInit
+   fun:glewInit
+}
diff --git a/doc/en/block-properties.md b/doc/en/block-properties.md
index 87df173b6..f5478e0b7 100644
--- a/doc/en/block-properties.md
+++ b/doc/en/block-properties.md
@@ -213,3 +213,39 @@ User properties must be declared in `pack:config/user-props.toml` file:
 ```
 
 Example: [user properties of pack **base**](../../res/content/base/config/user-props.toml).
+
+## Properties introduced by the `base` pack
+
+### *base:durability*
+
+The time it takes to break a block without tools or effects, measured in seconds.
+
+### Loot - *base:loot*
+
+A list of tables with properties:
+
+```json
+{
+    "item": "pack:item",
+    "min": 1,
+    "max": 3,
+    "chance": 0.5
+}
+```
+
+- `count` defaults to 1. It does not need to be specified if `min` and `max` are provided.
+- `min`, `max` - the minimum and maximum quantity of the item.
+- `chance` - the probability of the item dropping. Defaults to 1.0.
+
+It should be noted that the `item` refers specifically to the item. That is, to specify the item of a block, you need to add `.item` after the block name. 
+Example: `base:dirt.item`.
+
+To generate loot, the function `block_loot(block_id: int)` in the `base:util` module should be used.
+
+## Methods
+
+Methods are used to manage the overwriting of properties when extending a block with other packs.
+
+### `property_name@append`
+
+Adds elements to the end of the list instead of completely overwriting it.
diff --git a/doc/en/scripting.md b/doc/en/scripting.md
index b00930f1f..fa45ec95f 100644
--- a/doc/en/scripting.md
+++ b/doc/en/scripting.md
@@ -9,9 +9,11 @@ Subsections:
 - [UI properties and methods](scripting/ui.md)
 - [Entities and components](scripting/ecs.md)
 - [Libraries](#)
+    - [app](scripting/builtins/libapp.md)
     - [base64](scripting/builtins/libbase64.md)
     - [bjson, json, toml](scripting/filesystem.md)
     - [block](scripting/builtins/libblock.md)
+    - [byteutil](scripting/builtins/libbyteutil.md)
     - [cameras](scripting/builtins/libcameras.md)
     - [entities](scripting/builtins/libentities.md)
     - [file](scripting/builtins/libfile.md)
@@ -20,6 +22,7 @@ Subsections:
     - [gfx.text3d](3d-text.md#gfxtext3d-library)
     - [gui](scripting/builtins/libgui.md)
     - [hud](scripting/builtins/libhud.md)
+    - [input](scripting/builtins/libinput.md)
     - [inventory](scripting/builtins/libinventory.md)
     - [item](scripting/builtins/libitem.md)
     - [mat4](scripting/builtins/libmat4.md)
diff --git a/doc/en/scripting/builtins/libapp.md b/doc/en/scripting/builtins/libapp.md
new file mode 100644
index 000000000..e3fed3d4b
--- /dev/null
+++ b/doc/en/scripting/builtins/libapp.md
@@ -0,0 +1,147 @@
+# *app* library
+
+A library for high-level engine control, available only in script or test mode.
+
+The script/test name without the path and extension is available as `app.script`. The file path can be obtained as:
+```lua
+local filename = "script:"..app.script..".lua"
+```
+
+## Functions
+
+```lua
+app.tick()
+```
+
+Performs one tick of the main engine loop.
+
+```lua
+app.sleep(time: number)
+```
+
+Waits for the specified time in seconds, performing the main engine loop.
+
+```lua
+app.sleep_until(
+    -- function that checks the condition for ending the wait
+    predicate: function() -> bool,
+    -- the maximum number of engine loop ticks after which
+    -- a "max ticks exceed" exception will be thrown
+    [optional] max_ticks = 1e9
+)
+```
+
+Waits for the condition checked by the function to be true, performing the main engine loop.
+
+```lua
+app.quit()
+```
+
+Terminates the engine, printing the call stack to trace the function call location.
+
+```lua
+app.reconfig_packs(
+    -- packs to add
+    add_packs: table,
+    -- packs to remove
+    remove_packs: table
+)
+```
+
+Updates the packs configuration, checking its correctness (dependencies and availability of packs).
+Automatically adds dependencies.
+
+To remove all packs from the configuration, you can use `pack.get_installed()`:
+
+```lua
+app.reconfig_packs({}, pack.get_installed())
+```
+
+In this case, `base` will also be removed from the configuration.
+
+```lua
+app.config_packs(
+    -- expected set of packs (excluding dependencies)
+    packs: table
+)
+```
+
+Updates the packs configuration, automatically removing unspecified ones, adding those missing in the previous configuration.
+Uses app.reconfig_packs.
+
+```lua
+app.new_world(
+    -- world name
+    name: str,
+    -- generation seed
+    seed: str,
+    -- generator name
+    generator: str
+)
+```
+
+Creates a new world and opens it.
+
+```lua
+app.open_world(name: str)
+```
+
+Opens a world by name.
+
+```lua
+app.reopen_world()
+```
+
+Reopens the world.
+
+```lua
+app.save_world()
+```
+
+Saves the world.
+
+```lua
+app.close_world(
+    -- save the world before closing
+    [optional] save_world: bool=false
+)
+```
+
+Closes the world.
+
+```lua
+app.delete_world(name: str)
+```
+
+Deletes a world by name.
+
+```lua
+app.get_version() -> int, int
+```
+
+Returns the major and minor versions of the engine.
+
+```lua
+app.get_setting(name: str) -> value
+```
+
+Returns the value of a setting. Throws an exception if the setting does not exist.
+
+```lua
+app.set_setting(name: str, value: value)
+```
+
+Sets the value of a setting. Throws an exception if the setting does not exist.
+
+```lua
+app.get_setting_info(name: str) -> {
+    -- default value
+    def: value,
+    -- minimum value
+    [only for numeric settings] min: number,
+    -- maximum value
+    [only for numeric settings] max: number
+}
+```
+
+Returns a table with information about a setting. Throws an exception if the setting does not exist.
diff --git a/doc/en/scripting/builtins/libblock.md b/doc/en/scripting/builtins/libblock.md
index 5bd0536e2..61ea0edf5 100644
--- a/doc/en/scripting/builtins/libblock.md
+++ b/doc/en/scripting/builtins/libblock.md
@@ -67,12 +67,15 @@ Following three functions return direction vectors based on block rotation.
 -- Returns X: integer direction vector of the block at specified coordinates.
 -- Example: no rotation: 1, 0, 0.
 block.get_X(x: int, y: int, z: int) -> int, int, int
+block.get_X(id: int, rotation: int) -> int, int, int
 
 -- Same for axis Y. Default: 0, 1, 0.
 block.get_Y(x: int, y: int, z: int) -> int, int, int
+block.get_Y(id: int, rotation: int) -> int, int, int
 
 -- Same for axis Z. Default: 0, 0, 1.
 block.get_Z(x: int, y: int, z: int) -> int, int, int
+block.get_Z(id: int, rotation: int) -> int, int, int
 
 -- Returns block rotation index based on used profile.
 block.get_rotation(x: int, y: int, z: int) -> int
diff --git a/doc/en/scripting/builtins/libbyteutil.md b/doc/en/scripting/builtins/libbyteutil.md
new file mode 100644
index 000000000..c0cf72d07
--- /dev/null
+++ b/doc/en/scripting/builtins/libbyteutil.md
@@ -0,0 +1,70 @@
+# *byteutil* library
+
+The library provides functions for working with byte arrays represented as tables or Bytearrays.
+
+```lua
+byteutil.pack(format: str, ...) -> Bytearray
+byteutil.tpack(format: str, ...) -> table
+```
+
+Returns a byte array containing the provided values packed according to the format string. The arguments must exactly match the values required by the format.
+
+The format string consists of special characters and value characters.
+
+Special characters specify the byte order for the subsequent values:
+
+| Character | Byte Order          |
+| --------- | ------------------- |
+| `@`       | System              |
+| `=`       | System              |
+| `<`       | Little-endian       |
+| `>`       | Big-endian          |
+| `!`       | Network (big-endian)|
+
+
+Value characters describe the type and size.
+
+| Character | C++ Equivalent | Lua Type | Size    |
+| --------- | -------------- | -------- | ------- |
+| `b`       | int8_t         | number   | 1 byte  |
+| `B`       | uint8_t        | number   | 1 byte  |
+| `?`       | bool           | boolean  | 1 byte  |
+| `h`       | int16_t        | number   | 2 bytes |
+| `H`       | uint16_t       | number   | 2 bytes |
+| `i`       | int32_t        | number   | 4 bytes |
+| `I`       | uint32_t       | number   | 4 bytes |
+| `l`       | int64_t        | number   | 8 bytes |
+| `L`       | uint64_t       | number   | 8 bytes |
+
+> [!WARNING]
+> Due to the absence of an integer type in Lua for values `l` and `L`, only an output size of 8 bytes is guaranteed; the value may differ from what is expected.
+
+```lua
+byteutil.unpack(format: str, bytes: table|Bytearray) -> ...
+```
+
+Extracts values ​​from a byte array based on a format string.
+
+Example:
+
+```lua
+debug.print(byteutil.tpack('>iBH?', -8, 250, 2019, true))
+-- outputs:
+-- debug.print(
+--  {
+--    255,
+--    255,
+--    255,
+--    248,
+--    250,
+--    7,
+--    227,
+--    1
+--  }
+-- )
+
+local bytes = byteutil.pack('>iBH?', -8, 250, 2019, true)
+print(byteutil.unpack('>iBH?', bytes))
+-- outputs:
+--  -8      250     2019    true
+```
diff --git a/doc/en/scripting/builtins/libfile.md b/doc/en/scripting/builtins/libfile.md
index fe02bed18..9f1754d7d 100644
--- a/doc/en/scripting/builtins/libfile.md
+++ b/doc/en/scripting/builtins/libfile.md
@@ -25,6 +25,12 @@ file.read_bytes(path: str) -> array of integers
 
 Read file into bytes array.
 
+```lua
+file.is_writeable(path: str) -> bool
+```
+
+Checks if the specified path is writable.
+
 ```python
 file.write(path: str, text: str) -> nil
 ```
@@ -114,3 +120,27 @@ file.read_combined_object(path: str) -> array
 ```
 
 Combines objects from JSON files of different packs.
+
+```lua
+file.name(path: str) --> str
+```
+
+Extracts the file name from the path. Example: `world:data/base/config.toml` -> `config.toml`.
+
+``lua
+file.stem(path: str) --> str
+```
+
+Extracts the file name from the path, removing the extension. Example: `world:data/base/config.toml` -> `config`.
+
+```lua
+file.ext(path: str) --> str
+```
+
+Extracts the extension from the path. Example: `world:data/base/config.toml` -> `toml`.
+
+```lua
+file.prefix(path: str) --> str
+```
+
+Extracts the entry point (prefix) from the path. Example: `world:data/base/config.toml` -> `world`.
diff --git a/doc/en/scripting/builtins/libgui.md b/doc/en/scripting/builtins/libgui.md
index 3132bce3c..64b5005be 100644
--- a/doc/en/scripting/builtins/libgui.md
+++ b/doc/en/scripting/builtins/libgui.md
@@ -61,3 +61,34 @@ gui.escape_markup(
 ```
 
 Escapes markup in text.
+
+```lua
+gui.confirm(
+    -- message (does not translate automatically, use gui.str(...))
+    message: str,
+    -- function called upon confirmation
+    on_confirm: function() -> nil,
+    -- function called upon denial/cancellation
+    [optional] on_deny: function() -> nil,
+    -- text for the confirmation button (default: "Yes")
+    -- use an empty string for the default value if you want to specify no_text.
+    [optional] yes_text: str,
+    -- text for the denial button (default: "No")
+    [optional] no_text: str,
+)
+```
+
+Requests confirmation from the user for an action. **Does not** stop code execution.
+
+```lua
+gui.load_document(
+    -- Path to the xml file of the page. Example: `core:layouts/pages/main.xml`
+    path: str,
+    -- Name (id) of the document. Example: `core:pages/main`
+    name: str
+    -- Table of parameters passed to the on_open event
+    args: table
+) --> str
+```
+
+Loads a UI document with its script, returns the name of the document if successfully loaded.
diff --git a/doc/en/scripting/builtins/libinput.md b/doc/en/scripting/builtins/libinput.md
new file mode 100644
index 000000000..02f2a8d08
--- /dev/null
+++ b/doc/en/scripting/builtins/libinput.md
@@ -0,0 +1,89 @@
+# *input* library
+
+```lua
+input.keycode(keyname: str) --> int
+```
+
+Returns key code or -1 if unknown
+
+```lua
+input.mousecode(mousename: str) --> int
+```
+
+Returns mouse button code or -1 if unknown
+
+```lua
+input.add_callback(bindname: str, callback: function)
+```
+
+Add binding activation callback. Example:
+
+```lua
+input.add_callback("hud.inventory", function ()
+	print("Inventory open key pressed")
+end)
+```
+
+Callback may be added to a key.
+
+```lua
+input.add_callback("key:space", function ()
+    print("Space pressed")
+end)
+```
+
+You can also bind the function lifetime to the UI container instead of the HUD. 
+In that case, `input.add_callback` may be used until the `on_hud_open` is called.
+
+```lua
+input.add_callback("key:escape", function ()
+    print("NO")
+    return true -- prevents previously assigned functions from being called
+end, document.root)
+```
+
+```lua
+input.get_mouse_pos() --> {int, int}
+```
+
+Returns cursor screen position.
+
+```lua
+input.get_bindings() --> strings array
+```
+
+Returns all binding names.
+
+```lua
+input.get_binding_text(bindname: str) --> str
+```
+
+Returns text representation of button by binding name.
+
+```lua
+input.is_active(bindname: str) --> bool
+```
+
+Checks if the binding is active.
+
+```lua
+input.set_enabled(bindname: str, flag: bool)
+```
+
+Enables/disables binding until leaving the world.
+
+```lua
+input.is_pressed(code: str) --> bool
+```
+
+Checks input activity using a code consisting of:
+- input type: *key* or *mouse*
+- input code: [key name](#key names) or mouse button name (left, middle, right)
+
+Example:
+```lua
+if input.is_pressed("key:enter") then
+    ...
+end
+```
+
diff --git a/doc/en/scripting/builtins/libinventory.md b/doc/en/scripting/builtins/libinventory.md
index ccb7be20d..a3f3632fb 100644
--- a/doc/en/scripting/builtins/libinventory.md
+++ b/doc/en/scripting/builtins/libinventory.md
@@ -32,6 +32,21 @@ inventory.size(invid: int) -> int
 -- Returns remaining count if could not to add fully.
 inventory.add(invid: int, itemid: int, count: int) -> int
 
+-- Returns the index of the first matching slot in the given range.
+-- If no matching slot was found, returns nil
+inventory.find_by_item(
+    -- inventory id
+    invid: int,
+    -- item id
+    itemid: int,
+    -- [optional] index of the slot range start (from 0)
+    range_begin: int,
+    -- [optional] index of the slot range end (from 0)
+    range_end: int,
+    -- [optional] minimum item count in the slot
+    min_count: int = 1
+) -> int
+
 -- Returns block inventory ID or 0.
 inventory.get_block(x: int, y: int, z: int) -> int
 
diff --git a/doc/en/scripting/builtins/libnetwork.md b/doc/en/scripting/builtins/libnetwork.md
index 48caefbdc..cb24e7bf7 100644
--- a/doc/en/scripting/builtins/libnetwork.md
+++ b/doc/en/scripting/builtins/libnetwork.md
@@ -16,6 +16,11 @@ end)
 
 -- A variant for binary files, with a byte array instead of a string in the response.
 network.get_binary(url: str, callback: function(table|ByteArray))
+
+-- Performs a POST request to the specified URL.
+-- Currently, only `Content-Type: application/json` is supported
+-- After receiving the response, passes the text to the callback function.
+network.post(url: str, data: table, callback: function(str))
 ```
 
 ## TCP Connections
@@ -54,6 +59,9 @@ socket:recv(
 -- Closes the connection
 socket:close()
 
+-- Returns the number of data bytes available for reading
+socket:available() --> int
+
 -- Checks that the socket exists and is not closed.
 socket:is_alive() --> bool
 
diff --git a/doc/en/scripting/builtins/libpack.md b/doc/en/scripting/builtins/libpack.md
index 0fbc4b158..35b11088c 100644
--- a/doc/en/scripting/builtins/libpack.md
+++ b/doc/en/scripting/builtins/libpack.md
@@ -76,14 +76,15 @@ pack.get_base_packs() -> strings array
 
 Returns the id of all base packages (non-removeable)
 
-```python
+```lua
 pack.get_info(packid: str) -> {
   id: str,
   title: str,
   creator: str,
   description: str,
   version: str,
-  icon: str,
+  path: str,
+  icon: str, -- not available in headless mode
   dependencies: optional strings array
 }
 ```
@@ -95,3 +96,15 @@ Returns information about the pack (not necessarily installed).
   - `?` - optional
   - `~` - weak
   for example `!teal`
+
+To obtain information about multiple packs, use table of ids to avoid re-scanning:one
+
+```lua
+pack.get_info(packids: table) -> {id={...}, id2={...}, ...}
+```
+
+```lua
+pack.assemble(packis: table) -> table
+```
+
+Checks the configuration for correctness and adds dependencies, returning the complete configuration.
diff --git a/doc/en/scripting/builtins/libplayer.md b/doc/en/scripting/builtins/libplayer.md
index b43bf8607..041bf4423 100644
--- a/doc/en/scripting/builtins/libplayer.md
+++ b/doc/en/scripting/builtins/libplayer.md
@@ -1,5 +1,17 @@
 # *player* library
 
+```lua
+player.create(name: str) -> int
+```
+
+Creates a player and returns id.
+
+```lua
+player.delete(id: int)
+```
+
+Deletes a player by id.
+
 ```lua
 player.get_pos(playerid: int) -> number, number, number
 ```
@@ -70,6 +82,13 @@ player.set_instant_destruction(playerid: int, bool)
 
 Getter and setter for instant destruction of blocks when the `player.destroy` binding is activated.
 
+```lua
+player.is_loading_chunks(playerid: int) -> bool
+player.set_loading_chunks(playerid: int, bool)
+```
+
+Getter and setter of the property that determines whether the player is loading chunks.
+
 ``` lua
 player.set_spawnpoint(playerid: int, x: number, y: number, z: number)
 player.get_spawnpoint(playerid: int) -> number, number, number
@@ -84,6 +103,12 @@ player.get_name(playerid: int) -> str
 
 Player name setter and getter
 
+```lua
+player.set_selected_slot(playerid: int, slotid: int)
+```
+
+Sets the selected slot index
+
 ```lua
 player.get_selected_block(playerid: int) -> x,y,z
 ```
diff --git a/doc/en/scripting/builtins/libworld.md b/doc/en/scripting/builtins/libworld.md
index 5bf01abb0..fc18773e5 100644
--- a/doc/en/scripting/builtins/libworld.md
+++ b/doc/en/scripting/builtins/libworld.md
@@ -36,14 +36,15 @@ world.get_seed() -> int
 -- Returns generator name.
 world.get_generator() -> str
 
--- Proves that this is the current time during the day 
--- from 0.333(8 am) to 0.833(8 pm).
-world.is_day() -> boolean
+-- Checks the existence of a world by name.
+world.exists(name: str) -> bool
+
+-- Checks if the current time is daytime. From 0.333(8am) to 0.833(8pm).
+world.is_day() -> bool
 
--- Checks that it is the current time at night
--- from 0.833(8 pm) to 0.333(8 am).
+-- Checks if the current time is nighttime. From 0.833(8pm) to 0.333(8am).
 world.is_night() -> bool
 
--- Checks the existence of a world by name.
-world.exists() -> bool
+-- Returns the total number of chunks loaded into memory
+world.count_chunks() -> int
 ```
diff --git a/doc/en/scripting/ui.md b/doc/en/scripting/ui.md
index c990a1977..5013b4487 100644
--- a/doc/en/scripting/ui.md
+++ b/doc/en/scripting/ui.md
@@ -48,6 +48,7 @@ Properties that apply to all elements:
 | tooltip       | string | yes  | yes   | tooltip text                                |
 | tooltipDelay  | float  | yes  | yes   | tooltip delay                               |
 | contentOffset | vec2   | yes  | *no*  | element content offset                      |
+| cursor        | string | yes  | yes   | cursor displayed on hover                   |
 
 Common element methods:
 
diff --git a/doc/en/scripting/user-input.md b/doc/en/scripting/user-input.md
index 402f9e67b..d8a6e4e8e 100644
--- a/doc/en/scripting/user-input.md
+++ b/doc/en/scripting/user-input.md
@@ -25,70 +25,4 @@ packid.binding.name="inputtype:codename"
 
 ## *input* library
 
-```python
-input.keycode(keyname: str) -> int
-```
-
-Returns key code or -1 if unknown
-
-```python
-input.mousecode(mousename: str) -> int
-```
-
-Returns mouse button code or -1 if unknown
-
-```python
-input.add_callback(bindname: str, callback: function)
-```
-
-Add binding activation callback. Example:
-```lua
-input.add_callback("hud.inventory", function ()
-	print("Inventory open key pressed")
-end)
-```
-
-```python
-input.get_mouse_pos() -> {int, int}
-```
-
-Returns cursor screen position.
-
-```python
-input.get_bindings() -> strings array
-```
-
-Returns all binding names.
-
-```python
-input.get_binding_text(bindname: str) -> str
-```
-
-Returns text representation of button by binding name.
-
-```python
-input.is_active(bindname: str) -> bool
-```
-
-Checks if the binding is active.
-
-```python
-input.set_enabled(bindname: str, flag: bool)
-```
-
-Enables/disables binding until leaving the world.
-
-```python
-input.is_pressed(code: str) -> bool
-```
-
-Checks input activity using a code consisting of:
-- input type: *key* or *mouse*
-- input code: [key name](#key names) or mouse button name (left, middle, right)
-
-Example:
-```lua
-if input.is_pressed("key:enter") then
-    ...
-end
-```
+See [*input* library](builtins/libinput.md)
diff --git a/doc/en/xml-ui-layouts.md b/doc/en/xml-ui-layouts.md
index e70086825..3f0bff071 100644
--- a/doc/en/xml-ui-layouts.md
+++ b/doc/en/xml-ui-layouts.md
@@ -44,6 +44,7 @@ Examples:
 - `gravity` - automatic positioning of the element in the container. (Does not work in automatic containers like panel). Values: *top-left, top-center, top-right, center-left, center-center, center-right, bottom-left, bottom-center, bottom-right*.
 - `z-index` - determines the order of elements, with a larger value it will overlap elements with a smaller one.
 - `interactive` - if false, hovering over the element and all sub-elements will be ignored.
+- `cursor` - the cursor displayed when hovering over the element (arrow/text/pointer/crosshair/ew-resize/ns-resize/...).
 
 # Template attributes
 
diff --git a/doc/ru/block-properties.md b/doc/ru/block-properties.md
index 2f958e889..3b75759eb 100644
--- a/doc/ru/block-properties.md
+++ b/doc/ru/block-properties.md
@@ -224,3 +224,39 @@
 ```
 
 Пример: [пользовательские свойства пака **base**](../../res/content/base/config/user-props.toml).
+
+## Свойства, вводимые паком `base`
+
+### Прочность - *base:durability*
+
+Время разрушения блока без инструментов и эффектов в секундах.
+
+### Лут - *base:loot*
+
+Список таблиц со свойствами:
+
+```json
+{
+    "item": "пак:предмет",
+    "min": 1,
+    "max": 3,
+    "chance": 0.5
+}
+```
+
+- count равен 1 по-умолчанию. Не нужно указывать если указаны `min` и `max`.
+- min, max - минимальное и максимальное количество предмета.
+- chance - вероятность выпадения предмета. По-умолчанию: 1.0.
+
+Следует учитывать, что в item указывается именно предмет. Т.е. чтобы указать предмет блока, нужно добавить `.item` после имени блока.
+Пример: `base:dirt.item`.
+
+Для генерации лута следует использовать функцию `block_loot(block_id: int)` в модуле `base:util`.
+
+## Методы
+
+Методы используются для управлением перезаписью свойств при расширении блока другими паками.
+
+### `имя_свойства@append`
+
+Добавляет элементы в конец списка, вместо его полной перезаписи.
diff --git a/doc/ru/scripting.md b/doc/ru/scripting.md
index 63191ea83..e9fe3c50a 100644
--- a/doc/ru/scripting.md
+++ b/doc/ru/scripting.md
@@ -9,9 +9,11 @@
 - [Свойства и методы UI элементов](scripting/ui.md)
 - [Сущности и компоненты](scripting/ecs.md)
 - [Библиотеки](#)
+    - [app](scripting/builtins/libapp.md)
     - [base64](scripting/builtins/libbase64.md)
     - [bjson, json, toml](scripting/filesystem.md)
     - [block](scripting/builtins/libblock.md)
+    - [byteutil](scripting/builtins/libbyteutil.md)
     - [cameras](scripting/builtins/libcameras.md)
     - [entities](scripting/builtins/libentities.md)
     - [file](scripting/builtins/libfile.md)
@@ -20,6 +22,7 @@
     - [gfx.text3d](3d-text.md#библиотека-gfxtext3d)
     - [gui](scripting/builtins/libgui.md)
     - [hud](scripting/builtins/libhud.md)
+    - [input](scripting/builtins/libinput.md)
     - [inventory](scripting/builtins/libinventory.md)
     - [item](scripting/builtins/libitem.md)
     - [mat4](scripting/builtins/libmat4.md)
diff --git a/doc/ru/scripting/builtins/libapp.md b/doc/ru/scripting/builtins/libapp.md
new file mode 100644
index 000000000..7887bcdf6
--- /dev/null
+++ b/doc/ru/scripting/builtins/libapp.md
@@ -0,0 +1,148 @@
+# Библиотека *app*
+
+Библиотека для высокоуровневого управления работой движка, доступная только в режиме сценария или теста.
+
+Имя сценария/теста без пути и расширения доступен как `app.script`. Путь к файлу можно получить как:
+```lua
+local filename = "script:"..app.script..".lua"
+```
+
+## Функции
+
+```lua
+app.tick()
+```
+
+Выполняет один такт основного цикла движка.
+
+```lua
+app.sleep(time: number)
+```
+
+Ожидает указанное время в секундах, выполняя основной цикл движка.
+
+```lua
+app.sleep_until(
+    -- функция, проверяющее условия завершения ожидания
+    predicate: function() -> bool,
+    -- максимальное количество тактов цикла движка, после истечения которых
+    -- будет брошено исключение "max ticks exceed"
+    [опционально] max_ticks = 1e9
+)
+```
+
+Ожидает истинности утверждения (условия), проверяемого функцией, выполнячя основной цикл движка.
+
+```lua
+app.quit()
+```
+
+Завершает выполнение движка, выводя стек вызовов для ослеживания места вызова функции.
+
+```lua
+app.reconfig_packs(
+    -- добавляемые паки
+    add_packs: table,
+    -- удаляемые паки
+    remove_packs: table
+)
+```
+
+Обновляет конфигурацию паков, проверяя её корректность (зависимости и доступность паков).
+Автоматически добавляет зависимости.
+
+Для удаления всех паков из конфигурации можно использовать `pack.get_installed()`:
+
+```lua
+app.reconfig_packs({}, pack.get_installed())
+```
+
+В этом случае из конфигурации будет удалён и `base`.
+
+```lua
+app.config_packs(
+    -- ожидаемый набор паков (без учёта зависимостей)
+    packs: table
+)
+```
+
+Обновляет конфигурацию паков, автоматически удаляя лишние, добавляя отсутствующие в прошлой конфигурации.
+Использует app.reconfig_packs.
+
+```lua
+app.new_world(
+    -- название мира
+    name: str,
+    -- зерно генерации
+    seed: str,
+    -- название генератора
+    generator: str
+)
+```
+
+Создаёт новый мир и открывает его.
+
+```lua
+app.open_world(name: str)
+```
+
+Открывает мир по названию.
+
+```lua
+app.reopen_world()
+```
+
+Переоткрывает мир.
+
+```lua
+app.save_world()
+```
+
+Сохраняет мир.
+
+```lua
+app.close_world(
+    -- сохранить мир перед закрытием
+    [опционально] save_world: bool=false
+)
+```
+
+Закрывает мир.
+
+```lua
+app.delete_world(name: str)
+```
+
+Удаляет мир по названию.
+
+```lua
+app.get_version() -> int, int
+```
+
+Возвращает мажорную и минорную версии движка.
+
+```lua
+app.get_setting(name: str) -> value
+```
+
+Возвращает значение настройки. Бросает исключение, если настройки не существует.
+
+```lua
+app.set_setting(name: str, value: value)
+```
+
+Устанавливает значение настройки. Бросает исключение, если настройки не существует.
+
+
+```lua
+app.get_setting_info(name: str) -> {
+    -- значение по-умолчанию
+    def: value
+    -- минимальное значение
+    [только числовые настройки] min: number,
+    -- максимальное значение
+    [только числовые настройки] max: number
+}
+```
+
+Возвращает таблицу с информацией о настройке. Бросает исключение, если настройки не существует.
diff --git a/doc/ru/scripting/builtins/libblock.md b/doc/ru/scripting/builtins/libblock.md
index 19a28198c..5cb149e39 100644
--- a/doc/ru/scripting/builtins/libblock.md
+++ b/doc/ru/scripting/builtins/libblock.md
@@ -90,12 +90,15 @@ block.raycast(start: vec3, dir: vec3, max_distance: number, [опциональ
 -- Возвращает целочисленный единичный вектор X блока на указанных координатах с учётом его вращения (три целых числа).
 -- Если поворот отсутствует, возвращает 1, 0, 0
 block.get_X(x: int, y: int, z: int) -> int, int, int
+block.get_X(id: int, rotation: int) -> int, int, int
 
 -- То же, но для оси Y (по-умолчанию 0, 1, 0)
 block.get_Y(x: int, y: int, z: int) -> int, int, int
+block.get_Y(id: int, rotation: int) -> int, int, int
 
 -- То же, но для оси Z (по-умолчанию 0, 0, 1)
 block.get_Z(x: int, y: int, z: int) -> int, int, int
+block.get_Z(id: int, rotation: int) -> int, int, int
 
 -- Возвращает индекс поворота блока в его профиле вращения (не превышает 7).
 block.get_rotation(x: int, y: int, z: int) -> int
diff --git a/doc/ru/scripting/builtins/libbyteutil.md b/doc/ru/scripting/builtins/libbyteutil.md
new file mode 100644
index 000000000..2c675594e
--- /dev/null
+++ b/doc/ru/scripting/builtins/libbyteutil.md
@@ -0,0 +1,71 @@
+# Библиотека *byteutil*
+
+Библиотека предоставляет функции для работы с массивами байт, представленными в виде таблиц или Bytearray.
+
+```lua
+byteutil.pack(format: str, ...) -> Bytearray
+byteutil.tpack(format: str, ...) -> table
+```
+
+Возвращает массив байт, содержащий переданные значения, упакованные в соответствии со строкой формата. Аргументы должны точно соответствовать значениям, требуемым форматом.
+
+Строка формата состоит из специальных символов и символов значений.
+
+Специальные символы позволяют указать порядок байт для последующих значений:
+
+| Символ | Порядок байт         |
+| ------ | -------------------- |
+| `@`    | Системный            |
+| `=`    | Системный            |
+| `<`    | Little-endian        |
+| `>`    | Big-endian           |
+| `!`    | Сетевой (big-endian) |
+
+
+Символы значений описывают тип и размер.
+
+| Символ | Аналог в С++ | Тип Lua  | Размер  |
+| ------ | ------------ | -------- | ------- |
+| `b`    | int8_t       | number   | 1 байт  |
+| `B`    | uint8_t      | number   | 1 байт  |
+| `?`    | bool         | boolean  | 1 байт  |
+| `h`    | int16_t      | number   | 2 байта |
+| `H`    | uint16_t     | number   | 2 байта |
+| `i`    | int32_t      | number   | 4 байта |
+| `I`    | uint32_t     | number   | 4 байта |
+| `l`    | int64_t      | number   | 8 байта |
+| `L`    | uint64_t     | number   | 8 байта |
+
+> [!WARNING]
+> Из-за отсутствия в Lua целочисленного типа для значений `l` и `L` гарантируется
+> только выходной размер в 8 байт, значение может отличаться от ожидаемого.
+
+```lua
+byteutil.unpack(format: str, bytes: table|Bytearray) -> ...
+```
+
+Извлекает значения из массива байт, ориентируясь на строку формата.
+
+Пример:
+
+```lua
+debug.print(byteutil.tpack('>iBH?', -8, 250, 2019, true))
+-- выводит:
+-- debug.print(
+--  {
+--    255,
+--    255,
+--    255,
+--    248,
+--    250,
+--    7,
+--    227,
+--    1
+--  }
+-- )
+
+local bytes = byteutil.pack('>iBH?', -8, 250, 2019, true)
+debug.print(byteutil.unpack('>iBH?', bytes))
+-- выводит:
+--  -8      250     2019    true
+```
diff --git a/doc/ru/scripting/builtins/libfile.md b/doc/ru/scripting/builtins/libfile.md
index a9a9c273c..45ca462c1 100644
--- a/doc/ru/scripting/builtins/libfile.md
+++ b/doc/ru/scripting/builtins/libfile.md
@@ -25,6 +25,12 @@ file.read_bytes(путь: str) -> array of integers
 
 Читает файл в массив байт.
 
+```lua
+file.is_writeable(путь: str) -> bool
+```
+
+Проверяет, доступно ли право записи по указанному пути.
+
 ```python
 file.write(путь: str, текст: str) -> nil
 ```
@@ -114,3 +120,27 @@ file.read_combined_object(путь: str) -> массив
 ```
 
 Совмещает объекты из JSON файлов разных паков.
+
+```lua
+file.name(путь: str) --> str
+```
+
+Извлекает имя файла из пути. Пример: `world:data/base/config.toml` -> `config.toml`.
+
+```lua
+file.stem(путь: str) --> str
+```
+
+Извлекает имя файла из пути, удаляя расширение. Пример: `world:data/base/config.toml` -> `config`.
+
+```lua
+file.ext(путь: str) --> str
+```
+
+Извлекает расширение из пути. Пример: `world:data/base/config.toml` -> `toml`.
+
+```lua
+file.prefix(путь: str) --> str
+```
+
+Извлекает точку входа (префикс) из пути. Пример: `world:data/base/config.toml` -> `world`.
diff --git a/doc/ru/scripting/builtins/libgui.md b/doc/ru/scripting/builtins/libgui.md
index 11dfde034..66e67809e 100644
--- a/doc/ru/scripting/builtins/libgui.md
+++ b/doc/ru/scripting/builtins/libgui.md
@@ -58,3 +58,34 @@ gui.escape_markup(
 ```
 
 Экранирует разметку в тексте.
+
+```lua
+gui.confirm(
+    -- сообщение (не переводится автоматически, используйте gui.str(...))
+    message: str,
+    -- функция, вызываемая при подтвержении
+    on_confirm: function() -> nil,
+    -- функция, вызываемая при отказе/отмене
+    [опционально] on_deny: function() -> nil,
+    -- текст кнопки подтвержения (по-умолчанию: "Да")
+    -- используйте пустую строку для значения по-умолчанию, если нужно указать no_text.
+    [опционально] yes_text: str,
+    -- текст кнопки отказа (по-умолчанию: "Нет")
+    [опционально] no_text: str,
+)
+```
+
+Запрашивает у пользователя подтверждение действия. **Не** останавливает выполнение кода.
+
+```lua
+gui.load_document(
+    -- Путь к xml файлу страницы. Пример: `core:layouts/pages/main.xml`
+    path: str,
+    -- Имя (id) документа. Пример: `core:pages/main`
+    name: str
+    -- Таблица параметров, передаваемых в событие on_open
+    args: table
+) --> str
+```
+
+Загружает UI документ с его скриптом, возвращает имя документа, если успешно загружен.
diff --git a/doc/ru/scripting/builtins/libinput.md b/doc/ru/scripting/builtins/libinput.md
new file mode 100644
index 000000000..afe22ee62
--- /dev/null
+++ b/doc/ru/scripting/builtins/libinput.md
@@ -0,0 +1,88 @@
+# Библиотека *input*
+
+```lua
+input.keycode(keyname: str) --> int
+```
+
+Возвращает код клавиши по имени, либо -1
+
+```lua
+input.mousecode(mousename: str) --> int
+```
+
+Возвращает код кнопки мыши по имени, либо -1
+
+```lua
+input.add_callback(bindname: str, callback: function)
+```
+
+Назначает функцию, которая будет вызываться при активации привязки. Пример:
+
+```lua
+input.add_callback("hud.inventory", function ()
+    print("Inventory open key pressed")
+end)
+```
+
+Можно назначить функцию на нажатие клавиши.
+
+```lua
+input.add_callback("key:space", function ()
+    print("Space pressed")
+end)
+```
+
+Также можно привязать время жизни функции к UI контейнеру, вместо HUD.
+В таком случае, `input.add_callback` можно использовать до вызова `on_hud_open`.
+
+```lua
+input.add_callback("key:escape", function ()
+    print("NO")
+    return true -- предотвращает вызов назначенных ранее функций
+end, document.root)
+```
+
+```lua
+input.get_mouse_pos() --> {int, int}
+```
+
+Возвращает позицию курсора на экране.
+
+```lua
+input.get_bindings() --> массив строк
+```
+
+Возвращает названия всех доступных привязок.
+
+```lua
+input.get_binding_text(bindname: str) --> str
+```
+
+Возвращает текстовое представление кнопки по имени привязки.
+
+```lua
+input.is_active(bindname: str) --> bool
+```
+
+Проверяет активность привязки.
+
+```lua
+input.set_enabled(bindname: str, flag: bool)
+```
+
+Включает/выключает привязку до выхода из мира.
+
+```lua
+input.is_pressed(code: str) --> bool
+```
+
+Проверяет активность ввода по коду, состоящему из:
+- типа ввода: key (клавиша) или mouse (кнопка мыши)
+- код ввода: [имя клавиши](#имена-клавиш) или имя кнопки мыши (left, middle, right)
+
+Пример: 
+```lua
+if input.is_pressed("key:enter") then
+    ...
+end
+```
diff --git a/doc/ru/scripting/builtins/libinventory.md b/doc/ru/scripting/builtins/libinventory.md
index 7f3cf26e5..a01bd9177 100644
--- a/doc/ru/scripting/builtins/libinventory.md
+++ b/doc/ru/scripting/builtins/libinventory.md
@@ -38,6 +38,21 @@ inventory.add(
     count: int
 ) -> int
 
+-- Возвращает индекс первого подходящего под критерии слота в заданном диапазоне.
+-- Если подходящий слот не был найден, возвращает nil
+inventory.find_by_item(
+    -- id инвентаря
+    invid: int,
+    -- id предмета
+    itemid: int,
+    -- [опционально] индекс начала диапазона слотов (c 0)
+    range_begin: int,
+    -- [опционально] индекс конца диапазона слотов (c 0)
+    range_end: int,
+    -- [опционально] минимальное количество предмета в слоте
+    min_count: int = 1
+) -> int
+
 -- Функция возвращает id инвентаря блока.
 -- Если блок не может иметь инвентарь - возвращает 0.
 inventory.get_block(x: int, y: int, z: int) -> int
diff --git a/doc/ru/scripting/builtins/libnetwork.md b/doc/ru/scripting/builtins/libnetwork.md
index 7fedf2bd8..657ad7cf3 100644
--- a/doc/ru/scripting/builtins/libnetwork.md
+++ b/doc/ru/scripting/builtins/libnetwork.md
@@ -16,6 +16,11 @@ end)
 
 -- Вариант для двоичных файлов, с массивом байт вместо строки в ответе.
 network.get_binary(url: str, callback: function(table|ByteArray))
+
+-- Выполняет POST запрос к указанному URL.
+-- На данный момент реализована поддержка только `Content-Type: application/json`
+-- После получения ответа, передаёт текст в функцию callback.
+network.post(url: str, data: table, callback: function(str))
 ```
 
 ## TCP-Соединения
@@ -54,6 +59,9 @@ socket:recv(
 -- Закрывает соединение
 socket:close()
 
+-- Возвращает количество доступных для чтения байт данных
+socket:available() --> int
+
 -- Проверяет, что сокет существует и не закрыт.
 socket:is_alive() --> bool
 
diff --git a/doc/ru/scripting/builtins/libpack.md b/doc/ru/scripting/builtins/libpack.md
index 543ea7a35..7b3a03c12 100644
--- a/doc/ru/scripting/builtins/libpack.md
+++ b/doc/ru/scripting/builtins/libpack.md
@@ -63,14 +63,15 @@ pack.get_base_packs() -> массив строк
 
 Возвращает id всех базовых паков (неудаляемых)
 
-```python
+```lua
 pack.get_info(packid: str) -> {
 	id: str,
 	title: str,
 	creator: str,
 	description: str,
 	version: str,
-	icon: str,
+    path: str,
+	icon: str, -- отсутствует в headless режиме
 	dependencies: опциональный массив строк
 }
 ```
@@ -82,3 +83,16 @@ pack.get_info(packid: str) -> {
 	- `?` - optional
 	- `~` - weak
 	например `!teal`
+
+Для получения информации о нескольких паках используйте таблицу id, чтобы не
+производить сканирование для каждого пака:
+
+```lua
+pack.get_info(packids: table) -> {id={...}, id2={...}, ...}
+```
+
+```lua
+pack.assemble(packis: table) -> table
+```
+
+Проверяет корректность конфигурации и добавляет зависимости, возвращая полную.
diff --git a/doc/ru/scripting/builtins/libplayer.md b/doc/ru/scripting/builtins/libplayer.md
index 284f725a5..a96620157 100644
--- a/doc/ru/scripting/builtins/libplayer.md
+++ b/doc/ru/scripting/builtins/libplayer.md
@@ -1,5 +1,17 @@
 # Библиотека *player*
 
+```lua
+player.create(name: str) -> int
+```
+
+Создаёт игрока и возвращает его id.
+
+```lua
+player.delete(id: int)
+```
+
+Удаляет игрока по id.
+
 ```lua
 player.get_pos(playerid: int) -> number, number, number
 ```
@@ -70,6 +82,13 @@ player.set_instant_destruction(playerid: int, bool)
 
 Геттер и сеттер мнгновенного разрушения блоков при активации привязки `player.destroy`.
 
+```lua
+player.is_loading_chunks(playerid: int) -> bool
+player.set_loading_chunks(playerid: int, bool)
+```
+
+Геттер и сеттер свойства, определяющего, прогружает ли игрок чанки вокруг.
+
 ```lua
 player.set_spawnpoint(playerid: int, x: number, y: number, z: number) 
 player.get_spawnpoint(playerid: int) -> number, number, number
@@ -84,6 +103,12 @@ player.get_name(playerid: int) -> str
 
 Сеттер и геттер имени игрока
 
+```lua
+player.set_selected_slot(playerid: int, slotid: int)
+```
+
+Устанавливает индекс выбранного слота
+
 ```lua
 player.get_selected_block(playerid: int) -> x,y,z
 ```
diff --git a/doc/ru/scripting/builtins/libworld.md b/doc/ru/scripting/builtins/libworld.md
index 9d7d635ea..0467d784c 100644
--- a/doc/ru/scripting/builtins/libworld.md
+++ b/doc/ru/scripting/builtins/libworld.md
@@ -36,11 +36,14 @@ world.get_seed() -> int
 world.get_generator() -> str
 
 -- Проверяет существование мира по имени.
-world.exists() -> bool
+world.exists(name: str) -> bool
 
 -- Проверяет является ли текущее время днём. От 0.333(8 утра) до 0.833(8 вечера).
 world.is_day() -> bool
 
 -- Проверяет является ли текущее время ночью. От 0.833(8 вечера) до 0.333(8 утра).
 world.is_night() -> bool
+
+-- Возвращает общее количество загруженных в память чанков
+world.count_chunks() -> int
 ```
diff --git a/doc/ru/scripting/ui.md b/doc/ru/scripting/ui.md
index 07d93013e..3c203d37a 100644
--- a/doc/ru/scripting/ui.md
+++ b/doc/ru/scripting/ui.md
@@ -48,6 +48,7 @@ document["worlds-panel"]:clear()
 | tooltip       | string | да     | да     | текст всплывающей подсказки               |
 | tooltipDelay  | float  | да     | да     | задержка всплывающей подсказки            |
 | contentOffset | vec2   | да     | *нет*  | смещение содержимого                      |
+| cursor        | string | да     | да     | курсор, отображаемый при наведении        |
 
 Общие методы элементов:
 
diff --git a/doc/ru/scripting/user-input.md b/doc/ru/scripting/user-input.md
index 686d962b2..ffcadd27c 100644
--- a/doc/ru/scripting/user-input.md
+++ b/doc/ru/scripting/user-input.md
@@ -23,70 +23,4 @@ packid.binding.name="inputtype:codename"
 
 ## Библиотека input
 
-```python
-input.keycode(keyname: str) -> int
-```
-
-Возвращает код клавиши по имени, либо -1
-
-```python
-input.mousecode(mousename: str) -> int
-```
-
-Возвращает код кнопки мыши по имени, либо -1
-
-```python
-input.add_callback(bindname: str, callback: function)
-```
-
-Назначает функцию, которая будет вызываться при активации привязки. Пример:
-```lua
-input.add_callback("hud.inventory", function ()
-	print("Inventory open key pressed")
-end)
-```
-
-```python
-input.get_mouse_pos() -> {int, int}
-```
-
-Возвращает позицию курсора на экране.
-
-```python
-input.get_bindings() -> массив строк
-```
-
-Возвращает названия всех доступных привязок.
-
-```python
-input.get_binding_text(bindname: str) -> str
-```
-
-Возвращает текстовое представление кнопки по имени привязки.
-
-```python
-input.is_active(bindname: str) -> bool
-```
-
-Проверяет активность привязки.
-
-```python
-input.set_enabled(bindname: str, flag: bool)
-```
-
-Включает/выключает привязку до выхода из мира.
-
-```python
-input.is_pressed(code: str) -> bool
-```
-
-Проверяет активность ввода по коду, состоящему из:
-- типа ввода: key (клавиша) или mouse (кнопка мыши)
-- код ввода: [имя клавиши](#имена-клавиш) или имя кнопки мыши (left, middle, right)
-
-Пример: 
-```lua
-if input.is_pressed("key:enter") then
-    ...
-end
-```
+См. [библиотека *input*](builtins/libinput.md)
diff --git a/doc/ru/xml-ui-layouts.md b/doc/ru/xml-ui-layouts.md
index 1ad93c4fa..f562ee4cb 100644
--- a/doc/ru/xml-ui-layouts.md
+++ b/doc/ru/xml-ui-layouts.md
@@ -48,6 +48,7 @@
 - `gravity` - автоматическое позиционирование элемента в контейнере. (Не работает в автоматических контейнерах, как panel). Значения: *top-left, top-center, top-right, center-left, center-center, center-right, bottom-left, bottom-center, bottom-right*.
 - `z-index` - определяет порядок элементов, при большем значении будет перекрывать элементы с меньшим.
 - `interactive` - при значении false наведение на элемент и все под-элементы будет игнорироваться.
+- `cursor` - курсор, отображаемый при наведении на элемент (arrow/text/pointer/crosshair/ew-resize/ns-resize/...).
 
 # Атрибуты шаблонов
 
diff --git a/res/content/base/blocks/bazalt.json b/res/content/base/blocks/bazalt.json
index bb941a812..8c431da67 100644
--- a/res/content/base/blocks/bazalt.json
+++ b/res/content/base/blocks/bazalt.json
@@ -1,4 +1,5 @@
 {
     "texture": "bazalt",
-    "breakable": false
+    "breakable": false,
+    "base:durability": 1e9
 }
diff --git a/res/content/base/blocks/grass.json b/res/content/base/blocks/grass.json
index 7308d1a17..e55bc2ac3 100644
--- a/res/content/base/blocks/grass.json
+++ b/res/content/base/blocks/grass.json
@@ -9,5 +9,6 @@
     "grounded": true,
     "model": "X",
     "hitbox": [0.15, 0.0, 0.15, 0.7, 0.7, 0.7],
-    "base:durability": 0.0
+    "base:durability": 0.0,
+    "base:loot": []
 }
diff --git a/res/content/base/blocks/grass_block.json b/res/content/base/blocks/grass_block.json
index a6087afcf..e89a774c0 100644
--- a/res/content/base/blocks/grass_block.json
+++ b/res/content/base/blocks/grass_block.json
@@ -8,5 +8,8 @@
         "grass_side",
         "grass_side"
     ],
-    "base:durability": 1.3
+    "base:durability": 1.3,
+    "base:loot": [
+        {"item": "base:dirt.item"}
+    ]
 }
diff --git a/res/content/base/config/user-props.toml b/res/content/base/config/user-props.toml
index b7306ba1c..eab7a628b 100644
--- a/res/content/base/config/user-props.toml
+++ b/res/content/base/config/user-props.toml
@@ -1 +1,2 @@
 "base:durability" = {}
+"base:loot" = {}
diff --git a/res/content/base/modules/util.lua b/res/content/base/modules/util.lua
index 2112c2105..d12337fbe 100644
--- a/res/content/base/modules/util.lua
+++ b/res/content/base/modules/util.lua
@@ -11,4 +11,34 @@ function util.drop(ppos, itemid, count, pickup_delay)
     }})
 end
 
+local function calc_loot(loot_table)
+    local results = {}
+    for _, loot in ipairs(loot_table) do
+        local chance = loot.chance or 1
+        local count = loot.count or 1
+        
+        local roll = math.random()
+        
+        if roll < chance then
+            if loot.min and loot.max then
+                count = math.random(loot.min, loot.max)
+            end
+            if count == 0 then
+                goto continue
+            end
+            table.insert(results, {item=item.index(loot.item), count=count})
+        end
+        ::continue::
+    end
+    return results
+end
+
+function util.block_loot(blockid)
+    local lootscheme = block.properties[blockid]["base:loot"]
+    if lootscheme then
+        return calc_loot(lootscheme)
+    end
+    return {{item=block.get_picking_item(blockid), count=1}}
+end
+
 return util
diff --git a/res/content/base/scripts/components/falling_block.lua b/res/content/base/scripts/components/falling_block.lua
index f650b6f79..483e86aee 100644
--- a/res/content/base/scripts/components/falling_block.lua
+++ b/res/content/base/scripts/components/falling_block.lua
@@ -3,17 +3,32 @@ local body = entity.rigidbody
 local rig = entity.skeleton
 
 local blockid = ARGS.block
+local blockstates = ARGS.states or 0
 if SAVED_DATA.block then
     blockid = SAVED_DATA.block
+    blockstates = SAVED_DATA.states or 0
 else
     SAVED_DATA.block = blockid
+    SAVED_DATA.states = blockstates
 end
 
 do -- setup visuals
-    local textures = block.get_textures(block.index(blockid))
+    local id = block.index(blockid)
+    local rotation = block.decompose_state(blockstates)[1]
+    local textures = block.get_textures(id)
     for i,t in ipairs(textures) do
         rig:set_texture("$"..tostring(i-1), "blocks:"..textures[i])
     end
+    local axisX = {block.get_X(id, rotation)}
+    local axisY = {block.get_Y(id, rotation)}
+    local axisZ = {block.get_Z(id, rotation)}
+    local matrix = {
+        axisX[1], axisX[2], axisX[3], 0,
+        axisY[1], axisY[2], axisY[3], 0,
+        axisZ[1], axisZ[2], axisZ[3], 0,
+        0, 0, 0, 1
+    }
+    rig:set_matrix(0, matrix)
 end
 
 function on_grounded()
@@ -22,7 +37,7 @@ function on_grounded()
     local iy = math.floor(pos[2])
     local iz = math.floor(pos[3])
     if block.is_replaceable_at(ix, iy, iz) then
-        block.place(ix, iy, iz, block.index(blockid), 0)
+        block.place(ix, iy, iz, block.index(blockid), blockstates)
     else
         local picking_item = block.get_picking_item(block.index(blockid))
         local drop = entities.spawn("base:drop", pos, {base__drop={id=picking_item, count=1}})
diff --git a/res/content/base/scripts/world.lua b/res/content/base/scripts/world.lua
index 62d111ae3..4b78a3f1d 100644
--- a/res/content/base/scripts/world.lua
+++ b/res/content/base/scripts/world.lua
@@ -1,12 +1,16 @@
 function on_block_broken(id, x, y, z, playerid)
-    gfx.particles.emit({x+0.5, y+0.5, z+0.5}, 64, {
-        lifetime=1.0,
-        spawn_interval=0.0001,
-        explosion={4, 4, 4},
-        texture="blocks:"..block.get_textures(id)[1],
-        random_sub_uv=0.1,
-        size={0.1, 0.1, 0.1},
-        spawn_shape="box",
-        spawn_spread={0.4, 0.4, 0.4}
-    })
+    if gfx then
+        gfx.particles.emit({x+0.5, y+0.5, z+0.5}, 64, {
+            lifetime=1.0,
+            spawn_interval=0.0001,
+            explosion={4, 4, 4},
+            texture="blocks:"..block.get_textures(id)[1],
+            random_sub_uv=0.1,
+            size={0.1, 0.1, 0.1},
+            spawn_shape="box",
+            spawn_spread={0.4, 0.4, 0.4}
+        })
+    end
+
+    rules.create("do-loot-non-player", true)
 end
diff --git a/res/layouts/pages/content.xml.lua b/res/layouts/pages/content.xml.lua
index d03c6e80e..0eae8c009 100644
--- a/res/layouts/pages/content.xml.lua
+++ b/res/layouts/pages/content.xml.lua
@@ -99,8 +99,14 @@ function refresh()
         end
     end
 
+    local packids = {unpack(packs_installed)}
+    for i,k in ipairs(packs_available) do
+        table.insert(packids, k)
+    end
+    local packinfos = pack.get_info(packids)
+
     for i,id in ipairs(packs_installed) do
-        local packinfo = pack.get_info(id)
+        local packinfo = packinfos[id]
         packinfo.index = i
         callback = not table.has(base_packs, id) and string.format('move_pack("%s")', id) or nil
         packinfo.error = check_dependencies(packinfo)
@@ -108,7 +114,7 @@ function refresh()
     end
 
     for i,id in ipairs(packs_available) do
-        local packinfo = pack.get_info(id)
+        local packinfo = packinfos[id]
         packinfo.index = i
         callback = string.format('move_pack("%s")', id)
         packinfo.error = check_dependencies(packinfo)
diff --git a/res/layouts/pages/content_menu.xml.lua b/res/layouts/pages/content_menu.xml.lua
index 6d730340b..3a1cea300 100644
--- a/res/layouts/pages/content_menu.xml.lua
+++ b/res/layouts/pages/content_menu.xml.lua
@@ -247,8 +247,9 @@ function refresh()
     local contents = document.contents
     contents:clear()
 
+    local packinfos = pack.get_info(packs_installed)
     for i, id in ipairs(packs_installed) do
-        local packinfo = pack.get_info(id)
+        local packinfo = packinfos[id]
 
         packinfo.id = id
         packs_installed[i] = {packinfo.id, packinfo.title}
diff --git a/res/layouts/pages/main.xml b/res/layouts/pages/main.xml
index 9c562fb44..a39606661 100644
--- a/res/layouts/pages/main.xml
+++ b/res/layouts/pages/main.xml
@@ -1,5 +1,6 @@
 <panel size='400' color='0' interval='1' context='menu'>
     <button onclick='menu.page="worlds"'>@Worlds</button>
+    <button onclick='menu.page="scripts"'>@Scripts</button>
     <button onclick='menu.page="settings"'>@Settings</button>
     <button onclick='menu.page="content_menu"'>@Contents Menu</button>
     <button onclick='core.quit()'>@Quit</button>
diff --git a/res/layouts/pages/scripts.xml b/res/layouts/pages/scripts.xml
new file mode 100644
index 000000000..d5c448038
--- /dev/null
+++ b/res/layouts/pages/scripts.xml
@@ -0,0 +1,12 @@
+<panel size='400' color='#00000030' context='menu'>
+    <container size='400,32'>
+        <label pos='2,10'>@Scripts</label>
+        <image onclick='refresh()' interactive='true' src='gui/refresh' 
+            size='32' gravity='top-right'
+            color='#FFFFFF80' hover-color='#FFFFFF10'/>
+    </container>
+    <panel id="list" size='400' interval='1' color='0' max-length='300'>
+        <!-- content is generated in script -->
+    </panel>
+    <button onclick='menu:back()'>@Back</button>
+</panel>
diff --git a/res/layouts/pages/scripts.xml.lua b/res/layouts/pages/scripts.xml.lua
new file mode 100644
index 000000000..259792b82
--- /dev/null
+++ b/res/layouts/pages/scripts.xml.lua
@@ -0,0 +1,40 @@
+function run_script(path)
+    debug.log("starting application script "..path)
+
+    local code = file.read(path)
+    local chunk, err = loadstring(code, path)
+    if chunk == nil then
+        error(err)
+    end
+    setfenv(chunk, setmetatable({app=__vc_app}, {__index=_G}))
+    start_coroutine(chunk, path)
+end
+
+function refresh()
+    document.list:clear()
+    
+    local available = pack.get_available()
+    local infos = pack.get_info(available)
+    for _, name in ipairs(available) do
+        local info = infos[name]
+        local scripts_dir = info.path.."/scripts/app"
+        if not file.exists(scripts_dir) then
+            goto continue
+        end
+        local files = file.list(scripts_dir)
+        for _, filename in ipairs(files) do
+            if file.ext(filename) == "lua" then
+                document.list:add(gui.template("script", {
+                    pack=name,
+                    name=file.stem(filename),
+                    path=filename
+                }))
+            end
+        end
+        ::continue::
+    end
+end
+
+function on_open()
+    refresh()
+end
diff --git a/res/layouts/templates/script.xml b/res/layouts/templates/script.xml
new file mode 100644
index 000000000..1ef770d8d
--- /dev/null
+++ b/res/layouts/templates/script.xml
@@ -0,0 +1,3 @@
+<button color='#10305080' hover-color='#10305040' onclick='run_script("%{path}")'>
+    %{name} [%{pack}]
+</button>
diff --git a/res/modules/bit_converter.lua b/res/modules/bit_converter.lua
index 71161eff1..b72dc3114 100644
--- a/res/modules/bit_converter.lua
+++ b/res/modules/bit_converter.lua
@@ -13,15 +13,15 @@ local MAX_INT64 = 9223372036854775807
 local MIN_INT64 = -9223372036854775808
 
 local function maskHighBytes(num)
-	return bit.band(num, 0xFF)
+    return bit.band(num, 0xFF)
 end
 
 local function reverse(tbl)
-	  for i=1, math.floor(#tbl / 2) do
-	    local tmp = tbl[i]
-	    tbl[i] = tbl[#tbl - i + 1]
-	    tbl[#tbl - i + 1] = tmp
-	  end
+      for i=1, math.floor(#tbl / 2) do
+        local tmp = tbl[i]
+        tbl[i] = tbl[#tbl - i + 1]
+        tbl[#tbl - i + 1] = tmp
+      end
     return tbl
 end
 
@@ -29,60 +29,60 @@ local orders = { "LE", "BE" }
 
 local fromLEConvertors =
 {
-		LE = function(bytes) return bytes end,
-		BE = function(bytes) return reverse(bytes) end
+        LE = function(bytes) return bytes end,
+        BE = function(bytes) return reverse(bytes) end
 }
 
 local toLEConvertors =
 {
-		LE = function(bytes) return bytes end,
-		BE = function(bytes) return reverse(bytes) end
+        LE = function(bytes) return bytes end,
+        BE = function(bytes) return reverse(bytes) end
 }
 
-bit_converter.default_order = "LE"
+bit_converter.default_order = "BE"
 
 local function fromLE(bytes, orderTo)
-	if orderTo then
-		bit_converter.validate_order(orderTo)
-		return fromLEConvertors[orderTo](bytes)
-	else return bytes end
+    if orderTo then
+        bit_converter.validate_order(orderTo)
+        return fromLEConvertors[orderTo](bytes)
+    else return bytes end
 end
 
 local function toLE(bytes, orderFrom)
-	if orderFrom then
-		bit_converter.validate_order(orderFrom)
-		return toLEConvertors[orderFrom](bytes)
-	else return bytes end
+    if orderFrom then
+        bit_converter.validate_order(orderFrom)
+        return toLEConvertors[orderFrom](bytes)
+    else return bytes end
 end
 
 function bit_converter.validate_order(order)
-	if not bit_converter.is_valid_order(order) then
-		 error("invalid order: "..order)
-	end
+    if not bit_converter.is_valid_order(order) then
+         error("invalid order: "..order)
+    end
 end
 
 function bit_converter.is_valid_order(order) return table.has(orders, order) end
 
 function bit_converter.string_to_bytes(str)
-	local bytes = { }
+    local bytes = { }
 
-	local len = string.len(str)
+    local len = string.len(str)
 
-	local lenBytes = bit_converter.uint16_to_bytes(len)
+    local lenBytes = bit_converter.uint16_to_bytes(len)
 
-	for i = 1, #lenBytes do
-		bytes[i] = lenBytes[i]
-	end
+    for i = 1, #lenBytes do
+        bytes[i] = lenBytes[i]
+    end
 
-	for i = 1, len do
-		bytes[#bytes + 1] = string.byte(string.sub(str, i, i))
-	end
+    for i = 1, len do
+        bytes[#bytes + 1] = string.byte(string.sub(str, i, i))
+    end
 
-	return bytes
+    return bytes
 end
 
 function bit_converter.bool_to_byte(bool)
-	return bool and 1 or 0
+    return bool and 1 or 0
 end
 
 -- Credits to Iryont <https://github.com/iryont/lua-struct>
@@ -151,177 +151,178 @@ end
 --
 
 function bit_converter.float32_to_bytes(float, order)
-	return fromLE(floatOrDoubleToBytes(float, 'f'), order)
+    return fromLE(floatOrDoubleToBytes(float, 'f'), order)
 end
 
 function bit_converter.float64_to_bytes(float, order)
-	return fromLE(floatOrDoubleToBytes(float, 'd'), order)
+    return fromLE(floatOrDoubleToBytes(float, 'd'), order)
 end
 
 function bit_converter.single_to_bytes(float, order)
-	on_deprecated_call("bit_converter.float_to_bytes", "bit_converter.float32_to_bytes")
-	return bit_converter.float32_to_bytes(bytes, order)
+    on_deprecated_call("bit_converter.float_to_bytes", "bit_converter.float32_to_bytes")
+    return bit_converter.float32_to_bytes(bytes, order)
 end
 
 function bit_converter.double_to_bytes(double, order)
-	on_deprecated_call("bit_converter.double_to_bytes", "bit_converter.float64_to_bytes")
-	return bit_converter.float64_to_bytes(bytes, order)
+    on_deprecated_call("bit_converter.double_to_bytes", "bit_converter.float64_to_bytes")
+    return bit_converter.float64_to_bytes(bytes, order)
 end
 
 local function uint32ToBytes(int, order)
-	return fromLE({
-		maskHighBytes(bit.rshift(int, 24)),
-		maskHighBytes(bit.rshift(int, 16)),
-		maskHighBytes(bit.rshift(int, 8)),
-		maskHighBytes(int)
-	}, order)
+    return fromLE({
+        maskHighBytes(int),
+        maskHighBytes(bit.rshift(int, 8)),
+        maskHighBytes(bit.rshift(int, 16)),
+        maskHighBytes(bit.rshift(int, 24))
+    }, order)
 end
 
 local function uint16ToBytes(int, order)
-	return fromLE({
-		maskHighBytes(bit.rshift(int, 8)),
-		maskHighBytes(int)
-	}, order)
+    return fromLE({
+        maskHighBytes(int),
+        maskHighBytes(bit.rshift(int, 8))
+    }, order)
 end
 
 function bit_converter.uint32_to_bytes(int, order)
-	if int > MAX_UINT32 or int < MIN_UINT32 then
-		error("invalid uint32")
-	end
+    if int > MAX_UINT32 or int < MIN_UINT32 then
+        error("invalid uint32")
+    end
 
-	return uint32ToBytes(int, order)
+    return uint32ToBytes(int, order)
 end
 
 function bit_converter.uint16_to_bytes(int, order)
-	if int > MAX_UINT16 or int < MIN_UINT16 then
-		error("invalid uint16")
-	end
+    if int > MAX_UINT16 or int < MIN_UINT16 then
+        error("invalid uint16")
+    end
 
-	return uint16ToBytes(int, order)
+    return uint16ToBytes(int, order)
 end
 
 function bit_converter.int64_to_bytes(int, order)
-	if int > MAX_INT64 or int < MIN_INT64 then
-		error("invalid int64")
-	end
-
-	return fromLE({
-		maskHighBytes(bit.rshift(int, 56)),
-		maskHighBytes(bit.rshift(int, 48)),
-		maskHighBytes(bit.rshift(int, 40)),
-		maskHighBytes(bit.rshift(int, 32)),
-		maskHighBytes(bit.rshift(int, 24)),
-		maskHighBytes(bit.rshift(int, 16)),
-		maskHighBytes(bit.rshift(int, 8)),
-		maskHighBytes(int)
-	}, order)
+    if int > MAX_INT64 or int < MIN_INT64 then
+        error("invalid int64")
+    end
+
+    return fromLE({
+        maskHighBytes(int),
+        maskHighBytes(bit.rshift(int, 8)),
+        maskHighBytes(bit.rshift(int, 16)),
+        maskHighBytes(bit.rshift(int, 24)),
+        maskHighBytes(bit.rshift(int, 32)),
+        maskHighBytes(bit.rshift(int, 40)),
+        maskHighBytes(bit.rshift(int, 48)),
+        maskHighBytes(bit.rshift(int, 56))
+    }, order)
 end
 
 function bit_converter.int32_to_bytes(int, order)
-	on_deprecated_call("bit_converter.int32_to_bytes", "bit_converter.sint32_to_bytes")
+    on_deprecated_call("bit_converter.int32_to_bytes", "bit_converter.sint32_to_bytes")
 
-	if int > MAX_INT32 or int < MIN_INT32 then
-		error("invalid int32")
-	end
+    if int > MAX_INT32 or int < MIN_INT32 then
+        error("invalid int32")
+    end
 
-	return uint32ToBytes(int + MAX_INT32, order)
+    return uint32ToBytes(int + MAX_INT32, order)
 end
 
 function bit_converter.int16_to_bytes(int, order)
-	on_deprecated_call("bit_converter.int32_to_bytes", "bit_converter.sint16_to_bytes")
+    on_deprecated_call("bit_converter.int32_to_bytes", "bit_converter.sint16_to_bytes")
 
-	if int > MAX_INT16 or int < MIN_INT16 then
-		error("invalid int16")
-	end
+    if int > MAX_INT16 or int < MIN_INT16 then
+        error("invalid int16")
+    end
 
-	return uint16ToBytes(int + MAX_INT16, order)
+    return uint16ToBytes(int + MAX_INT16, order)
 end
 
 function bit_converter.sint32_to_bytes(int, order)
-	if int > MAX_INT32 or int < MIN_INT32 then
-		error("invalid sint32")
-	end
+    if int > MAX_INT32 or int < MIN_INT32 then
+        error("invalid sint32")
+    end
 
-	return uint32ToBytes(int + MAX_UINT32 + 1, order)
+    return uint32ToBytes(int + MAX_UINT32 + 1, order)
 end
 
 function bit_converter.sint16_to_bytes(int, order)
-	if int > MAX_INT16 or int < MIN_INT16 then
-		error("invalid sint16")
-	end
+    if int > MAX_INT16 or int < MIN_INT16 then
+        error("invalid sint16")
+    end
 
-	return uint16ToBytes(int + MAX_UINT16 + 1, order)
+    return uint16ToBytes(int + MAX_UINT16 + 1, order)
 end
 
 function bit_converter.bytes_to_float32(bytes, order)
-	return bytesToFloatOrDouble(toLE(bytes, order), 'f')
+    return bytesToFloatOrDouble(toLE(bytes, order), 'f')
 end
 
 function bit_converter.bytes_to_float64(bytes, order)
-	return bytesToFloatOrDouble(toLE(bytes, order), 'd')
+    return bytesToFloatOrDouble(toLE(bytes, order), 'd')
 end
 
 function bit_converter.bytes_to_single(bytes, order)
-	on_deprecated_call("bit_converter.bytes_to_single", "bit_converter.bytes_to_float32")
-	return bit_converter.bytes_to_float32(bytes, order)
+    on_deprecated_call("bit_converter.bytes_to_single", "bit_converter.bytes_to_float32")
+    return bit_converter.bytes_to_float32(bytes, order)
 end
 
 function bit_converter.bytes_to_double(bytes, order)
-	on_deprecated_call("bit_converter.bytes_to_double", "bit_converter.bytes_to_float64")
-	return bit_converter.bytes_to_float64(bytes, order)
+    on_deprecated_call("bit_converter.bytes_to_double", "bit_converter.bytes_to_float64")
+    return bit_converter.bytes_to_float64(bytes, order)
 end
 
 function bit_converter.bytes_to_string(bytes, order)
-	local len = bit_converter.bytes_to_uint16({ bytes[1], bytes[2] })
+    local len = bit_converter.bytes_to_uint16({ bytes[1], bytes[2] })
 
-	local str = ""
+    local str = ""
 
-	for i = 1, len do
-		str = str..string.char(bytes[i + 2])
-	end
+    for i = 1, len do
+        str = str..string.char(bytes[i + 2])
+    end
 
-	return str
+    return str
 end
 
 function bit_converter.byte_to_bool(byte)
-	return byte ~= 0
+    return byte ~= 0
 end
 
 function bit_converter.bytes_to_uint32(bytes, order)
-	if #bytes < 4 then
-		error("eof")
-	end
+    if #bytes < 4 then
+        error("eof")
+    end
 
-	bytes = toLE(bytes, order)
+    bytes = toLE(bytes, order)
 
      return
      bit.bor(
      bit.bor(
      bit.bor(
-     bit.lshift(bytes[1], 24),
-     bit.lshift(bytes[2], 16)),
-     bit.lshift(bytes[3], 8)),bytes[4])
+     bytes[1],
+     bit.lshift(bytes[2], 8)),
+     bit.lshift(bytes[3], 16)),
+     bit.lshift(bytes[4], 24))
 end
 
 function bit_converter.bytes_to_uint16(bytes, order)
-	if #bytes < 2 then
-		error("eof")
-	end
+    if #bytes < 2 then
+        error("eof")
+    end
 
-	bytes = toLE(bytes, order)
+    bytes = toLE(bytes, order)
 
      return
      bit.bor(
-     bit.lshift(bytes[1], 8),
-     bytes[2], 0)
+     bit.lshift(bytes[2], 8),
+     bytes[1], 0)
 end
 
 function bit_converter.bytes_to_int64(bytes, order)
-	if #bytes < 8 then
-		error("eof")
-	end
+    if #bytes < 8 then
+        error("eof")
+    end
 
-	bytes = toLE(bytes, order)
+    bytes = toLE(bytes, order)
 
      return
      bit.bor(
@@ -331,35 +332,35 @@ function bit_converter.bytes_to_int64(bytes, order)
      bit.bor(
      bit.bor(
      bit.bor(
-     bit.lshift(bytes[1], 56),
-     bit.lshift(bytes[2], 48)),
-     bit.lshift(bytes[3], 40)),
-     bit.lshift(bytes[4], 32)),
-     bit.lshift(bytes[5], 24)),
-     bit.lshift(bit.band(bytes[6], 0xFF), 16)),
-     bit.lshift(bit.band(bytes[7], 0xFF), 8)),bit.band(bytes[8], 0xFF))
+     bit.lshift(bytes[8], 56),
+     bit.lshift(bytes[7], 48)),
+     bit.lshift(bytes[6], 40)),
+     bit.lshift(bytes[5], 32)),
+     bit.lshift(bytes[4], 24)),
+     bit.lshift(bit.band(bytes[3], 0xFF), 16)),
+     bit.lshift(bit.band(bytes[2], 0xFF), 8)),bit.band(bytes[1], 0xFF))
 end
 
 function bit_converter.bytes_to_int32(bytes, order)
-	on_deprecated_call("bit_converter.bytes_to_int32", "bit_converter.bytes_to_sint32")
-	return bit_converter.bytes_to_uint32(bytes, order) - MAX_INT32
+    on_deprecated_call("bit_converter.bytes_to_int32", "bit_converter.bytes_to_sint32")
+    return bit_converter.bytes_to_uint32(bytes, order) - MAX_INT32
 end
 
 function bit_converter.bytes_to_int16(bytes, order)
-	on_deprecated_call("bit_converter.bytes_to_int16", "bit_converter.bytes_to_sint16")
-	return bit_converter.bytes_to_uint16(bytes, order) - MAX_INT16
+    on_deprecated_call("bit_converter.bytes_to_int16", "bit_converter.bytes_to_sint16")
+    return bit_converter.bytes_to_uint16(bytes, order) - MAX_INT16
 end
 
 function bit_converter.bytes_to_sint32(bytes, order)
-	local num = bit_converter.bytes_to_uint32(bytes, order)
+    local num = bit_converter.bytes_to_uint32(bytes, order)
 
-	return MIN_INT32 * (bit.band(MAX_INT32 + 1, num) ~= 0 and 1 or 0) + bit.band(MAX_INT32, num)
+    return MIN_INT32 * (bit.band(MAX_INT32 + 1, num) ~= 0 and 1 or 0) + bit.band(MAX_INT32, num)
 end
 
 function bit_converter.bytes_to_sint16(bytes, order)
-	local num = bit_converter.bytes_to_uint16(bytes, order)
+    local num = bit_converter.bytes_to_uint16(bytes, order)
 
-	return MIN_INT16 * (bit.band(MAX_INT16 + 1, num) ~= 0 and 1 or 0) + bit.band(MAX_INT16, num)
+    return MIN_INT16 * (bit.band(MAX_INT16 + 1, num) ~= 0 and 1 or 0) + bit.band(MAX_INT16, num)
 end
 
 return bit_converter
diff --git a/res/modules/gui_util.lua b/res/modules/gui_util.lua
new file mode 100644
index 000000000..d29837653
--- /dev/null
+++ b/res/modules/gui_util.lua
@@ -0,0 +1,36 @@
+local gui_util = {}
+
+--- Parse `pagename?arg1=value1&arg2=value2` queries
+--- @param query page query string
+--- @return page_name, args_table
+function gui_util.parse_query(query)
+    local args = {}
+    local name
+
+    local index = string.find(query, '?')
+    if index then
+        local argstr = string.sub(query, index + 1)
+        name = string.sub(query, 1, index - 1)
+        
+        for key, value in string.gmatch(argstr, "([^=&]*)=([^&]*)") do
+            args[key] = value
+        end
+    else
+        name = query
+    end
+    return name, args
+end
+
+--- @param query page query string
+--- @return document_id
+function gui_util.load_page(query)
+    local name, args = gui_util.parse_query(query)
+    local filename = file.find(string.format("layouts/pages/%s.xml", name))
+    if filename then
+        name = file.prefix(filename)..":pages/"..name
+        gui.load_document(filename, name, args)
+        return name
+    end
+end
+
+return gui_util
diff --git a/res/modules/tests_util.lua b/res/modules/tests_util.lua
new file mode 100644
index 000000000..1e2207c24
--- /dev/null
+++ b/res/modules/tests_util.lua
@@ -0,0 +1,8 @@
+local util = {}
+
+function util.create_demo_world(generator)
+    app.config_packs({"base"})
+    app.new_world("demo", "2019", generator or "core:default")
+end
+
+return util
diff --git a/res/preload.json b/res/preload.json
index 5efe0162f..fb202291e 100644
--- a/res/preload.json
+++ b/res/preload.json
@@ -31,5 +31,8 @@
         "blocks",
         "items",
         "particles"
+    ],
+    "models": [
+        "block"
     ]
 }
diff --git a/res/scripts/classes.lua b/res/scripts/classes.lua
index 909717cf1..0741c89b1 100644
--- a/res/scripts/classes.lua
+++ b/res/scripts/classes.lua
@@ -40,6 +40,7 @@ local Socket = {__index={
     send=function(self, ...) return network.__send(self.id, ...) end,
     recv=function(self, ...) return network.__recv(self.id, ...) end,
     close=function(self) return network.__close(self.id) end,
+    available=function(self) return network.__available(self.id) or 0 end,
     is_alive=function(self) return network.__is_alive(self.id) end,
     is_connected=function(self) return network.__is_connected(self.id) end,
     get_address=function(self) return network.__get_address(self.id) end,
diff --git a/res/scripts/hud.lua b/res/scripts/hud.lua
new file mode 100644
index 000000000..093d43c32
--- /dev/null
+++ b/res/scripts/hud.lua
@@ -0,0 +1,58 @@
+function on_hud_open()
+    input.add_callback("player.pick", function ()
+        if hud.is_paused() or hud.is_inventory_open() then
+            return
+        end
+        local pid = hud.get_player()
+        local x, y, z = player.get_selected_block(pid)
+        if x == nil then
+            return
+        end
+        local id = block.get_picking_item(block.get(x, y, z))
+        local inv, cur_slot = player.get_inventory(pid)
+        local slot = inventory.find_by_item(inv, id, 0, 9)
+        if slot then
+            player.set_selected_slot(pid, slot)
+            return
+        end
+        if not rules.get("allow-content-access") then
+            return
+        end
+        slot = inventory.find_by_item(inv, 0, 0, 9)
+        if slot then
+            cur_slot = slot
+        end
+        player.set_selected_slot(pid, cur_slot)
+        inventory.set(inv, cur_slot, id, 1)
+    end)
+
+    input.add_callback("player.noclip", function ()
+        if hud.is_paused() or hud.is_inventory_open() then
+            return
+        end
+        local pid = hud.get_player()
+        if player.is_noclip(pid) then
+            player.set_flight(pid, false)
+            player.set_noclip(pid, false)
+        else
+            player.set_flight(pid, true)
+            player.set_noclip(pid, true)
+        end
+    end)
+    
+    input.add_callback("player.flight", function ()
+        if hud.is_paused() or hud.is_inventory_open() then
+            return
+        end
+        local pid = hud.get_player()
+        if player.is_noclip(pid) then
+            return
+        end
+        if player.is_flight(pid) then
+            player.set_flight(pid, false)
+        else
+            player.set_flight(pid, true)
+            player.set_vel(pid, 0, 1, 0)
+        end
+    end)
+end
diff --git a/res/scripts/post_content.lua b/res/scripts/post_content.lua
index ae67c6789..8725ed974 100644
--- a/res/scripts/post_content.lua
+++ b/res/scripts/post_content.lua
@@ -7,7 +7,7 @@ local names = {
     "hidden", "draw-group", "picking-item", "surface-replacement", "script-name",
     "ui-layout", "inventory-size", "tick-interval", "overlay-texture",
     "translucent", "fields", "particles", "icon-type", "icon", "placing-block", 
-    "stack-size"
+    "stack-size", "name"
 }
 for name, _ in pairs(user_props) do
     table.insert(names, name)
@@ -40,3 +40,24 @@ make_read_only(block.properties)
 for k,v in pairs(block.properties) do
     make_read_only(v)
 end
+
+local function cache_names(library)
+    local indices = {}
+    local names = {}
+    for id=0,library.defs_count()-1 do
+        local name = library.properties[id].name
+        indices[name] = id
+        names[id] = name
+    end
+
+    function library.name(id)
+        return names[id]
+    end
+
+    function library.index(name)
+        return indices[name]
+    end
+end
+
+cache_names(block)
+cache_names(item)
diff --git a/res/scripts/stdlib.lua b/res/scripts/stdlib.lua
index 9cf23cc3f..f376e2106 100644
--- a/res/scripts/stdlib.lua
+++ b/res/scripts/stdlib.lua
@@ -9,6 +9,87 @@ function sleep(timesec)
     end
 end
 
+function tb_frame_tostring(frame)
+    local s = frame.short_src
+    if frame.what ~= "C" then
+        s = s .. ":" .. tostring(frame.currentline)
+    end
+    if frame.what == "main" then
+        s = s .. ": in main chunk"
+    elseif frame.name then
+        s = s .. ": in function " .. utf8.escape(frame.name)
+    end
+    return s
+end
+
+local function complete_app_lib(app)
+    app.sleep = sleep
+    app.script = __VC_SCRIPT_NAME
+    app.new_world = core.new_world
+    app.open_world = core.open_world
+    app.save_world = core.save_world
+    app.close_world = core.close_world
+    app.reopen_world = core.reopen_world
+    app.delete_world = core.delete_world
+    app.reconfig_packs = core.reconfig_packs
+    app.get_setting = core.get_setting
+    app.set_setting = core.set_setting
+    app.tick = coroutine.yield
+    app.get_version = core.get_version
+    app.get_setting_info = core.get_setting_info
+    app.load_content = core.load_content
+    app.reset_content = core.reset_content
+    
+    function app.config_packs(packs_list)
+        -- Check if packs are valid and add dependencies to the configuration
+        packs_list = pack.assemble(packs_list)
+        
+        local installed = pack.get_installed()
+        local toremove = {}
+        for _, packid in ipairs(installed) do
+            if not table.has(packs_list, packid) then
+                table.insert(toremove, packid)
+            end
+        end
+        local toadd = {}
+        for _, packid in ipairs(packs_list) do
+            if not table.has(installed, packid) then
+                table.insert(toadd, packid)
+            end
+        end
+        app.reconfig_packs(toadd, toremove)
+    end
+
+    function app.quit()
+        local tb = debug.get_traceback(1)
+        local s = "app.quit() traceback:"
+        for i, frame in ipairs(tb) do
+            s = s .. "\n\t"..tb_frame_tostring(frame)
+        end
+        debug.log(s)
+        core.quit()
+        coroutine.yield()
+    end
+
+    function app.sleep_until(predicate, max_ticks)
+        max_ticks = max_ticks or 1e9
+        local ticks = 0
+        while ticks < max_ticks and not predicate() do
+            app.tick()
+            ticks = ticks + 1
+        end
+        if ticks == max_ticks then
+            error("max ticks exceed")
+        end
+    end
+end
+
+if app then
+    complete_app_lib(app)
+elseif __vc_app then
+    complete_app_lib(__vc_app)
+end
+
 ------------------------------------------------
 ------------------- Events ---------------------
 ------------------------------------------------
@@ -54,7 +135,12 @@ function events.emit(event, ...)
         return nil
     end
     for _, func in ipairs(handlers) do
-        result = result or func(...)
+        local status, newres = xpcall(func, __vc__error, ...)
+        if not status then
+            debug.error("error in event ("..event..") handler: "..newres)
+        else 
+            result = result or newres
+        end
     end
     return result
 end
@@ -85,7 +171,7 @@ function Document.new(docname)
 end
 
 local _RadioGroup = {}
-function _RadioGroup.set(self, key)
+function _RadioGroup:set(key)
     if type(self) ~= 'table' then
         error("called as non-OOP via '.', use radiogroup:set")
     end
@@ -98,7 +184,7 @@ function _RadioGroup.set(self, key)
         self.callback(key)
     end
 end
-function _RadioGroup.__call(self, elements, onset, default)
+function _RadioGroup:__call(elements, onset, default)
     local group = setmetatable({
         elements=elements, 
         callback=onset, 
@@ -114,20 +200,8 @@ _GUI_ROOT = Document.new("core:root")
 _MENU = _GUI_ROOT.menu
 menu = _MENU
 
-local __post_runnables = {}
-
-function __process_post_runnables()
-    if #__post_runnables then
-        for _, func in ipairs(__post_runnables) do
-            func()
-        end
-        __post_runnables = {}
-    end
-end
-
-function time.post_runnable(runnable)
-    table.insert(__post_runnables, runnable)
-end
+local gui_util = require "core:gui_util"
+__vc_page_loader = gui_util.load_page
 
 ---  Console library extension ---
 console.cheats = {}
@@ -272,7 +346,6 @@ function __vc_on_hud_open()
 
     _rules.create("allow-content-access", hud._is_content_access(), function(value)
         hud._set_content_access(value)
-        input.set_enabled("player.pick", value)
     end)
     _rules.create("allow-flight", true, function(value)
         input.set_enabled("player.flight", value)
@@ -328,6 +401,86 @@ function __vc_on_world_quit()
     _rules.clear()
 end
 
+local __vc_coroutines = {}
+local __vc_named_coroutines = {}
+local __vc_next_coroutine = 1
+local __vc_coroutine_error = nil
+
+function __vc_start_coroutine(chunk)
+    local co = coroutine.create(function()
+        local status, err = pcall(chunk)
+        if not status then
+            __vc_coroutine_error = err
+        end
+    end)
+    local id = __vc_next_coroutine
+    __vc_next_coroutine = __vc_next_coroutine + 1
+    __vc_coroutines[id] = co
+    return id
+end
+
+function __vc_resume_coroutine(id)
+    local co = __vc_coroutines[id]
+    if co then
+        coroutine.resume(co)
+        if __vc_coroutine_error then
+            debug.error(__vc_coroutine_error)
+            error(__vc_coroutine_error)
+        end
+        return coroutine.status(co) ~= "dead"
+    end
+    return false
+end
+
+function __vc_stop_coroutine(id)
+    local co = __vc_coroutines[id]
+    if co then
+        if coroutine.close then
+            coroutine.close(co)
+        end
+        __vc_coroutines[id] = nil
+    end
+end
+
+function start_coroutine(chunk, name)
+    local co = coroutine.create(function()
+        local status, error = xpcall(chunk, __vc__error)
+        if not status then
+            debug.error(error)
+        end
+    end)
+    __vc_named_coroutines[name] = co
+end
+
+local __post_runnables = {}
+
+function __process_post_runnables()
+    if #__post_runnables then
+        for _, func in ipairs(__post_runnables) do
+            local status, result = xpcall(func, __vc__error)
+            if not status then
+                debug.error("error in post_runnable: "..result)
+            end
+        end
+        __post_runnables = {}
+    end
+
+    local dead = {}
+    for name, co in pairs(__vc_named_coroutines) do
+        coroutine.resume(co)
+        if coroutine.status(co) == "dead" then
+            table.insert(dead, name)
+        end
+    end
+    for _, name in ipairs(dead) do
+        __vc_named_coroutines[name] = nil
+    end
+end
+
+function time.post_runnable(runnable)
+    table.insert(__post_runnables, runnable)
+end
+
 assets = {}
 assets.load_texture = core.__load_texture
 
diff --git a/res/scripts/stdmin.lua b/res/scripts/stdmin.lua
index 5b93fa2f9..5da1b3474 100644
--- a/res/scripts/stdmin.lua
+++ b/res/scripts/stdmin.lua
@@ -34,11 +34,11 @@ end
 
 
 function timeit(iters, func, ...)
-    local tm = time.uptime()
+    local tm = os.clock()
     for i=1,iters do
         func(...)
     end
-    print("[time mcs]", (time.uptime()-tm) * 1000000)
+    print("[time mcs]", (os.clock()-tm) * 1000000)
 end
 
 ----------------------------------------------
@@ -361,3 +361,20 @@ function __vc_warning(msg, detail, n)
             "core:warning", msg, detail, debug.get_traceback(1 + (n or 0)))
     end
 end
+
+function file.name(path)
+    return path:match("([^:/\\]+)$")
+end
+
+function file.stem(path)
+    local name = file.name(path)
+    return name:match("(.+)%.[^%.]+$") or name
+end
+
+function file.ext(path)
+    return path:match("%.([^:/\\]+)$")
+end
+
+function file.prefix(path)
+    return path:match("^([^:]+)")
+end
diff --git a/res/texts/ru_RU.txt b/res/texts/ru_RU.txt
index e78b5f729..d3c408935 100644
--- a/res/texts/ru_RU.txt
+++ b/res/texts/ru_RU.txt
@@ -34,6 +34,7 @@ graphics.dense-render.tooltip=Включает прозрачность блок
 menu.Apply=Применить
 menu.Audio=Звук
 menu.Back to Main Menu=Вернуться в Меню
+menu.Scripts=Сценарии
 menu.Content Error=Ошибка Контента
 menu.Content=Контент
 menu.Continue=Продолжить
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 7eecaef99..6350f4b88 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -4,15 +4,19 @@ set(CMAKE_CXX_STANDARD 17)
 
 file(GLOB_RECURSE HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/*.hpp)
 file(GLOB_RECURSE SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
-list(REMOVE_ITEM SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/voxel_engine.cpp)
+list(REMOVE_ITEM SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp)
 
-add_library(${PROJECT_NAME} ${SOURCES} ${HEADERS})
-
-option(VOXELENGINE_BUILD_WINDOWS_VCPKG ON)
+add_library(${PROJECT_NAME} STATIC ${SOURCES} ${HEADERS})
 
 find_package(OpenGL REQUIRED)
 find_package(GLEW REQUIRED)
-find_package(OpenAL REQUIRED)
+if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
+    # specific for vcpkg
+    find_package(OpenAL CONFIG REQUIRED)
+    set(OPENAL_LIBRARY OpenAL::OpenAL)
+else()
+    find_package(OpenAL REQUIRED)
+endif()
 find_package(ZLIB REQUIRED)
 find_package(PNG REQUIRED)
 find_package(CURL REQUIRED)
@@ -20,19 +24,23 @@ if (NOT APPLE)
     find_package(EnTT REQUIRED)
 endif()
 
-if (WIN32)
-    if(VOXELENGINE_BUILD_WINDOWS_VCPKG)
-      set(LUA_LIBRARIES "${CMAKE_CURRENT_SOURCE_DIR}/../vcpkg/packages/luajit_x64-windows/lib/lua51.lib")
-      set(LUA_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../vcpkg/packages/luajit_x64-windows/include/luajit")
-      find_package(glfw3 REQUIRED)
-      find_package(glm REQUIRED)
-      find_package(vorbis REQUIRED)
-      set(VORBISLIB Vorbis::vorbis Vorbis::vorbisfile)
+set(LIBS "")
+
+if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
+    # Use directly linking to lib instead PkgConfig (because pkg-config dont install on windows as default) 
+    # TODO: Do it with findLua.
+    if (MSVC)
+        set(LUA_INCLUDE_DIR "$ENV{VCPKG_ROOT}/packages/luajit_${VCPKG_TARGET_TRIPLET}/include/luajit")
+        find_package(Lua REQUIRED)
     else()
-      find_package(Lua REQUIRED)
-      set(VORBISLIB vorbis vorbisfile) # not tested
-      add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/libs/glfw)
+        # Used for mingw-clang cross compiling from msys2
+        set(LIBS ${LIBS} luajit-5.1)
     endif()
+    find_package(glfw3 REQUIRED)
+    find_package(glm REQUIRED)
+    find_package(vorbis REQUIRED)
+    set(VORBISLIB Vorbis::vorbis Vorbis::vorbisfile)
+
 elseif(APPLE)
     find_package(PkgConfig)
     pkg_check_modules(LUAJIT REQUIRED luajit)
@@ -53,8 +61,6 @@ else()
     set(VORBISLIB ${VORBIS_LDFLAGS})
 endif()
 
-set(LIBS "")
-
 if(UNIX)
     find_package(glfw3 3.3 REQUIRED)
     find_package(Threads REQUIRED)
diff --git a/src/audio/audio.cpp b/src/audio/audio.cpp
index 0dc0f591c..522e37053 100644
--- a/src/audio/audio.cpp
+++ b/src/audio/audio.cpp
@@ -8,6 +8,9 @@
 #include "coders/wav.hpp"
 #include "AL/ALAudio.hpp"
 #include "NoAudio.hpp"
+#include "debug/Logger.hpp"
+
+static debug::Logger logger("audio");
 
 namespace audio {
     static speakerid_t nextId = 1;
@@ -147,10 +150,14 @@ class PCMVoidSource : public PCMStream {
 
 void audio::initialize(bool enabled) {
     if (enabled) {
+        logger.info() << "initializing ALAudio backend";
         backend = ALAudio::create().release();
     }
     if (backend == nullptr) {
-        std::cerr << "could not to initialize audio" << std::endl;
+        if (enabled) {
+            std::cerr << "could not to initialize audio" << std::endl;
+        }
+        logger.info() << "initializing NoAudio backend";
         backend = NoAudio::create().release();
     }
     create_channel("master");
diff --git a/src/coders/byte_utils.cpp b/src/coders/byte_utils.cpp
index e30c14f2e..bd4a00909 100644
--- a/src/coders/byte_utils.cpp
+++ b/src/coders/byte_utils.cpp
@@ -6,6 +6,10 @@
 
 #include "util/data_io.hpp"
 
+ByteBuilder::ByteBuilder(size_t size) {
+    buffer.reserve(size);
+}
+
 void ByteBuilder::put(ubyte b) {
     buffer.push_back(b);
 }
@@ -31,37 +35,37 @@ void ByteBuilder::put(const ubyte* arr, size_t size) {
     }
 }
 
-void ByteBuilder::putInt16(int16_t val) {
+void ByteBuilder::putInt16(int16_t val, bool bigEndian) {
     size_t size = buffer.size();
     buffer.resize(buffer.size() + sizeof(int16_t));
-    val = dataio::h2le(val);
+    val = bigEndian ? dataio::h2be(val) : dataio::h2le(val);
     std::memcpy(buffer.data()+size, &val, sizeof(int16_t));
 }
 
-void ByteBuilder::putInt32(int32_t val) {
+void ByteBuilder::putInt32(int32_t val, bool bigEndian) {
     size_t size = buffer.size();
     buffer.resize(buffer.size() + sizeof(int32_t));
-    val = dataio::h2le(val);
+    val = bigEndian ? dataio::h2be(val) : dataio::h2le(val);
     std::memcpy(buffer.data()+size, &val, sizeof(int32_t));
 }
 
-void ByteBuilder::putInt64(int64_t val) {
+void ByteBuilder::putInt64(int64_t val, bool bigEndian) {
     size_t size = buffer.size();
     buffer.resize(buffer.size() + sizeof(int64_t));
-    val = dataio::h2le(val);
+    val = bigEndian ? dataio::h2be(val) : dataio::h2le(val);
     std::memcpy(buffer.data()+size, &val, sizeof(int64_t));
 }
 
-void ByteBuilder::putFloat32(float val) {
+void ByteBuilder::putFloat32(float val, bool bigEndian) {
     int32_t i32_val;
     std::memcpy(&i32_val, &val, sizeof(int32_t));
-    putInt32(i32_val);
+    putInt32(i32_val, bigEndian);
 }
 
-void ByteBuilder::putFloat64(double val) {
+void ByteBuilder::putFloat64(double val, bool bigEndian) {
     int64_t i64_val;
     std::memcpy(&i64_val, &val, sizeof(int64_t));
-    putInt64(i64_val);
+    putInt64(i64_val, bigEndian);
 }
 
 void ByteBuilder::set(size_t position, ubyte val) {
@@ -95,6 +99,10 @@ ByteReader::ByteReader(const ubyte* data) : data(data), size(4), pos(0) {
     size = getInt32();
 }
 
+ByteReader::ByteReader(const std::vector<ubyte>& data)
+    : data(data.data()), size(data.size()), pos(0) {
+}
+
 void ByteReader::checkMagic(const char* data, size_t size) {
     if (pos + size >= this->size) {
         throw std::runtime_error("invalid magic number");
@@ -129,45 +137,51 @@ ubyte ByteReader::peek() {
     return data[pos];
 }
 
-int16_t ByteReader::getInt16() {
+int16_t ByteReader::getInt16(bool bigEndian) {
     if (pos + sizeof(int16_t) > size) {
         throw std::runtime_error("buffer underflow");
     }
     int16_t value;
     std::memcpy(&value, data + pos, sizeof(int16_t));
     pos += sizeof(int16_t);
-    return dataio::le2h(value);
+    return bigEndian ? dataio::be2h(value) : dataio::le2h(value);
 }
 
-int32_t ByteReader::getInt32() {
+int32_t ByteReader::getInt32(bool bigEndian) {
     if (pos + sizeof(int32_t) > size) {
         throw std::runtime_error("buffer underflow");
     }
     int32_t value;
     std::memcpy(&value, data + pos, sizeof(int32_t));
     pos += sizeof(int32_t);
-    return dataio::le2h(value);
+    return bigEndian ? dataio::be2h(value) : dataio::le2h(value);
 }
 
-int64_t ByteReader::getInt64() {
+int64_t ByteReader::getInt64(bool bigEndian) {
     if (pos + sizeof(int64_t) > size) {
         throw std::runtime_error("buffer underflow");
     }
     int64_t value;
     std::memcpy(&value, data + pos, sizeof(int64_t));
     pos += sizeof(int64_t);
-    return dataio::le2h(value);
+    return bigEndian ? dataio::be2h(value) : dataio::le2h(value);
 }
 
-float ByteReader::getFloat32() {
+float ByteReader::getFloat32(bool bigEndian) {
     int32_t i32_val = getInt32();
+    if (bigEndian) {
+        i32_val = dataio::be2h(i32_val);
+    }
     float val;
     std::memcpy(&val, &i32_val, sizeof(float));
     return val;
 }
 
-double ByteReader::getFloat64() {
+double ByteReader::getFloat64(bool bigEndian) {
     int64_t i64_val = getInt64();
+    if (bigEndian) {
+        i64_val = dataio::be2h(i64_val);
+    }
     double val;
     std::memcpy(&val, &i64_val, sizeof(double));
     return val;
diff --git a/src/coders/byte_utils.hpp b/src/coders/byte_utils.hpp
index 0532fe43a..8d98585a3 100644
--- a/src/coders/byte_utils.hpp
+++ b/src/coders/byte_utils.hpp
@@ -8,20 +8,23 @@
 class ByteBuilder {
     std::vector<ubyte> buffer;
 public:
+    ByteBuilder() = default;
+    ByteBuilder(size_t size);
+
     /// @brief Write one byte (8 bit unsigned integer)
     void put(ubyte b);
     /// @brief Write c-string (bytes array terminated with '\00')
     void putCStr(const char* str);
     /// @brief Write signed 16 bit little-endian integer
-    void putInt16(int16_t val);
+    void putInt16(int16_t val, bool bigEndian = false);
     /// @brief Write signed 32 bit integer
-    void putInt32(int32_t val);
+    void putInt32(int32_t val, bool bigEndian = false);
     /// @brief Write signed 64 bit integer
-    void putInt64(int64_t val);
+    void putInt64(int64_t val, bool bigEndian = false);
     /// @brief Write 32 bit floating-point number
-    void putFloat32(float val);
+    void putFloat32(float val, bool bigEndian = false);
     /// @brief Write 64 bit floating-point number
-    void putFloat64(double val);
+    void putFloat64(double val, bool bigEndian = false);
 
     /// @brief Write string (uint32 length + bytes)
     void put(const std::string& s);
@@ -50,6 +53,7 @@ class ByteReader {
 public:
     ByteReader(const ubyte* data, size_t size);
     ByteReader(const ubyte* data);
+    ByteReader(const std::vector<ubyte>& data);
 
     void checkMagic(const char* data, size_t size);
     /// @brief Get N bytes
@@ -59,15 +63,15 @@ class ByteReader {
     /// @brief Read one byte (unsigned 8 bit integer) without pointer move
     ubyte peek();
     /// @brief Read signed 16 bit little-endian integer
-    int16_t getInt16();
+    int16_t getInt16(bool bigEndian = false);
     /// @brief Read signed 32 bit little-endian integer
-    int32_t getInt32();
+    int32_t getInt32(bool bigEndian = false);
     /// @brief Read signed 64 bit little-endian integer
-    int64_t getInt64();
+    int64_t getInt64(bool bigEndian = false);
     /// @brief Read 32 bit floating-point number
-    float getFloat32();
+    float getFloat32(bool bigEndian = false);
     /// @brief Read 64 bit floating-point number
-    double getFloat64();
+    double getFloat64(bool bigEndian = false);
     /// @brief Read C-String
     const char* getCString();
     /// @brief Read string with unsigned 32 bit number before (length)
diff --git a/src/coders/xml.cpp b/src/coders/xml.cpp
index b2cb88092..84cc9f375 100644
--- a/src/coders/xml.cpp
+++ b/src/coders/xml.cpp
@@ -92,11 +92,11 @@ glm::vec4 Attribute::asColor() const {
             throw std::runtime_error("#RRGGBB or #RRGGBBAA required");
         }
         int a = 255;
-        int r = (hexchar2int(text[1]) << 4) | hexchar2int(text[2]);
-        int g = (hexchar2int(text[3]) << 4) | hexchar2int(text[4]);
-        int b = (hexchar2int(text[5]) << 4) | hexchar2int(text[6]);
+        int r = (std::max(0, hexchar2int(text[1])) << 4) | hexchar2int(text[2]);
+        int g = (std::max(0, hexchar2int(text[3])) << 4) | hexchar2int(text[4]);
+        int b = (std::max(0, hexchar2int(text[5])) << 4) | hexchar2int(text[6]);
         if (text.length() == 9) {
-            a = (hexchar2int(text[7]) << 4) | hexchar2int(text[8]);
+            a = (std::max(0, hexchar2int(text[7])) << 4) | hexchar2int(text[8]);
         }
         return glm::vec4(r / 255.f, g / 255.f, b / 255.f, a / 255.f);
     } else {
diff --git a/src/constants.hpp b/src/constants.hpp
index c8de5a8dd..6f4a6ce6e 100644
--- a/src/constants.hpp
+++ b/src/constants.hpp
@@ -35,6 +35,11 @@ inline constexpr int CHUNK_D = 16;
 inline constexpr uint VOXEL_USER_BITS = 8;
 inline constexpr uint VOXEL_USER_BITS_OFFSET = sizeof(blockstate_t)*8-VOXEL_USER_BITS;
 
+/// @brief % unordered map max average buckets load factor.
+/// Low value gives significant performance impact by minimizing collisions and
+/// lookup latency. Default value (1.0) shows x2 slower work.
+inline constexpr float CHUNKS_MAP_MAX_LOAD_FACTOR = 0.1f;
+
 /// @brief chunk volume (count of voxels per Chunk)
 inline constexpr int CHUNK_VOL = (CHUNK_W * CHUNK_H * CHUNK_D);
 
diff --git a/src/content/ContentBuilder.cpp b/src/content/ContentBuilder.cpp
index f7ab3b1a7..49433dfd1 100644
--- a/src/content/ContentBuilder.cpp
+++ b/src/content/ContentBuilder.cpp
@@ -91,10 +91,18 @@ std::unique_ptr<Content> ContentBuilder::build() {
     for (Block* def : blockDefsIndices) {
         def->rt.pickingItem = content->items.require(def->pickingItem).rt.id;
         def->rt.surfaceReplacement = content->blocks.require(def->surfaceReplacement).rt.id;
+        if (def->properties == nullptr) {
+            def->properties = dv::object();
+            def->properties["name"] = def->name;
+        }
     }
 
     for (ItemDef* def : itemDefsIndices) {
         def->rt.placingBlock = content->blocks.require(def->placingBlock).rt.id;
+        if (def->properties == nullptr) {
+            def->properties = dv::object();
+        }
+        def->properties["name"] = def->name;
     }
 
     for (auto& [name, def] : content->generators.getDefs()) {
diff --git a/src/content/ContentBuilder.hpp b/src/content/ContentBuilder.hpp
index 44099304c..cc35838ce 100644
--- a/src/content/ContentBuilder.hpp
+++ b/src/content/ContentBuilder.hpp
@@ -35,11 +35,13 @@ class ContentUnitBuilder {
         : allNames(allNames), type(type) {
     }
 
-    T& create(const std::string& id) {
+    T& create(const std::string& id, bool* created = nullptr) {
         auto found = defs.find(id);
         if (found != defs.end()) {
+            if (created) *created = false;
             return *found->second;
         }
+        if (created) *created = true;
         checkIdentifier(id);
         allNames[id] = type;
         names.push_back(id);
diff --git a/src/content/ContentLoader.cpp b/src/content/ContentLoader.cpp
index 1dc676ea4..ce3f50605 100644
--- a/src/content/ContentLoader.cpp
+++ b/src/content/ContentLoader.cpp
@@ -187,11 +187,49 @@ static void perform_user_block_fields(
     layout = StructLayout::create(fields);
 }
 
+static void process_method(
+    dv::value& properties,
+    const std::string& method,
+    const std::string& name,
+    const dv::value& value
+) {
+    if (method == "append") {
+        if (!properties.has(name)) {
+            properties[name] = dv::list();
+        }
+        auto& list = properties[name];
+        if (value.isList()) {
+            for (const auto& item : value) {
+                list.add(item);
+            }
+        } else {
+            list.add(value);
+        }
+    } else {
+        throw std::runtime_error(
+            "unknown method " + method + " for " + name
+        );
+    }
+}
+
 void ContentLoader::loadBlock(
     Block& def, const std::string& name, const fs::path& file
 ) {
     auto root = files::read_json(file);
-    def.properties = root;
+    if (def.properties == nullptr) {
+        def.properties = dv::object();
+        def.properties["name"] = name;
+    }
+    for (auto& [key, value] : root.asObject()) {
+        auto pos = key.rfind('@');
+        if (pos == std::string::npos) {
+            def.properties[key] = value;
+            continue;
+        }
+        auto field = key.substr(0, pos);
+        auto suffix = key.substr(pos + 1);
+        process_method(def.properties, suffix, field, value);
+    }
 
     if (root.has("parent")) {
         const auto& parentName = root["parent"].asString();
@@ -492,7 +530,8 @@ void ContentLoader::loadBlock(
     if (fs::exists(configFile)) loadBlock(def, full, configFile);
 
     if (!def.hidden) {
-        auto& item = builder.items.create(full + BLOCK_ITEM_SUFFIX);
+        bool created;
+        auto& item = builder.items.create(full + BLOCK_ITEM_SUFFIX, &created);
         item.generated = true;
         item.caption = def.caption;
         item.iconType = ItemIconType::BLOCK;
@@ -502,7 +541,7 @@ void ContentLoader::loadBlock(
         for (uint j = 0; j < 4; j++) {
             item.emission[j] = def.emission[j];
         }
-        stats->totalItems++;
+        stats->totalItems += created;
     }
 }
 
@@ -564,9 +603,10 @@ void ContentLoader::loadContent(const dv::value& root) {
             if (parent.empty() || builder.blocks.get(parent)) {
                 // No dependency or dependency already loaded/exists in another
                 // content pack
-                auto& def = builder.blocks.create(full);
+                bool created;
+                auto& def = builder.blocks.create(full, &created);
                 loadBlock(def, full, name);
-                stats->totalBlocks++;
+                stats->totalBlocks += created;
             } else {
                 // Dependency not loaded yet, add to pending items
                 pendingDefs.emplace_back(full, name);
@@ -583,9 +623,10 @@ void ContentLoader::loadContent(const dv::value& root) {
                 if (builder.blocks.get(parent)) {
                     // Dependency resolved or parent exists in another pack,
                     // load the item
-                    auto& def = builder.blocks.create(it->first);
+                    bool created;
+                    auto& def = builder.blocks.create(it->first, &created);
                     loadBlock(def, it->first, it->second);
-                    stats->totalBlocks++;
+                    stats->totalBlocks += created;
                     it = pendingDefs.erase(it);  // Remove resolved item
                     progressMade = true;
                 } else {
@@ -609,9 +650,10 @@ void ContentLoader::loadContent(const dv::value& root) {
             if (parent.empty() || builder.items.get(parent)) {
                 // No dependency or dependency already loaded/exists in another
                 // content pack
-                auto& def = builder.items.create(full);
+                bool created;
+                auto& def = builder.items.create(full, &created);
                 loadItem(def, full, name);
-                stats->totalItems++;
+                stats->totalItems += created;
             } else {
                 // Dependency not loaded yet, add to pending items
                 pendingDefs.emplace_back(full, name);
@@ -628,9 +670,10 @@ void ContentLoader::loadContent(const dv::value& root) {
                 if (builder.items.get(parent)) {
                     // Dependency resolved or parent exists in another pack,
                     // load the item
-                    auto& def = builder.items.create(it->first);
+                    bool created;
+                    auto& def = builder.items.create(it->first, &created);
                     loadItem(def, it->first, it->second);
-                    stats->totalItems++;
+                    stats->totalItems += created;
                     it = pendingDefs.erase(it);  // Remove resolved item
                     progressMade = true;
                 } else {
@@ -654,9 +697,10 @@ void ContentLoader::loadContent(const dv::value& root) {
             if (parent.empty() || builder.entities.get(parent)) {
                 // No dependency or dependency already loaded/exists in another
                 // content pack
-                auto& def = builder.entities.create(full);
+                bool created;
+                auto& def = builder.entities.create(full, &created);
                 loadEntity(def, full, name);
-                stats->totalEntities++;
+                stats->totalEntities += created;
             } else {
                 // Dependency not loaded yet, add to pending items
                 pendingDefs.emplace_back(full, name);
@@ -673,9 +717,10 @@ void ContentLoader::loadContent(const dv::value& root) {
                 if (builder.entities.get(parent)) {
                     // Dependency resolved or parent exists in another pack,
                     // load the item
-                    auto& def = builder.entities.create(it->first);
+                    bool created;
+                    auto& def = builder.entities.create(it->first, &created);
                     loadEntity(def, it->first, it->second);
-                    stats->totalEntities++;
+                    stats->totalEntities += created;
                     it = pendingDefs.erase(it);  // Remove resolved item
                     progressMade = true;
                 } else {
diff --git a/src/content/ContentPack.cpp b/src/content/ContentPack.cpp
index 166400c6b..7135f2311 100644
--- a/src/content/ContentPack.cpp
+++ b/src/content/ContentPack.cpp
@@ -13,9 +13,9 @@
 
 namespace fs = std::filesystem;
 
-ContentPack ContentPack::createCore(const EnginePaths* paths) {
+ContentPack ContentPack::createCore(const EnginePaths& paths) {
     return ContentPack {
-        "core", "Core", ENGINE_VERSION_STRING, "", "", paths->getResourcesFolder(), {}
+        "core", "Core", ENGINE_VERSION_STRING, "", "", paths.getResourcesFolder(), "res:", {}
     };
 }
 
@@ -70,7 +70,7 @@ static void checkContentPackId(const std::string& id, const fs::path& folder) {
     }
 }
 
-ContentPack ContentPack::read(const fs::path& folder) {
+ContentPack ContentPack::read(const std::string& path, const fs::path& folder) {
     auto root = files::read_json(folder / fs::path(PACKAGE_FILENAME));
     ContentPack pack;
     root.at("id").get(pack.id);
@@ -90,6 +90,7 @@ ContentPack ContentPack::read(const fs::path& folder) {
     root.at("description").get(pack.description);
     root.at("source").get(pack.source);
     pack.folder = folder;
+    pack.path = path;
 
     if (auto found = root.at("dependencies")) {
         const auto& dependencies = *found;
@@ -123,17 +124,19 @@ ContentPack ContentPack::read(const fs::path& folder) {
 }
 
 void ContentPack::scanFolder(
-    const fs::path& folder, std::vector<ContentPack>& packs
+    const std::string& path, const fs::path& folder, std::vector<ContentPack>& packs
 ) {
     if (!fs::is_directory(folder)) {
         return;
     }
     for (const auto& entry : fs::directory_iterator(folder)) {
-        const fs::path& folder = entry.path();
-        if (!fs::is_directory(folder)) continue;
-        if (!is_pack(folder)) continue;
+        const fs::path& packFolder = entry.path();
+        if (!fs::is_directory(packFolder)) continue;
+        if (!is_pack(packFolder)) continue;
         try {
-            packs.push_back(read(folder));
+            packs.push_back(
+                read(path + "/" + packFolder.filename().string(), packFolder)
+            );
         } catch (const contentpack_error& err) {
             std::cerr << "package.json error at " << err.getFolder().u8string();
             std::cerr << ": " << err.what() << std::endl;
@@ -146,9 +149,7 @@ void ContentPack::scanFolder(
 std::vector<std::string> ContentPack::worldPacksList(const fs::path& folder) {
     fs::path listfile = folder / fs::path("packs.list");
     if (!fs::is_regular_file(listfile)) {
-        std::cerr << "warning: packs.list not found (will be created)";
-        std::cerr << std::endl;
-        files::write_string(listfile, "# autogenerated, do not modify\nbase\n");
+        throw std::runtime_error("missing file 'packs.list'");
     }
     return files::read_list(listfile);
 }
diff --git a/src/content/ContentPack.hpp b/src/content/ContentPack.hpp
index 857f4fe0a..c8e0de9b0 100644
--- a/src/content/ContentPack.hpp
+++ b/src/content/ContentPack.hpp
@@ -10,18 +10,18 @@
 
 class EnginePaths;
 
-namespace fs = std::filesystem;
-
 class contentpack_error : public std::runtime_error {
     std::string packId;
-    fs::path folder;
+    std::filesystem::path folder;
 public:
     contentpack_error(
-        std::string packId, fs::path folder, const std::string& message
+        std::string packId,
+        std::filesystem::path folder,
+        const std::string& message
     );
 
     std::string getPackId() const;
-    fs::path getFolder() const;
+    std::filesystem::path getFolder() const;
 };
 
 enum class DependencyLevel {
@@ -42,45 +42,52 @@ struct ContentPack {
     std::string version = "0.0";
     std::string creator = "";
     std::string description = "no description";
-    fs::path folder;
+    std::filesystem::path folder;
+    std::string path;
     std::vector<DependencyPack> dependencies;
     std::string source = "";
 
-    fs::path getContentFile() const;
+    std::filesystem::path getContentFile() const;
 
     static inline const std::string PACKAGE_FILENAME = "package.json";
     static inline const std::string CONTENT_FILENAME = "content.json";
-    static inline const fs::path BLOCKS_FOLDER = "blocks";
-    static inline const fs::path ITEMS_FOLDER = "items";
-    static inline const fs::path ENTITIES_FOLDER = "entities";
-    static inline const fs::path GENERATORS_FOLDER = "generators";
+    static inline const std::filesystem::path BLOCKS_FOLDER = "blocks";
+    static inline const std::filesystem::path ITEMS_FOLDER = "items";
+    static inline const std::filesystem::path ENTITIES_FOLDER = "entities";
+    static inline const std::filesystem::path GENERATORS_FOLDER = "generators";
     static const std::vector<std::string> RESERVED_NAMES;
 
-    static bool is_pack(const fs::path& folder);
-    static ContentPack read(const fs::path& folder);
+    static bool is_pack(const std::filesystem::path& folder);
+    static ContentPack read(
+        const std::string& path, const std::filesystem::path& folder
+    );
 
     static void scanFolder(
-        const fs::path& folder, std::vector<ContentPack>& packs
+        const std::string& path,
+        const std::filesystem::path& folder,
+        std::vector<ContentPack>& packs
     );
 
-    static std::vector<std::string> worldPacksList(const fs::path& folder);
+    static std::vector<std::string> worldPacksList(
+        const std::filesystem::path& folder
+    );
 
-    static fs::path findPack(
+    static std::filesystem::path findPack(
         const EnginePaths* paths,
-        const fs::path& worldDir,
+        const std::filesystem::path& worldDir,
         const std::string& name
     );
 
-    static ContentPack createCore(const EnginePaths*);
+    static ContentPack createCore(const EnginePaths&);
 
-    static inline fs::path getFolderFor(ContentType type) {
+    static inline std::filesystem::path getFolderFor(ContentType type) {
         switch (type) {
             case ContentType::BLOCK: return ContentPack::BLOCKS_FOLDER;
             case ContentType::ITEM: return ContentPack::ITEMS_FOLDER;
             case ContentType::ENTITY: return ContentPack::ENTITIES_FOLDER;
             case ContentType::GENERATOR: return ContentPack::GENERATORS_FOLDER;
-            case ContentType::NONE: return fs::u8path("");
-            default: return fs::u8path("");
+            case ContentType::NONE: return std::filesystem::u8path("");
+            default: return std::filesystem::u8path("");
         }
     }
 };
@@ -95,12 +102,13 @@ struct ContentPackStats {
     }
 };
 
-struct world_funcs_set {
-    bool onblockplaced : 1;
-    bool onblockreplaced : 1;
-    bool onblockbroken : 1;
-    bool onblockinteract : 1;
-    bool onplayertick : 1;
+struct WorldFuncsSet {
+    bool onblockplaced;
+    bool onblockreplaced;
+    bool onblockbreaking;
+    bool onblockbroken;
+    bool onblockinteract;
+    bool onplayertick;
 };
 
 class ContentPackRuntime {
@@ -108,7 +116,7 @@ class ContentPackRuntime {
     ContentPackStats stats {};
     scriptenv env;
 public:
-    world_funcs_set worldfuncsset {};
+    WorldFuncsSet worldfuncsset {};
 
     ContentPackRuntime(ContentPack info, scriptenv env);
     ~ContentPackRuntime();
diff --git a/src/content/PacksManager.cpp b/src/content/PacksManager.cpp
index 370bed989..fdf39bb32 100644
--- a/src/content/PacksManager.cpp
+++ b/src/content/PacksManager.cpp
@@ -7,7 +7,7 @@
 
 PacksManager::PacksManager() = default;
 
-void PacksManager::setSources(std::vector<fs::path> sources) {
+void PacksManager::setSources(std::vector<std::pair<std::string, fs::path>> sources) {
     this->sources = std::move(sources);
 }
 
@@ -15,8 +15,8 @@ void PacksManager::scan() {
     packs.clear();
 
     std::vector<ContentPack> packsList;
-    for (auto& folder : sources) {
-        ContentPack::scanFolder(folder, packsList);
+    for (auto& [path, folder] : sources) {
+        ContentPack::scanFolder(path, folder, packsList);
         for (auto& pack : packsList) {
             packs.try_emplace(pack.id, pack);
         }
@@ -116,7 +116,7 @@ static bool resolve_dependencies(
     return satisfied;
 }
 
-std::vector<std::string> PacksManager::assembly(
+std::vector<std::string> PacksManager::assemble(
     const std::vector<std::string>& names
 ) const {
     std::vector<std::string> allNames = names;
diff --git a/src/content/PacksManager.hpp b/src/content/PacksManager.hpp
index 3784bbfbc..b60b06ce1 100644
--- a/src/content/PacksManager.hpp
+++ b/src/content/PacksManager.hpp
@@ -10,12 +10,12 @@ namespace fs = std::filesystem;
 
 class PacksManager {
     std::unordered_map<std::string, ContentPack> packs;
-    std::vector<fs::path> sources;
+    std::vector<std::pair<std::string, fs::path>> sources;
 public:
     PacksManager();
 
     /// @brief Set content packs sources (search folders)
-    void setSources(std::vector<fs::path> sources);
+    void setSources(std::vector<std::pair<std::string, fs::path>> sources);
 
     /// @brief Scan sources and collect all found packs excluding duplication.
     /// Scanning order depends on sources order
@@ -38,7 +38,7 @@ class PacksManager {
     /// @return resulting ordered vector of pack names
     /// @throws contentpack_error if required dependency not found or
     /// circular dependency detected
-    std::vector<std::string> assembly(const std::vector<std::string>& names
+    std::vector<std::string> assemble(const std::vector<std::string>& names
     ) const;
 
     /// @brief Collect all pack names (identifiers) into a new vector
diff --git a/src/core_defs.cpp b/src/core_defs.cpp
index c62900f7f..fb8540baa 100644
--- a/src/core_defs.cpp
+++ b/src/core_defs.cpp
@@ -11,9 +11,9 @@
 #include "voxels/Block.hpp"
 
 // All in-game definitions (blocks, items, etc..)
-void corecontent::setup(EnginePaths* paths, ContentBuilder* builder) {
+void corecontent::setup(const EnginePaths& paths, ContentBuilder& builder) {
     {
-        Block& block = builder->blocks.create(CORE_AIR);
+        Block& block = builder.blocks.create(CORE_AIR);
         block.replaceable = true;
         block.drawGroup = 1;
         block.lightPassing = true;
@@ -24,11 +24,11 @@ void corecontent::setup(EnginePaths* paths, ContentBuilder* builder) {
         block.pickingItem = CORE_EMPTY;
     }
     {
-        ItemDef& item = builder->items.create(CORE_EMPTY);
+        ItemDef& item = builder.items.create(CORE_EMPTY);
         item.iconType = ItemIconType::NONE;
     }
 
-    auto bindsFile = paths->getResourcesFolder()/fs::path("bindings.toml");
+    auto bindsFile = paths.getResourcesFolder()/fs::path("bindings.toml");
     if (fs::is_regular_file(bindsFile)) {
         Events::loadBindings(
             bindsFile.u8string(), files::read_string(bindsFile), BindType::BIND
@@ -36,20 +36,20 @@ void corecontent::setup(EnginePaths* paths, ContentBuilder* builder) {
     }
 
     {
-        Block& block = builder->blocks.create(CORE_OBSTACLE);
+        Block& block = builder.blocks.create(CORE_OBSTACLE);
         for (uint i = 0; i < 6; i++) {
             block.textureFaces[i] = "obstacle";
         }
         block.hitboxes = {AABB()};
         block.breakable = false;
-        ItemDef& item = builder->items.create(CORE_OBSTACLE+".item");
+        ItemDef& item = builder.items.create(CORE_OBSTACLE+".item");
         item.iconType = ItemIconType::BLOCK;
         item.icon = CORE_OBSTACLE;
         item.placingBlock = CORE_OBSTACLE;
         item.caption = block.caption;
     }
     {
-        Block& block = builder->blocks.create(CORE_STRUCT_AIR);
+        Block& block = builder.blocks.create(CORE_STRUCT_AIR);
         for (uint i = 0; i < 6; i++) {
             block.textureFaces[i] = "struct_air";
         }
@@ -58,7 +58,7 @@ void corecontent::setup(EnginePaths* paths, ContentBuilder* builder) {
         block.lightPassing = true;
         block.hitboxes = {AABB()};
         block.obstacle = false;
-        ItemDef& item = builder->items.create(CORE_STRUCT_AIR+".item");
+        ItemDef& item = builder.items.create(CORE_STRUCT_AIR+".item");
         item.iconType = ItemIconType::BLOCK;
         item.icon = CORE_STRUCT_AIR;
         item.placingBlock = CORE_STRUCT_AIR;
diff --git a/src/core_defs.hpp b/src/core_defs.hpp
index 9f26b1c8a..8042ca362 100644
--- a/src/core_defs.hpp
+++ b/src/core_defs.hpp
@@ -21,12 +21,9 @@ inline const std::string BIND_MOVE_CROUCH = "movement.crouch";
 inline const std::string BIND_MOVE_CHEAT = "movement.cheat";
 inline const std::string BIND_CAM_ZOOM = "camera.zoom";
 inline const std::string BIND_CAM_MODE = "camera.mode";
-inline const std::string BIND_PLAYER_NOCLIP = "player.noclip";
-inline const std::string BIND_PLAYER_FLIGHT = "player.flight";
 inline const std::string BIND_PLAYER_ATTACK = "player.attack";
 inline const std::string BIND_PLAYER_DESTROY = "player.destroy";
 inline const std::string BIND_PLAYER_BUILD = "player.build";
-inline const std::string BIND_PLAYER_PICK = "player.pick";
 inline const std::string BIND_PLAYER_FAST_INTERACTOIN =
     "player.fast_interaction";
 inline const std::string BIND_HUD_INVENTORY = "hud.inventory";
@@ -35,5 +32,5 @@ class EnginePaths;
 class ContentBuilder;
 
 namespace corecontent {
-    void setup(EnginePaths* paths, ContentBuilder* builder);
+    void setup(const EnginePaths& paths, ContentBuilder& builder);
 }
diff --git a/src/data/StructLayout.cpp b/src/data/StructLayout.cpp
index a3e0fd233..3716bc44c 100644
--- a/src/data/StructLayout.cpp
+++ b/src/data/StructLayout.cpp
@@ -95,8 +95,8 @@ static inline FieldIncapatibilityType checkIncapatibility(
 
 static inline integer_t clamp_value(integer_t value, FieldType type) {
     auto typesize = sizeof_type(type) * CHAR_BIT;
-    integer_t minval = -(1 << (typesize-1));
-    integer_t maxval = (1 << (typesize-1))-1;
+    integer_t minval = -(1LL << (typesize-1));
+    integer_t maxval = (1LL << (typesize-1))-1;
     return std::min(maxval, std::max(minval, value));
 }
 
diff --git a/src/debug/Logger.cpp b/src/debug/Logger.cpp
index e8f4c95b7..970b2102d 100644
--- a/src/debug/Logger.cpp
+++ b/src/debug/Logger.cpp
@@ -23,10 +23,16 @@ Logger::Logger(std::string name) : name(std::move(name)) {
 void Logger::log(
     LogLevel level, const std::string& name, const std::string& message
 ) {
+    if (level == LogLevel::print) {
+        std::cout << "[" << name << "]    " << message << std::endl;
+        return;
+    }
+
     using namespace std::chrono;
 
     std::stringstream ss;
     switch (level) {
+        case LogLevel::print:
         case LogLevel::debug:
 #ifdef NDEBUG
             return;
diff --git a/src/debug/Logger.hpp b/src/debug/Logger.hpp
index 6b931fe0a..9505affd4 100644
--- a/src/debug/Logger.hpp
+++ b/src/debug/Logger.hpp
@@ -5,7 +5,7 @@
 #include <sstream>
 
 namespace debug {
-    enum class LogLevel { debug, info, warning, error };
+    enum class LogLevel { print, debug, info, warning, error };
 
     class Logger;
 
@@ -60,5 +60,10 @@ namespace debug {
         LogMessage warning() {
             return LogMessage(this, LogLevel::warning);
         }
+
+        /// @brief Print-debugging tool (printed without header)
+        LogMessage print() {
+            return LogMessage(this, LogLevel::print);
+        }
     };
 }
diff --git a/src/delegates.hpp b/src/delegates.hpp
index 324921643..0e670b413 100644
--- a/src/delegates.hpp
+++ b/src/delegates.hpp
@@ -8,6 +8,8 @@ using runnable = std::function<void()>;
 template<class T> using supplier = std::function<T()>;
 template<class T> using consumer = std::function<void(T)>;
 
+using KeyCallback = std::function<bool()>;
+
 // data sources
 using wstringsupplier = std::function<std::wstring()>;
 using doublesupplier = std::function<double()>;
diff --git a/src/devtools/syntax_highlighting.cpp b/src/devtools/syntax_highlighting.cpp
index f68780df8..2963daf2e 100644
--- a/src/devtools/syntax_highlighting.cpp
+++ b/src/devtools/syntax_highlighting.cpp
@@ -32,7 +32,6 @@ static std::unique_ptr<FontStylesScheme> build_styles(
             continue;
         }
         if (token.start.pos > offset) {
-            int n = token.start.pos - offset;
             styles.map.insert(styles.map.end(), token.start.pos - offset, 0);
         }
         offset = token.end.pos;
diff --git a/src/engine.cpp b/src/engine/Engine.cpp
similarity index 58%
rename from src/engine.cpp
rename to src/engine/Engine.cpp
index 129dc68db..9184fdd6d 100644
--- a/src/engine.cpp
+++ b/src/engine/Engine.cpp
@@ -1,6 +1,8 @@
-#include "engine.hpp"
+#include "Engine.hpp"
 
+#ifndef GLEW_STATIC
 #define GLEW_STATIC
+#endif
 
 #include "debug/Logger.hpp"
 #include "assets/AssetsLoader.hpp"
@@ -15,13 +17,10 @@
 #include "content/ContentLoader.hpp"
 #include "core_defs.hpp"
 #include "files/files.hpp"
-#include "files/settings_io.hpp"
 #include "frontend/locale.hpp"
 #include "frontend/menu.hpp"
 #include "frontend/screens/Screen.hpp"
-#include "frontend/screens/MenuScreen.hpp"
 #include "graphics/render/ModelsGenerator.hpp"
-#include "graphics/core/Batch2D.hpp"
 #include "graphics/core/DrawContext.hpp"
 #include "graphics/core/ImageData.hpp"
 #include "graphics/core/Shader.hpp"
@@ -30,6 +29,7 @@
 #include "logic/EngineController.hpp"
 #include "logic/CommandsInterpreter.hpp"
 #include "logic/scripting/scripting.hpp"
+#include "logic/scripting/scripting_hud.hpp"
 #include "network/Network.hpp"
 #include "util/listutil.hpp"
 #include "util/platform.hpp"
@@ -37,7 +37,9 @@
 #include "window/Events.hpp"
 #include "window/input.hpp"
 #include "window/Window.hpp"
-#include "settings.hpp"
+#include "world/Level.hpp"
+#include "Mainloop.hpp"
+#include "ServerMainloop.hpp"
 
 #include <iostream>
 #include <assert.h>
@@ -71,52 +73,69 @@ static std::unique_ptr<ImageData> load_icon(const fs::path& resdir) {
     return nullptr;
 }
 
-Engine::Engine(EngineSettings& settings, SettingsHandler& settingsHandler, EnginePaths* paths) 
-    : settings(settings), settingsHandler(settingsHandler), paths(paths),
+Engine::Engine(CoreParameters coreParameters)
+    : params(std::move(coreParameters)),
+      settings(),
+      settingsHandler({settings}),
       interpreter(std::make_unique<cmd::CommandsInterpreter>()),
-      network(network::Network::create(settings.network))
-{
-    paths->prepare();
+      network(network::Network::create(settings.network)) {
+    logger.info() << "engine version: " << ENGINE_VERSION_STRING;
+    if (params.headless) {
+        logger.info() << "headless mode is enabled";
+    }
+    paths.setResourcesFolder(params.resFolder);
+    paths.setUserFilesFolder(params.userFolder);
+    paths.prepare();
+    if (!params.scriptFile.empty()) {
+        paths.setScriptFolder(params.scriptFile.parent_path());
+    }
     loadSettings();
 
-    auto resdir = paths->getResourcesFolder();
+    auto resdir = paths.getResourcesFolder();
 
-    controller = std::make_unique<EngineController>(this);
-    if (Window::initialize(&this->settings.display)){
-        throw initialize_error("could not initialize window");
-    }
-    if (auto icon = load_icon(resdir)) {
-        icon->flipY();
-        Window::setIcon(icon.get());
+    controller = std::make_unique<EngineController>(*this);
+    if (!params.headless) {
+        if (Window::initialize(&settings.display)){
+            throw initialize_error("could not initialize window");
+        }
+        time.set(Window::time());
+        if (auto icon = load_icon(resdir)) {
+            icon->flipY();
+            Window::setIcon(icon.get());
+        }
+        loadControls();
+
+        gui = std::make_unique<gui::GUI>();
+        if (ENGINE_DEBUG_BUILD) {
+            menus::create_version_label(*this);
+        }
     }
-    loadControls();
-    audio::initialize(settings.audio.enabled.get());
+    audio::initialize(settings.audio.enabled.get() && !params.headless);
     create_channel(this, "master", settings.audio.volumeMaster);
     create_channel(this, "regular", settings.audio.volumeRegular);
     create_channel(this, "music", settings.audio.volumeMusic);
     create_channel(this, "ambient", settings.audio.volumeAmbient);
     create_channel(this, "ui", settings.audio.volumeUI);
 
-    gui = std::make_unique<gui::GUI>();
-    if (settings.ui.language.get() == "auto") {
+    bool langNotSet = settings.ui.language.get() == "auto";
+    if (langNotSet) {
         settings.ui.language.set(langs::locale_by_envlocale(
             platform::detect_locale(),
-            paths->getResourcesFolder()
+            paths.getResourcesFolder()
         ));
     }
-    if (ENGINE_DEBUG_BUILD) {
-        menus::create_version_label(this);
+    scripting::initialize(this);
+    if (!isHeadless()) {
+        gui->setPageLoader(scripting::create_page_loader());
     }
-    keepAlive(settings.ui.language.observe([=](auto lang) {
+    keepAlive(settings.ui.language.observe([this](auto lang) {
         setLanguage(lang);
     }, true));
-    
-    scripting::initialize(this);
     basePacks = files::read_list(resdir/fs::path("config/builtins.list"));
 }
 
 void Engine::loadSettings() {
-    fs::path settings_file = paths->getSettingsFile();
+    fs::path settings_file = paths.getSettingsFile();
     if (fs::is_regular_file(settings_file)) {
         logger.info() << "loading settings";
         std::string text = files::read_string(settings_file);
@@ -130,7 +149,7 @@ void Engine::loadSettings() {
 }
 
 void Engine::loadControls() {
-    fs::path controls_file = paths->getControlsFile();
+    fs::path controls_file = paths.getControlsFile();
     if (fs::is_regular_file(controls_file)) {
         logger.info() << "loading controls";
         std::string text = files::read_string(controls_file);
@@ -143,13 +162,6 @@ void Engine::onAssetsLoaded() {
     gui->onAssetsLoad(assets.get());
 }
 
-void Engine::updateTimers() {
-    frame++;
-    double currentTime = Window::time();
-    delta = currentTime - lastTime;
-    lastTime = currentTime;
-}
-
 void Engine::updateHotkeys() {
     if (Events::jpressed(keycode::F2)) {
         saveScreenshot();
@@ -162,67 +174,58 @@ void Engine::updateHotkeys() {
 void Engine::saveScreenshot() {
     auto image = Window::takeScreenshot();
     image->flipY();
-    fs::path filename = paths->getNewScreenshotFile("png");
+    fs::path filename = paths.getNewScreenshotFile("png");
     imageio::write(filename.string(), image.get());
     logger.info() << "saved screenshot as " << filename.u8string();
 }
 
-void Engine::mainloop() {
-    logger.info() << "starting menu screen";
-    setScreen(std::make_shared<MenuScreen>(this));
-
-    Batch2D batch(1024);
-    lastTime = Window::time();
-    
-    logger.info() << "engine started";
-    while (!Window::isShouldClose()){
-        assert(screen != nullptr);
-        updateTimers();
-        updateHotkeys();
-        audio::update(delta);
-
-        gui->act(delta, Viewport(Window::width, Window::height));
-        screen->update(delta);
+void Engine::run() {
+    if (params.headless) {
+        ServerMainloop(*this).run();
+    } else {
+        Mainloop(*this).run();
+    }
+}
 
-        if (!Window::isIconified()) {
-            renderFrame(batch);
-        }
-        Window::setFramerate(
-            Window::isIconified() && settings.display.limitFpsIconified.get()
-                ? 20
-                : settings.display.framerate.get()
-        );
+void Engine::postUpdate() {
+    network->update();
+    postRunnables.run();
+    scripting::process_post_runnables();
+}
 
-        network->update();
-        processPostRunnables();
+void Engine::updateFrontend() {
+    double delta = time.getDelta();
+    updateHotkeys();
+    audio::update(delta);
+    gui->act(delta, Viewport(Window::width, Window::height));
+    screen->update(delta);
+}
 
-        Window::swapBuffers();
-        Events::pollEvents();
-    }
+void Engine::nextFrame() {
+    Window::setFramerate(
+        Window::isIconified() && settings.display.limitFpsIconified.get()
+            ? 20
+            : settings.display.framerate.get()
+    );
+    Window::swapBuffers();
+    Events::pollEvents();
 }
 
-void Engine::renderFrame(Batch2D& batch) {
-    screen->draw(delta);
+void Engine::renderFrame() {
+    screen->draw(time.getDelta());
 
     Viewport viewport(Window::width, Window::height);
-    DrawContext ctx(nullptr, viewport, &batch);
+    DrawContext ctx(nullptr, viewport, nullptr);
     gui->draw(ctx, *assets);
 }
 
-void Engine::processPostRunnables() {
-    std::lock_guard<std::recursive_mutex> lock(postRunnablesMutex);
-    while (!postRunnables.empty()) {
-        postRunnables.front()();
-        postRunnables.pop();
-    }
-    scripting::process_post_runnables();
-}
-
 void Engine::saveSettings() {
     logger.info() << "saving settings";
-    files::write_string(paths->getSettingsFile(), toml::stringify(settingsHandler));
-    logger.info() << "saving bindings";
-    files::write_string(paths->getControlsFile(), Events::writeBindings());
+    files::write_string(paths.getSettingsFile(), toml::stringify(settingsHandler));
+    if (!params.headless) {
+        logger.info() << "saving bindings";
+        files::write_string(paths.getControlsFile(), Events::writeBindings());
+    }
 }
 
 Engine::~Engine() {
@@ -235,13 +238,19 @@ Engine::~Engine() {
     content.reset();
     assets.reset();
     interpreter.reset();
-    gui.reset();
-    logger.info() << "gui finished";
+    if (gui) {
+        gui.reset();
+        logger.info() << "gui finished";
+    }
     audio::close();
     network.reset();
+    clearKeepedObjects();
     scripting::close();
     logger.info() << "scripting finished";
-    Window::terminate();
+    if (!params.headless) {
+        Window::terminate();
+        logger.info() << "window closed";
+    }
     logger.info() << "engine finished";
 }
 
@@ -256,13 +265,17 @@ cmd::CommandsInterpreter* Engine::getCommandsInterpreter() {
 PacksManager Engine::createPacksManager(const fs::path& worldFolder) {
     PacksManager manager;
     manager.setSources({
-        worldFolder/fs::path("content"),
-        paths->getUserFilesFolder()/fs::path("content"),
-        paths->getResourcesFolder()/fs::path("content")
+        {"world:content", worldFolder.empty() ? worldFolder : worldFolder/fs::path("content")},
+        {"user:content", paths.getUserFilesFolder()/fs::path("content")},
+        {"res:content", paths.getResourcesFolder()/fs::path("content")}
     });
     return manager;
 }
 
+void Engine::setLevelConsumer(consumer<std::unique_ptr<Level>> levelConsumer) {
+    this->levelConsumer = std::move(levelConsumer);
+}
+
 void Engine::loadAssets() {
     logger.info() << "loading assets";
     Shader::preprocessor->setPaths(resPaths.get());
@@ -278,42 +291,36 @@ void Engine::loadAssets() {
         auto task = loader.startTask([=](){});
         task->waitForEnd();
     } else {
-        try {
-            while (loader.hasNext()) {
-                loader.loadNext();
-            }
-        } catch (const assetload::error& err) {
-            new_assets.reset();
-            throw;
+        while (loader.hasNext()) {
+            loader.loadNext();
         }
     }
     assets = std::move(new_assets);
-    
-    if (content) {
-        for (auto& [name, def] : content->blocks.getDefs()) {
-            if (def->model == BlockModel::custom) {
-                if (def->modelName.empty()) {
-                    assets->store(
-                        std::make_unique<model::Model>(
-                            ModelsGenerator::loadCustomBlockModel(
-                                def->customModelRaw, *assets, !def->shadeless
-                            )
-                        ),
-                        name + ".model"
-                    );
-                    def->modelName = def->name + ".model";
-                }
-            }
-        }
-        for (auto& [name, def] : content->items.getDefs()) {
+
+    if (content == nullptr) {
+        return;
+    }
+    for (auto& [name, def] : content->blocks.getDefs()) {
+        if (def->model == BlockModel::custom && def->modelName.empty()) {
             assets->store(
                 std::make_unique<model::Model>(
-                    ModelsGenerator::generate(*def, *content, *assets)
+                    ModelsGenerator::loadCustomBlockModel(
+                        def->customModelRaw, *assets, !def->shadeless
+                    )
                 ),
                 name + ".model"
             );
+            def->modelName = def->name + ".model";
         }
     }
+    for (auto& [name, def] : content->items.getDefs()) {
+        assets->store(
+            std::make_unique<model::Model>(
+                ModelsGenerator::generate(*def, *content, *assets)
+            ),
+            name + ".model"
+        );
+    }
 }
 
 static void load_configs(const fs::path& root) {
@@ -329,7 +336,7 @@ static void load_configs(const fs::path& root) {
 void Engine::loadContent() {
     scripting::cleanup();
 
-    auto resdir = paths->getResourcesFolder();
+    auto resdir = paths.getResourcesFolder();
 
     std::vector<std::string> names;
     for (auto& pack : contentPacks) {
@@ -337,12 +344,12 @@ void Engine::loadContent() {
     }
 
     ContentBuilder contentBuilder;
-    corecontent::setup(paths, &contentBuilder);
+    corecontent::setup(paths, contentBuilder);
 
-    paths->setContentPacks(&contentPacks);
-    PacksManager manager = createPacksManager(paths->getCurrentWorldFolder());
+    paths.setContentPacks(&contentPacks);
+    PacksManager manager = createPacksManager(paths.getCurrentWorldFolder());
     manager.scan();
-    names = manager.assembly(names);
+    names = manager.assemble(names);
     contentPacks = manager.getAll(names);
 
     auto corePack = ContentPack::createCore(paths);
@@ -372,13 +379,15 @@ void Engine::loadContent() {
     ContentLoader::loadScripts(*content);
 
     langs::setup(resdir, langs::current->getId(), contentPacks);
-    loadAssets();
-    onAssetsLoaded();
+    if (!isHeadless()) {
+        loadAssets();
+        onAssetsLoaded();
+    }
 }
 
 void Engine::resetContent() {
     scripting::cleanup();
-    auto resdir = paths->getResourcesFolder();
+    auto resdir = paths.getResourcesFolder();
     std::vector<PathsRoot> resRoots;
     {
         auto pack = ContentPack::createCore(paths);
@@ -395,8 +404,10 @@ void Engine::resetContent() {
     content.reset();
 
     langs::setup(resdir, langs::current->getId(), contentPacks);
-    loadAssets();
-    onAssetsLoaded();
+    if (!isHeadless()) {
+        loadAssets();
+        onAssetsLoaded();
+    }
 
     contentPacks = manager.getAll(basePacks);
 }
@@ -405,26 +416,23 @@ void Engine::loadWorldContent(const fs::path& folder) {
     contentPacks.clear();
     auto packNames = ContentPack::worldPacksList(folder);
     PacksManager manager;
-    manager.setSources({
-        folder/fs::path("content"),
-        paths->getUserFilesFolder()/fs::path("content"),
-        paths->getResourcesFolder()/fs::path("content")
-    });
+    manager.setSources(
+        {{"world:content",
+          folder.empty() ? folder : folder / fs::path("content")},
+         {"user:content", paths.getUserFilesFolder() / fs::path("content")},
+         {"res:content", paths.getResourcesFolder() / fs::path("content")}}
+    );
     manager.scan();
-    contentPacks = manager.getAll(manager.assembly(packNames));
-    paths->setCurrentWorldFolder(folder);
+    contentPacks = manager.getAll(manager.assemble(packNames));
+    paths.setCurrentWorldFolder(folder);
     loadContent();
 }
 
 void Engine::loadAllPacks() {
-    PacksManager manager = createPacksManager(paths->getCurrentWorldFolder());
+    PacksManager manager = createPacksManager(paths.getCurrentWorldFolder());
     manager.scan();
     auto allnames = manager.getAllNames();
-    contentPacks = manager.getAll(manager.assembly(allnames));
-}
-
-double Engine::getDelta() const {
-    return delta;
+    contentPacks = manager.getAll(manager.assemble(allnames));
 }
 
 void Engine::setScreen(std::shared_ptr<Screen> screen) {
@@ -435,8 +443,28 @@ void Engine::setScreen(std::shared_ptr<Screen> screen) {
 }
 
 void Engine::setLanguage(std::string locale) {
-    langs::setup(paths->getResourcesFolder(), std::move(locale), contentPacks);
-    gui->getMenu()->setPageLoader(menus::create_page_loader(this));
+    langs::setup(paths.getResourcesFolder(), std::move(locale), contentPacks);
+}
+
+void Engine::onWorldOpen(std::unique_ptr<Level> level) {
+    logger.info() << "world open";
+    levelConsumer(std::move(level));
+}
+
+void Engine::onWorldClosed() {
+    logger.info() << "world closed";
+    levelConsumer(nullptr);
+}
+
+void Engine::quit() {
+    quitSignal = true;
+    if (!isHeadless()) {
+        Window::setShouldClose(true);
+    }
+}
+
+bool Engine::isQuitSignal() const {
+    return quitSignal;
 }
 
 gui::GUI* Engine::getGUI() {
@@ -469,7 +497,7 @@ std::vector<std::string>& Engine::getBasePacks() {
     return basePacks;
 }
 
-EnginePaths* Engine::getPaths() {
+EnginePaths& Engine::getPaths() {
     return paths;
 }
 
@@ -481,11 +509,6 @@ std::shared_ptr<Screen> Engine::getScreen() {
     return screen;
 }
 
-void Engine::postRunnable(const runnable& callback) {
-    std::lock_guard<std::recursive_mutex> lock(postRunnablesMutex);
-    postRunnables.push(callback);
-}
-
 SettingsHandler& Engine::getSettingsHandler() {
     return settingsHandler;
 }
@@ -493,3 +516,15 @@ SettingsHandler& Engine::getSettingsHandler() {
 network::Network& Engine::getNetwork() {
     return *network;
 }
+
+Time& Engine::getTime() {
+    return time;
+}
+
+const CoreParameters& Engine::getCoreParameters() const {
+    return params;
+}
+
+bool Engine::isHeadless() const {
+    return params.headless;
+}
diff --git a/src/engine.hpp b/src/engine/Engine.hpp
similarity index 70%
rename from src/engine.hpp
rename to src/engine/Engine.hpp
index 04a221dff..af9f7fb9f 100644
--- a/src/engine.hpp
+++ b/src/engine/Engine.hpp
@@ -2,32 +2,32 @@
 
 #include "delegates.hpp"
 #include "typedefs.hpp"
+#include "settings.hpp"
 
 #include "assets/Assets.hpp"
 #include "content/content_fwd.hpp"
 #include "content/ContentPack.hpp"
 #include "content/PacksManager.hpp"
 #include "files/engine_paths.hpp"
+#include "files/settings_io.hpp"
 #include "util/ObjectsKeeper.hpp"
+#include "PostRunnables.hpp"
+#include "Time.hpp"
 
 #include <filesystem>
 #include <memory>
-#include <queue>
 #include <stdexcept>
 #include <string>
 #include <vector>
-#include <mutex>
 
+class Level;
 class Screen;
 class EnginePaths;
 class ResPaths;
-class Batch2D;
 class EngineController;
 class SettingsHandler;
 struct EngineSettings;
 
-namespace fs = std::filesystem;
-
 namespace gui {
     class GUI;
 }
@@ -45,44 +45,52 @@ class initialize_error : public std::runtime_error {
     initialize_error(const std::string& message) : std::runtime_error(message) {}
 };
 
+struct CoreParameters {
+    bool headless = false;
+    bool testMode = false;
+    std::filesystem::path resFolder {"res"};
+    std::filesystem::path userFolder {"."};
+    std::filesystem::path scriptFile;
+};
+
 class Engine : public util::ObjectsKeeper {
-    EngineSettings& settings;
-    SettingsHandler& settingsHandler;
-    EnginePaths* paths;
+    CoreParameters params;
+    EngineSettings settings;
+    SettingsHandler settingsHandler;
+    EnginePaths paths;
 
     std::unique_ptr<Assets> assets;
     std::shared_ptr<Screen> screen;
     std::vector<ContentPack> contentPacks;
     std::unique_ptr<Content> content;
     std::unique_ptr<ResPaths> resPaths;
-    std::queue<runnable> postRunnables;
-    std::recursive_mutex postRunnablesMutex;
     std::unique_ptr<EngineController> controller;
     std::unique_ptr<cmd::CommandsInterpreter> interpreter;
     std::unique_ptr<network::Network> network;
     std::vector<std::string> basePacks;
-
-    uint64_t frame = 0;
-    double lastTime = 0.0;
-    double delta = 0.0;
-
     std::unique_ptr<gui::GUI> gui;
+    PostRunnables postRunnables;
+    Time time;
+    consumer<std::unique_ptr<Level>> levelConsumer;
+    bool quitSignal = false;
     
     void loadControls();
     void loadSettings();
     void saveSettings();
-    void updateTimers();
     void updateHotkeys();
-    void renderFrame(Batch2D& batch);
-    void processPostRunnables();
     void loadAssets();
 public:
-    Engine(EngineSettings& settings, SettingsHandler& settingsHandler, EnginePaths* paths);
+    Engine(CoreParameters coreParameters);
     ~Engine();
- 
-    /// @brief Start main engine input/update/render loop. 
-    /// Automatically sets MenuScreen
-    void mainloop();
+
+    /// @brief Start the engine
+    void run();
+
+    void postUpdate();
+
+    void updateFrontend();
+    void renderFrame();
+    void nextFrame();
 
     /// @brief Called after assets loading when all engine systems are initialized
     void onAssetsLoaded();
@@ -100,6 +108,7 @@ class Engine : public util::ObjectsKeeper {
     /// @brief Load all selected content-packs and reload assets
     void loadContent();
 
+    /// @brief Reset content to base packs list
     void resetContent();
     
     /// @brief Collect world content-packs and load content
@@ -110,9 +119,6 @@ class Engine : public util::ObjectsKeeper {
     /// @brief Collect all available content-packs from res/content
     void loadAllPacks();
 
-    /// @brief Get current frame delta-time
-    double getDelta() const;
-
     /// @brief Get active assets storage instance
     Assets* getAssets();
     
@@ -123,11 +129,18 @@ class Engine : public util::ObjectsKeeper {
     EngineSettings& getSettings();
 
     /// @brief Get engine filesystem paths source
-    EnginePaths* getPaths();
+    EnginePaths& getPaths();
 
     /// @brief Get engine resource paths controller
     ResPaths* getResPaths();
 
+    void onWorldOpen(std::unique_ptr<Level> level);
+    void onWorldClosed();
+
+    void quit();
+
+    bool isQuitSignal() const;
+
     /// @brief Get current Content instance
     const Content* getContent() const;
 
@@ -142,7 +155,9 @@ class Engine : public util::ObjectsKeeper {
     std::shared_ptr<Screen> getScreen();
 
     /// @brief Enqueue function call to the end of current frame in draw thread
-    void postRunnable(const runnable& callback);
+    void postRunnable(const runnable& callback) {
+        postRunnables.postRunnable(callback);
+    }
 
     void saveScreenshot();
 
@@ -151,7 +166,15 @@ class Engine : public util::ObjectsKeeper {
 
     PacksManager createPacksManager(const fs::path& worldFolder);
 
+    void setLevelConsumer(consumer<std::unique_ptr<Level>> levelConsumer);
+
     SettingsHandler& getSettingsHandler();
 
     network::Network& getNetwork();
+
+    Time& getTime();
+
+    const CoreParameters& getCoreParameters() const;
+
+    bool isHeadless() const;
 };
diff --git a/src/engine/Mainloop.cpp b/src/engine/Mainloop.cpp
new file mode 100644
index 000000000..e0e64d10c
--- /dev/null
+++ b/src/engine/Mainloop.cpp
@@ -0,0 +1,43 @@
+#include "Mainloop.hpp"
+
+#include "Engine.hpp"
+#include "debug/Logger.hpp"
+#include "frontend/screens/MenuScreen.hpp"
+#include "frontend/screens/LevelScreen.hpp"
+#include "window/Window.hpp"
+#include "world/Level.hpp"
+
+static debug::Logger logger("mainloop");
+
+Mainloop::Mainloop(Engine& engine) : engine(engine) {
+}
+
+void Mainloop::run() {
+    auto& time = engine.getTime();
+
+    engine.setLevelConsumer([this](auto level) {
+        if (level == nullptr) {
+            // destroy LevelScreen and run quit callbacks
+            engine.setScreen(nullptr);
+            // create and go to menu screen
+            engine.setScreen(std::make_shared<MenuScreen>(engine));
+        } else {
+            engine.setScreen(std::make_shared<LevelScreen>(engine, std::move(level)));
+        }
+    });
+
+    logger.info() << "starting menu screen";
+    engine.setScreen(std::make_shared<MenuScreen>(engine));
+    
+    logger.info() << "main loop started";
+    while (!Window::isShouldClose()){
+        time.update(Window::time());
+        engine.updateFrontend();
+        if (!Window::isIconified()) {
+            engine.renderFrame();
+        }
+        engine.postUpdate();
+        engine.nextFrame();
+    }
+    logger.info() << "main loop stopped";
+}
diff --git a/src/engine/Mainloop.hpp b/src/engine/Mainloop.hpp
new file mode 100644
index 000000000..3cd2f608f
--- /dev/null
+++ b/src/engine/Mainloop.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+class Engine;
+
+class Mainloop {
+    Engine& engine;
+public:
+    Mainloop(Engine& engine);
+
+    void run();
+};
diff --git a/src/engine/PostRunnables.hpp b/src/engine/PostRunnables.hpp
new file mode 100644
index 000000000..dc227c889
--- /dev/null
+++ b/src/engine/PostRunnables.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <queue>
+#include <mutex>
+#include "delegates.hpp"
+
+class PostRunnables {
+    std::queue<runnable> runnables;
+    std::recursive_mutex mutex;
+public:
+    void postRunnable(runnable task) {
+        std::lock_guard<std::recursive_mutex> lock(mutex);
+        runnables.push(std::move(task));
+    }
+
+    void run() {
+        std::queue<runnable> tasksToRun;
+        {
+            std::lock_guard<std::recursive_mutex> lock(mutex);
+            std::swap(tasksToRun, runnables);
+        }
+
+        while (!tasksToRun.empty()) {
+            auto& task = tasksToRun.front();
+            task();
+            tasksToRun.pop();
+        }
+    }
+};
diff --git a/src/engine/ServerMainloop.cpp b/src/engine/ServerMainloop.cpp
new file mode 100644
index 000000000..eb570e7bf
--- /dev/null
+++ b/src/engine/ServerMainloop.cpp
@@ -0,0 +1,86 @@
+#include "ServerMainloop.hpp"
+
+#include "Engine.hpp"
+#include "logic/scripting/scripting.hpp"
+#include "logic/LevelController.hpp"
+#include "interfaces/Process.hpp"
+#include "debug/Logger.hpp"
+#include "world/Level.hpp"
+#include "world/World.hpp"
+#include "util/platform.hpp"
+
+#include <chrono>
+
+using namespace std::chrono;
+
+static debug::Logger logger("mainloop");
+
+inline constexpr int TPS = 20;
+
+ServerMainloop::ServerMainloop(Engine& engine) : engine(engine) {
+}
+
+ServerMainloop::~ServerMainloop() = default;
+
+void ServerMainloop::run() {
+    const auto& coreParams = engine.getCoreParameters();
+    auto& time = engine.getTime();
+
+    if (coreParams.scriptFile.empty()) {
+        logger.info() << "nothing to do";
+        return;
+    }
+    engine.setLevelConsumer([this](auto level) {
+        setLevel(std::move(level));
+    });
+
+    logger.info() << "starting test " << coreParams.scriptFile;
+    auto process = scripting::start_coroutine(coreParams.scriptFile);
+
+    double targetDelta = 1.0 / static_cast<double>(TPS);
+    double delta = targetDelta;
+    auto begin = system_clock::now();
+    auto startupTime = begin;
+
+    while (process->isActive()) {
+        if (engine.isQuitSignal()) {
+            process->terminate();
+            logger.info() << "script has been terminated due to quit signal";
+            break;
+        }
+        if (coreParams.testMode) {
+            time.step(delta);
+        } else {
+            auto now = system_clock::now();
+            time.update(
+                duration_cast<microseconds>(now - startupTime).count() / 1e6);
+            delta = time.getDelta();
+        }
+        process->update();
+        if (controller) {
+            controller->getLevel()->getWorld()->updateTimers(delta);
+            controller->update(glm::min(delta, 0.2), false);
+        }
+        engine.postUpdate();
+
+        if (!coreParams.testMode) {
+            auto end = system_clock::now();
+            platform::sleep(targetDelta * 1000 - 
+                duration_cast<microseconds>(end - begin).count() / 1000);
+            begin = system_clock::now();
+        }
+    }
+    logger.info() << "test finished";
+}
+
+void ServerMainloop::setLevel(std::unique_ptr<Level> level) {
+    if (level == nullptr) {
+        controller->onWorldQuit();
+        engine.getPaths().setCurrentWorldFolder(fs::path());
+        controller = nullptr;
+    } else {
+        controller = std::make_unique<LevelController>(
+            &engine, std::move(level), nullptr
+        );
+    }
+}
diff --git a/src/engine/ServerMainloop.hpp b/src/engine/ServerMainloop.hpp
new file mode 100644
index 000000000..28cfbd9de
--- /dev/null
+++ b/src/engine/ServerMainloop.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <memory>
+
+class Level;
+class LevelController;
+class Engine;
+
+class ServerMainloop {
+    Engine& engine;
+    std::unique_ptr<LevelController> controller;
+public:
+    ServerMainloop(Engine& engine);
+    ~ServerMainloop();
+
+    void run();
+
+    void setLevel(std::unique_ptr<Level> level);
+};
diff --git a/src/engine/Time.hpp b/src/engine/Time.hpp
new file mode 100644
index 000000000..9f914b1fc
--- /dev/null
+++ b/src/engine/Time.hpp
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <stdint.h>
+
+class Time {
+    uint64_t frame = 0;
+    double lastTime = 0.0;
+    double delta = 0.0;
+public:
+    Time() {}
+
+    void update(double currentTime) {
+        frame++;
+        delta = currentTime - lastTime;
+        lastTime = currentTime;
+    }
+
+    void step(double delta) {
+        frame++;
+        lastTime += delta;
+        this->delta = delta;
+    }
+
+    void set(double currentTime) {
+        lastTime = currentTime;
+    }
+
+    double getDelta() const {
+        return delta;
+    }
+
+    double getTime() const {
+        return lastTime;
+    }
+};
diff --git a/src/files/WorldFiles.cpp b/src/files/WorldFiles.cpp
index c99ee8ef0..3759c96b1 100644
--- a/src/files/WorldFiles.cpp
+++ b/src/files/WorldFiles.cpp
@@ -159,9 +159,9 @@ std::optional<WorldInfo> WorldFiles::readWorldInfo() {
 }
 
 static void read_resources_data(
-    const Content* content, const dv::value& list, ResourceType type
+    const Content& content, const dv::value& list, ResourceType type
 ) {
-    const auto& indices = content->getIndices(type);
+    const auto& indices = content.getIndices(type);
     for (size_t i = 0; i < list.size(); i++) {
         auto& map = list[i];
         const auto& name = map["name"].asString();
@@ -174,7 +174,7 @@ static void read_resources_data(
     }
 }
 
-bool WorldFiles::readResourcesData(const Content* content) {
+bool WorldFiles::readResourcesData(const Content& content) {
     fs::path file = getResourcesFile();
     if (!fs::is_regular_file(file)) {
         logger.warning() << "resources.json does not exists";
diff --git a/src/files/WorldFiles.hpp b/src/files/WorldFiles.hpp
index 7f72e1463..2d8ff0f0a 100644
--- a/src/files/WorldFiles.hpp
+++ b/src/files/WorldFiles.hpp
@@ -49,7 +49,7 @@ class WorldFiles {
     void createDirectories();
 
     std::optional<WorldInfo> readWorldInfo();
-    bool readResourcesData(const Content* content);
+    bool readResourcesData(const Content& content);
 
     static void createContentIndicesCache(
         const ContentIndices* indices, dv::value& root
diff --git a/src/files/engine_paths.cpp b/src/files/engine_paths.cpp
index d92518970..2c8cd02cc 100644
--- a/src/files/engine_paths.cpp
+++ b/src/files/engine_paths.cpp
@@ -48,6 +48,18 @@ static std::filesystem::path toCanonic(std::filesystem::path path) {
 }
 
 void EnginePaths::prepare() {
+    if (!fs::is_directory(resourcesFolder)) {
+        throw std::runtime_error(
+            resourcesFolder.u8string() + " is not a directory"
+        );
+    }
+    if (!fs::is_directory(userFilesFolder)) {
+        fs::create_directories(userFilesFolder);
+    }
+
+    logger.info() << "resources folder: " << fs::canonical(resourcesFolder).u8string();
+    logger.info() << "user files folder: " << fs::canonical(userFilesFolder).u8string();
+    
     auto contentFolder = userFilesFolder / CONTENT_FOLDER;
     if (!fs::is_directory(contentFolder)) {
         fs::create_directories(contentFolder);
@@ -120,7 +132,7 @@ std::filesystem::path EnginePaths::getSettingsFile() const {
     return userFilesFolder / SETTINGS_FILE;
 }
 
-std::vector<std::filesystem::path> EnginePaths::scanForWorlds() {
+std::vector<std::filesystem::path> EnginePaths::scanForWorlds() const {
     std::vector<std::filesystem::path> folders;
 
     auto folder = getWorldsFolder();
@@ -157,6 +169,10 @@ void EnginePaths::setResourcesFolder(std::filesystem::path folder) {
     this->resourcesFolder = std::move(folder);
 }
 
+void EnginePaths::setScriptFolder(std::filesystem::path folder) {
+    this->scriptFolder = std::move(folder);
+}
+
 void EnginePaths::setCurrentWorldFolder(std::filesystem::path folder) {
     this->currentWorldFolder = std::move(folder);
 }
@@ -177,7 +193,7 @@ std::tuple<std::string, std::string> EnginePaths::parsePath(std::string_view pat
 
 std::filesystem::path EnginePaths::resolve(
     const std::string& path, bool throwErr
-) {
+) const {
     auto [prefix, filename] = EnginePaths::parsePath(path);
     if (prefix.empty()) {
         throw files_access_error("no entry point specified");
@@ -199,7 +215,9 @@ std::filesystem::path EnginePaths::resolve(
     if (prefix == "export") {
         return userFilesFolder / EXPORT_FOLDER / fs::u8path(filename);
     }
-
+    if (prefix == "script" && scriptFolder) {
+        return scriptFolder.value() / fs::u8path(filename);
+    }
     if (contentPacks) {
         for (auto& pack : *contentPacks) {
             if (pack.id == prefix) {
diff --git a/src/files/engine_paths.hpp b/src/files/engine_paths.hpp
index c52892437..5ec347046 100644
--- a/src/files/engine_paths.hpp
+++ b/src/files/engine_paths.hpp
@@ -2,6 +2,7 @@
 
 #include <filesystem>
 #include <stdexcept>
+#include <optional>
 #include <string>
 #include <vector>
 #include <tuple>
@@ -26,6 +27,8 @@ class EnginePaths {
     void setResourcesFolder(std::filesystem::path folder);
     std::filesystem::path getResourcesFolder() const;
 
+    void setScriptFolder(std::filesystem::path folder);
+
     std::filesystem::path getWorldFolderByName(const std::string& name);
     std::filesystem::path getWorldsFolder() const;
     std::filesystem::path getConfigFolder() const;
@@ -39,9 +42,9 @@ class EnginePaths {
 
     void setContentPacks(std::vector<ContentPack>* contentPacks);
 
-    std::vector<std::filesystem::path> scanForWorlds();
+    std::vector<std::filesystem::path> scanForWorlds() const;
 
-    std::filesystem::path resolve(const std::string& path, bool throwErr = true);
+    std::filesystem::path resolve(const std::string& path, bool throwErr = true) const;
 
     static std::tuple<std::string, std::string> parsePath(std::string_view view);
 
@@ -51,6 +54,7 @@ class EnginePaths {
     std::filesystem::path userFilesFolder {"."};
     std::filesystem::path resourcesFolder {"res"};
     std::filesystem::path currentWorldFolder;
+    std::optional<std::filesystem::path> scriptFolder;
     std::vector<ContentPack>* contentPacks = nullptr;
 };
 
diff --git a/src/files/settings_io.cpp b/src/files/settings_io.cpp
index fe251a11e..f5f1341b0 100644
--- a/src/files/settings_io.cpp
+++ b/src/files/settings_io.cpp
@@ -73,6 +73,7 @@ SettingsHandler::SettingsHandler(EngineSettings& settings) {
     builder.add("frustum-culling", &settings.graphics.frustumCulling);
     builder.add("skybox-resolution", &settings.graphics.skyboxResolution);
     builder.add("chunk-max-vertices", &settings.graphics.chunkMaxVertices);
+    builder.add("chunk-max-vertices-dense", &settings.graphics.chunkMaxVerticesDense);
     builder.add("chunk-max-renderers", &settings.graphics.chunkMaxRenderers);
 
     builder.section("ui");
diff --git a/src/frontend/LevelFrontend.cpp b/src/frontend/LevelFrontend.cpp
index d3cbb9e8d..1bc6e9e23 100644
--- a/src/frontend/LevelFrontend.cpp
+++ b/src/frontend/LevelFrontend.cpp
@@ -23,18 +23,18 @@ LevelFrontend::LevelFrontend(
       controller(controller),
       assets(assets),
       contentCache(std::make_unique<ContentGfxCache>(
-          *level.content, assets, settings.graphics
+          level.content, assets, settings.graphics
       )) {
     assets.store(
         BlocksPreview::build(
-            *contentCache, assets, *level.content->getIndices()
+            *contentCache, assets, *level.content.getIndices()
         ),
         "block-previews"
     );
     controller->getBlocksController()->listenBlockInteraction(
         [currentPlayer, controller, &assets](auto player, const auto& pos, const auto& def, BlockInteraction type) {
             const auto& level = *controller->getLevel();
-            auto material = level.content->findBlockMaterial(def.material);
+            auto material = level.content.findBlockMaterial(def.material);
             if (material == nullptr) {
                 return;
             }
diff --git a/src/frontend/debug_panel.cpp b/src/frontend/debug_panel.cpp
index 9043f5b9d..a234c38aa 100644
--- a/src/frontend/debug_panel.cpp
+++ b/src/frontend/debug_panel.cpp
@@ -1,6 +1,6 @@
 #include "audio/audio.hpp"
 #include "delegates.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "settings.hpp"
 #include "hud.hpp"
 #include "content/Content.hpp"
@@ -21,6 +21,7 @@
 #include "voxels/Block.hpp"
 #include "voxels/Chunk.hpp"
 #include "voxels/Chunks.hpp"
+#include "voxels/GlobalChunks.hpp"
 #include "world/Level.hpp"
 #include "world/World.hpp"
 
@@ -41,7 +42,7 @@ static std::shared_ptr<Label> create_label(wstringsupplier supplier) {
 // TODO: move to xml
 // TODO: move to xml finally
 std::shared_ptr<UINode> create_debug_panel(
-    Engine* engine, 
+    Engine& engine, 
     Level& level, 
     Player& player,
     bool allowDebugCheats
@@ -55,8 +56,8 @@ std::shared_ptr<UINode> create_debug_panel(
     static int fpsMax = fps;
     static std::wstring fpsString = L"";
 
-    panel->listenInterval(0.016f, [engine]() {
-        fps = 1.0f / engine->getDelta();
+    panel->listenInterval(0.016f, [&engine]() {
+        fps = 1.0f / engine.getTime().getDelta();
         fpsMin = std::min(fps, fpsMin);
         fpsMax = std::max(fps, fpsMax);
     });
@@ -83,8 +84,8 @@ std::shared_ptr<UINode> create_debug_panel(
     panel->add(create_label([]() {
         return L"lua-stack: " + std::to_wstring(scripting::get_values_on_stack());
     }));
-    panel->add(create_label([=]() {
-        auto& settings = engine->getSettings();
+    panel->add(create_label([&engine]() {
+        auto& settings = engine.getSettings();
         bool culling = settings.graphics.frustumCulling.get();
         return L"frustum-culling: "+std::wstring(culling ? L"on" : L"off");
     }));
@@ -95,7 +96,7 @@ std::shared_ptr<UINode> create_debug_panel(
                std::to_wstring(ParticlesRenderer::aliveEmitters);
     }));
     panel->add(create_label([&]() {
-        return L"chunks: "+std::to_wstring(level.chunks->getChunksCount())+
+        return L"chunks: "+std::to_wstring(level.chunks->size())+
                L" visible: "+std::to_wstring(ChunksRenderer::visibleChunks);
     }));
     panel->add(create_label([&]() {
@@ -137,7 +138,7 @@ std::shared_ptr<UINode> create_debug_panel(
         }
     }));
     panel->add(create_label([&](){
-        auto* indices = level.content->getIndices();
+        auto indices = level.content.getIndices();
         if (auto def = indices->blocks.get(player.selection.vox.id)) {
             return L"name: " + util::str2wstr_utf8(def->name);
         } else {
diff --git a/src/frontend/hud.cpp b/src/frontend/hud.cpp
index 01252c4c3..3bf7cab2b 100644
--- a/src/frontend/hud.cpp
+++ b/src/frontend/hud.cpp
@@ -8,7 +8,7 @@
 #include "content/Content.hpp"
 #include "core_defs.hpp"
 #include "delegates.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "graphics/core/Atlas.hpp"
 #include "graphics/core/Batch2D.hpp"
 #include "graphics/core/Batch3D.hpp"
@@ -40,7 +40,7 @@
 #include "voxels/Block.hpp"
 #include "voxels/Chunk.hpp"
 #include "voxels/Chunks.hpp"
-#include "voxels/ChunksStorage.hpp"
+#include "voxels/GlobalChunks.hpp"
 #include "window/Camera.hpp"
 #include "window/Events.hpp"
 #include "window/input.hpp"
@@ -62,8 +62,8 @@ static debug::Logger logger("hud");
 bool Hud::showGeneratorMinimap = false;
 
 // implemented in debug_panel.cpp
-extern std::shared_ptr<UINode> create_debug_panel(
-    Engine* engine,
+std::shared_ptr<UINode> create_debug_panel(
+    Engine& engine,
     Level& level,
     Player& player,
     bool allowDebugCheats
@@ -107,9 +107,9 @@ std::shared_ptr<UINode> HudElement::getNode() const {
 }
 
 std::shared_ptr<InventoryView> Hud::createContentAccess() {
-    auto content = frontend.getLevel().content;
-    auto indices = content->getIndices();
-    auto inventory = player->getInventory();
+    auto& content = frontend.getLevel().content;
+    auto indices = content.getIndices();
+    auto inventory = player.getInventory();
     
     size_t itemsCount = indices->items.count();
     auto accessInventory = std::make_shared<Inventory>(0, itemsCount);
@@ -123,20 +123,20 @@ std::shared_ptr<InventoryView> Hud::createContentAccess() {
         inventory->move(copy, indices);
     }, 
     [=](uint, ItemStack& item) {
-        inventory->getSlot(player->getChosenSlot()).set(item);
+        inventory->getSlot(player.getChosenSlot()).set(item);
     });
 
     InventoryBuilder builder;
     builder.addGrid(8, itemsCount-1, glm::vec2(), glm::vec4(8, 8, 12, 8), true, slotLayout);
     auto view = builder.build();
-    view->bind(accessInventory, content);
+    view->bind(accessInventory, &content);
     view->setMargin(glm::vec4());
     return view;
 }
 
 std::shared_ptr<InventoryView> Hud::createHotbar() {
-    auto inventory = player->getInventory();
-    auto content = frontend.getLevel().content;
+    auto inventory = player.getInventory();
+    auto& content = frontend.getLevel().content;
 
     SlotLayout slotLayout(-1, glm::vec2(), false, false, nullptr, nullptr, nullptr);
     InventoryBuilder builder;
@@ -144,17 +144,17 @@ std::shared_ptr<InventoryView> Hud::createHotbar() {
     auto view = builder.build();
     view->setId("hud.hotbar");
     view->setOrigin(glm::vec2(view->getSize().x/2, 0));
-    view->bind(inventory, content);
+    view->bind(inventory, &content);
     view->setInteractive(false);
     return view;
 }
 
 static constexpr uint WORLDGEN_IMG_SIZE = 128U;
 
-Hud::Hud(Engine* engine, LevelFrontend& frontend, Player* player)
+Hud::Hud(Engine& engine, LevelFrontend& frontend, Player& player)
     : engine(engine),
-      assets(engine->getAssets()),
-      gui(engine->getGUI()),
+      assets(*engine.getAssets()),
+      gui(*engine.getGUI()),
       frontend(frontend),
       player(player),
       debugImgWorldGen(std::make_unique<ImageData>(
@@ -180,27 +180,38 @@ Hud::Hud(Engine* engine, LevelFrontend& frontend, Player* player)
     uicamera->flipped = true;
 
     debugPanel = create_debug_panel(
-        engine, frontend.getLevel(), *player, allowDebugCheats
+        engine, frontend.getLevel(), player, allowDebugCheats
     );
     debugPanel->setZIndex(2);
-    gui->add(debugPanel);
+    gui.add(debugPanel);
     
-    gui->add(darkOverlay);
-    gui->add(hotbarView);
-    gui->add(contentAccessPanel);
+    gui.add(darkOverlay);
+    gui.add(hotbarView);
+    gui.add(contentAccessPanel);
 
     auto dplotter = std::make_shared<Plotter>(350, 250, 2000, 16);
     dplotter->setGravity(Gravity::bottom_right);
     dplotter->setInteractive(false);
     add(HudElement(hud_element_mode::permanent, nullptr, dplotter, true));
 
-    assets->store(Texture::from(debugImgWorldGen.get()), DEBUG_WORLDGEN_IMAGE);
+    assets.store(Texture::from(debugImgWorldGen.get()), DEBUG_WORLDGEN_IMAGE);
 
     debugMinimap = guiutil::create(
             "<image src='"+DEBUG_WORLDGEN_IMAGE+
             "' pos='0' size='256' gravity='top-right' margin='0,20,0,0'/>"
         );
     add(HudElement(hud_element_mode::permanent, nullptr, debugMinimap, true));
+
+    keepAlive(Events::keyCallbacks[keycode::ESCAPE].add([this]() -> bool {
+        if (pause) {
+            setPause(false);
+        } else if (inventoryOpen) {
+            closeInventory();
+        } else {
+            setPause(true);
+        }
+        return false;
+    }));
 }
 
 Hud::~Hud() {
@@ -208,10 +219,10 @@ Hud::~Hud() {
     for (auto& element : elements) {
         onRemove(element);
     }
-    gui->remove(hotbarView);
-    gui->remove(darkOverlay);
-    gui->remove(contentAccessPanel);
-    gui->remove(debugPanel);
+    gui.remove(hotbarView);
+    gui.remove(darkOverlay);
+    gui.remove(contentAccessPanel);
+    gui.remove(debugPanel);
 }
 
 /// @brief Remove all elements marked as removed
@@ -223,15 +234,6 @@ void Hud::cleanup() {
 }
 
 void Hud::processInput(bool visible) {
-    if (Events::jpressed(keycode::ESCAPE)) {
-        if (pause) {
-            setPause(false);
-        } else if (inventoryOpen) {
-            closeInventory();
-        } else {
-            setPause(true);
-        }
-    }
     if (!Window::isFocused() && !pause && !isInventoryOpen()) {
         setPause(true);
     }
@@ -249,12 +251,12 @@ void Hud::processInput(bool visible) {
 
 void Hud::updateHotbarControl() {
     if (!inventoryOpen && Events::scroll) {
-        int slot = player->getChosenSlot();
+        int slot = player.getChosenSlot();
         slot = (slot - Events::scroll) % 10;
         if (slot < 0) {
             slot += 10;
         }
-        player->setChosenSlot(slot);
+        player.setChosenSlot(slot);
     }
     for (
         int i = static_cast<int>(keycode::NUM_1); 
@@ -262,16 +264,17 @@ void Hud::updateHotbarControl() {
         i++
     ) {
         if (Events::jpressed(i)) {
-            player->setChosenSlot(i - static_cast<int>(keycode::NUM_1));
+            player.setChosenSlot(i - static_cast<int>(keycode::NUM_1));
         }
     }
     if (Events::jpressed(keycode::NUM_0)) {
-        player->setChosenSlot(9);
+        player.setChosenSlot(9);
     }
 }
 
 void Hud::updateWorldGenDebugVisualization() {
     auto& level = frontend.getLevel();
+    const auto& chunks = *player.chunks;
     auto generator =
         frontend.getController()->getChunksController()->getGenerator();
     auto debugInfo = generator->createDebugInfo();
@@ -288,17 +291,15 @@ void Hud::updateWorldGenDebugVisualization() {
 
     for (int z = 0; z < height; z++) {
         for (int x = 0; x < width; x++) {
-            int cx = x + ox;
-            int cz = z + oz;
             int flippedZ = height - z - 1;
 
             int ax = x - (width - areaWidth) / 2;
             int az = z - (height - areaHeight) / 2;
 
             data[(flippedZ * width + x) * 4 + 1] = 
-                level.chunks->getChunk(ax + ox, az + oz) ? 255 : 0;
+                chunks.getChunk(ax + ox, az + oz) ? 255 : 0;
             data[(flippedZ * width + x) * 4 + 0] = 
-                level.chunksStorage->get(ax + ox, az + oz) ? 255 : 0;
+                level.chunks->fetch(ax + ox, az + oz) ? 255 : 0;
 
             if (ax < 0 || az < 0 || 
                 ax >= areaWidth || az >= areaHeight) {
@@ -314,15 +315,16 @@ void Hud::updateWorldGenDebugVisualization() {
             data[(flippedZ * width + x) * 4 + 3] = 150;
         }
     }
-    auto texture = assets->get<Texture>(DEBUG_WORLDGEN_IMAGE);
-    texture->reload(*debugImgWorldGen);
+    auto& texture = assets.require<Texture>(DEBUG_WORLDGEN_IMAGE);
+    texture.reload(*debugImgWorldGen);
 }
 
 void Hud::update(bool visible) {
     const auto& level = frontend.getLevel();
-    auto menu = gui->getMenu();
+    const auto& chunks = *player.chunks;
+    const auto& menu = gui.getMenu();
 
-    debugPanel->setVisible(player->debug && visible);
+    debugPanel->setVisible(debug && visible);
 
     if (!visible && inventoryOpen) {
         closeInventory();
@@ -331,7 +333,7 @@ void Hud::update(bool visible) {
         setPause(false);
     }
 
-    if (!gui->isFocusCaught()) {
+    if (!gui.isFocusCaught()) {
         processInput(visible);
     }
     if ((pause || inventoryOpen) == Events::_cursor_locked) {
@@ -339,7 +341,7 @@ void Hud::update(bool visible) {
     }
 
     if (blockUI) {
-        voxel* vox = level.chunks->get(blockPos.x, blockPos.y, blockPos.z);
+        voxel* vox = chunks.get(blockPos.x, blockPos.y, blockPos.z);
         if (vox == nullptr || vox->id != currentblockid) {
             closeInventory();
         }
@@ -357,7 +359,7 @@ void Hud::update(bool visible) {
 
     if (visible) {
         for (auto& element : elements) {
-            element.update(pause, inventoryOpen, player->debug);
+            element.update(pause, inventoryOpen, debug);
             if (element.isRemoved()) {
                 onRemove(element);
             }
@@ -365,22 +367,22 @@ void Hud::update(bool visible) {
     }
     cleanup();
 
-    debugMinimap->setVisible(player->debug && showGeneratorMinimap);
-    if (player->debug && showGeneratorMinimap) {
+    debugMinimap->setVisible(debug && showGeneratorMinimap);
+    if (debug && showGeneratorMinimap) {
         updateWorldGenDebugVisualization();
     }
 }
 
 /// @brief Show inventory on the screen and turn on inventory mode blocking movement
 void Hud::openInventory() {
-    auto content = frontend.getLevel().content;
+    auto& content = frontend.getLevel().content;
     showExchangeSlot();
 
     inventoryOpen = true;
-    auto inventory = player->getInventory();
-    auto inventoryDocument = assets->get<UiDocument>("core:inventory");
+    auto inventory = player.getInventory();
+    auto inventoryDocument = assets.get<UiDocument>("core:inventory");
     inventoryView = std::dynamic_pointer_cast<InventoryView>(inventoryDocument->getRoot());
-    inventoryView->bind(inventory, content);
+    inventoryView->bind(inventory, &content);
     add(HudElement(hud_element_mode::inventory_bound, inventoryDocument, inventoryView, false));
     add(HudElement(hud_element_mode::inventory_bound, nullptr, exchangeSlot, false));
 }
@@ -394,7 +396,7 @@ std::shared_ptr<Inventory> Hud::openInventory(
         closeInventory();
     }
     const auto& level = frontend.getLevel();
-    auto content = level.content;
+    auto& content = level.content;
     secondInvView = std::dynamic_pointer_cast<InventoryView>(doc->getRoot());
     if (secondInvView == nullptr) {
         throw std::runtime_error("secondary UI root element must be 'inventory'");
@@ -409,7 +411,7 @@ std::shared_ptr<Inventory> Hud::openInventory(
     if (inv == nullptr) {
         inv = level.inventories->createVirtual(secondInvView->getSlotsCount());
     }
-    secondInvView->bind(inv, content);
+    secondInvView->bind(inv, &content);
     add(HudElement(hud_element_mode::inventory_bound, doc, secondUI, false));
     return inv;
 }
@@ -424,7 +426,9 @@ void Hud::openInventory(
         closeInventory();
     }
     auto& level = frontend.getLevel();
-    auto content = level.content;
+    const auto& chunks = *player.chunks;
+    auto& content = level.content;
+
     blockUI = std::dynamic_pointer_cast<InventoryView>(doc->getRoot());
     if (blockUI == nullptr) {
         throw std::runtime_error("block UI root element must be 'inventory'");
@@ -438,25 +442,25 @@ void Hud::openInventory(
     if (blockinv == nullptr) {
         blockinv = level.inventories->createVirtual(blockUI->getSlotsCount());
     }
-    level.chunks->getChunkByVoxel(block.x, block.y, block.z)->flags.unsaved = true;
-    blockUI->bind(blockinv, content);
+    chunks.getChunkByVoxel(block)->flags.unsaved = true;
+    blockUI->bind(blockinv, &content);
     blockPos = block;
-    currentblockid = level.chunks->get(block.x, block.y, block.z)->id;
+    currentblockid = chunks.require(block.x, block.y, block.z).id;
     add(HudElement(hud_element_mode::inventory_bound, doc, blockUI, false));
 }
 
 void Hud::showExchangeSlot() {
     auto& level = frontend.getLevel();
-    auto content = level.content;
+    auto& content = level.content;
     exchangeSlotInv = level.inventories->createVirtual(1);
     exchangeSlot = std::make_shared<SlotView>(
         SlotLayout(-1, glm::vec2(), false, false, nullptr, nullptr, nullptr)
     );
-    exchangeSlot->bind(exchangeSlotInv->getId(), exchangeSlotInv->getSlot(0), content);
+    exchangeSlot->bind(exchangeSlotInv->getId(), exchangeSlotInv->getSlot(0), &content);
     exchangeSlot->setColor(glm::vec4());
     exchangeSlot->setInteractive(false);
     exchangeSlot->setZIndex(1);
-    gui->store(SlotView::EXCHANGE_SLOT_NAME, exchangeSlot);
+    gui.store(SlotView::EXCHANGE_SLOT_NAME, exchangeSlot);
 
 }
 
@@ -483,28 +487,28 @@ void Hud::openPermanent(UiDocument* doc) {
 
     auto invview = std::dynamic_pointer_cast<InventoryView>(root);
     if (invview) {
-        invview->bind(player->getInventory(), frontend.getLevel().content);
+        invview->bind(player.getInventory(), &frontend.getLevel().content);
     }
     add(HudElement(hud_element_mode::permanent, doc, doc->getRoot(), false));
 }
 
 void Hud::dropExchangeSlot() {
     auto slotView = std::dynamic_pointer_cast<SlotView>(
-        gui->get(SlotView::EXCHANGE_SLOT_NAME)
+        gui.get(SlotView::EXCHANGE_SLOT_NAME)
     );
     if (slotView == nullptr) {
         return;
     }
     ItemStack& stack = slotView->getStack();
     
-    auto indices = frontend.getLevel().content->getIndices();
+    auto indices = frontend.getLevel().content.getIndices();
     if (auto invView = std::dynamic_pointer_cast<InventoryView>(blockUI)) {
         invView->getInventory()->move(stack, indices);
     }
     if (stack.isEmpty()) {
         return;
     }
-    player->getInventory()->move(stack, indices);
+    player.getInventory()->move(stack, indices);
     if (!stack.isEmpty()) {
         logger.warning() << "discard item [" << stack.getItemId() << ":"
                          << stack.getCount();
@@ -514,7 +518,7 @@ void Hud::dropExchangeSlot() {
 
 void Hud::closeInventory() {
     dropExchangeSlot();
-    gui->remove(SlotView::EXCHANGE_SLOT_NAME);
+    gui.remove(SlotView::EXCHANGE_SLOT_NAME);
     exchangeSlot = nullptr;
     exchangeSlotInv = nullptr;
     inventoryOpen = false;
@@ -532,7 +536,7 @@ void Hud::closeInventory() {
 }
 
 void Hud::add(const HudElement& element, const dv::value& argsArray) {
-    gui->add(element.getNode());
+    gui.add(element.getNode());
     auto document = element.getDocument();
     if (document) {
         auto invview = std::dynamic_pointer_cast<InventoryView>(element.getNode());
@@ -568,7 +572,7 @@ void Hud::onRemove(const HudElement& element) {
             invview->unbind();
         }
     }
-    gui->remove(element.getNode());
+    gui.remove(element.getNode());
 }
 
 void Hud::remove(const std::shared_ptr<UINode>& node) {
@@ -581,6 +585,10 @@ void Hud::remove(const std::shared_ptr<UINode>& node) {
     cleanup();
 }
 
+void Hud::setDebug(bool flag) {
+    debug = flag;
+}
+
 void Hud::draw(const DrawContext& ctx){
     const Viewport& viewport = ctx.getViewport();
     const uint width = viewport.getWidth();
@@ -593,15 +601,15 @@ void Hud::draw(const DrawContext& ctx){
     auto batch = ctx.getBatch2D();
     batch->begin();
 
-    auto uishader = assets->get<Shader>("ui");
-    uishader->use();
-    uishader->uniformMatrix("u_projview", uicamera->getProjView());
+    auto& uishader = assets.require<Shader>("ui");
+    uishader.use();
+    uishader.uniformMatrix("u_projview", uicamera->getProjView());
 
     // Crosshair
-    if (!pause && !inventoryOpen && !player->debug) {
+    if (!pause && !inventoryOpen && !debug) {
         DrawContext chctx = ctx.sub(batch);
         chctx.setBlendMode(BlendMode::inversion);
-        auto texture = assets->get<Texture>("gui/crosshair");
+        auto texture = assets.get<Texture>("gui/crosshair");
         batch->texture(texture);
         int chsizex = texture != nullptr ? texture->getWidth() : 16;
         int chsizey = texture != nullptr ? texture->getHeight() : 16;
@@ -656,7 +664,7 @@ void Hud::updateElementsPosition(const Viewport& viewport) {
         exchangeSlot->setPos(glm::vec2(Events::cursor));
     }
     hotbarView->setPos(glm::vec2(width/2, height-65));
-    hotbarView->setSelected(player->getChosenSlot());
+    hotbarView->setSelected(player.getChosenSlot());
 }
 
 bool Hud::isInventoryOpen() const {
@@ -677,7 +685,7 @@ void Hud::setPause(bool pause) {
         closeInventory();
     }
     
-    auto menu = gui->getMenu();
+    const auto& menu = gui.getMenu();
     if (pause) {
         menu->setPage("pause");
     } else {
@@ -688,7 +696,7 @@ void Hud::setPause(bool pause) {
 }
 
 Player* Hud::getPlayer() const {
-    return player;
+    return &player;
 }
 
 std::shared_ptr<Inventory> Hud::getBlockInventory() {
@@ -709,10 +717,10 @@ void Hud::setContentAccess(bool flag) {
 void Hud::setDebugCheats(bool flag) {
     allowDebugCheats = flag;
     
-    gui->remove(debugPanel);
+    gui.remove(debugPanel);
     debugPanel = create_debug_panel(
-        engine, frontend.getLevel(), *player, allowDebugCheats
+        engine, frontend.getLevel(), player, allowDebugCheats
     );
     debugPanel->setZIndex(2);
-    gui->add(debugPanel);
+    gui.add(debugPanel);
 }
diff --git a/src/frontend/hud.hpp b/src/frontend/hud.hpp
index ad834955a..2a5371577 100644
--- a/src/frontend/hud.hpp
+++ b/src/frontend/hud.hpp
@@ -70,12 +70,12 @@ class HudElement {
 };
 
 class Hud : public util::ObjectsKeeper {
-    Engine* engine;
-    Assets* assets;
+    Engine& engine;
+    Assets& assets;
     std::unique_ptr<Camera> uicamera;
-    gui::GUI* gui;
+    gui::GUI& gui;
     LevelFrontend& frontend;
-    Player* player;
+    Player& player;
 
     /// @brief Is any overlay/inventory open
     bool inventoryOpen = false;
@@ -113,6 +113,7 @@ class Hud : public util::ObjectsKeeper {
     bool showContentPanel = true;
     /// @brief Provide cheat controllers to the debug panel
     bool allowDebugCheats = true;
+    bool debug = false;
     /// @brief UI element will be dynamicly positioned near to inventory or in screen center
     std::shared_ptr<gui::UINode> secondUI;
 
@@ -134,7 +135,7 @@ class Hud : public util::ObjectsKeeper {
     void showExchangeSlot();
     void updateWorldGenDebugVisualization();
 public:
-    Hud(Engine* engine, LevelFrontend& frontend, Player* player);
+    Hud(Engine& engine, LevelFrontend& frontend, Player& player);
     ~Hud();
 
     void update(bool hudVisible);
@@ -193,6 +194,8 @@ class Hud : public util::ObjectsKeeper {
     void onRemove(const HudElement& element);
     void remove(const std::shared_ptr<gui::UINode>& node);
 
+    void setDebug(bool flag);
+
     Player* getPlayer() const;
 
     std::shared_ptr<Inventory> getBlockInventory();
diff --git a/src/frontend/locale.cpp b/src/frontend/locale.cpp
index de040a11d..2af780769 100644
--- a/src/frontend/locale.cpp
+++ b/src/frontend/locale.cpp
@@ -37,38 +37,40 @@ const std::string& langs::Lang::getId() const {
     return locale;
 }
 
-// @brief Language key-value txt files parser
-class Reader : BasicParser {
-    void skipWhitespace() override {
-        BasicParser::skipWhitespace();
-        if (hasNext() && source[pos] == '#') {
-            skipLine();
-            if (hasNext() && is_whitespace(peek())) {
-                skipWhitespace();
+/// @brief Language key-value txt files parser
+namespace {
+    class Reader : BasicParser {
+        void skipWhitespace() override {
+            BasicParser::skipWhitespace();
+            if (hasNext() && source[pos] == '#') {
+                skipLine();
+                if (hasNext() && is_whitespace(peek())) {
+                    skipWhitespace();
+                }
             }
         }
-    }
-public:
-    Reader(std::string_view file, std::string_view source) : BasicParser(file, source) {
-    }
+    public:
+        Reader(std::string_view file, std::string_view source)
+            : BasicParser(file, source) {
+        }
 
-    void read(langs::Lang& lang, const std::string &prefix) {
-        skipWhitespace();
-        while (hasNext()) {
-            std::string key = parseString('=', true);
-            util::trim(key);
-            key = prefix + key;
-            std::string text = parseString('\n', false);
-            util::trim(text);
-            lang.put(util::str2wstr_utf8(key),
-                     util::str2wstr_utf8(text));
+        void read(langs::Lang& lang, const std::string &prefix) {
             skipWhitespace();
+            while (hasNext()) {
+                std::string key = parseString('=', true);
+                util::trim(key);
+                key = prefix + key;
+                std::string text = parseString('\n', false);
+                util::trim(text);
+                lang.put(util::str2wstr_utf8(key), util::str2wstr_utf8(text));
+                skipWhitespace();
+            }
         }
-    }
-};
+    };
+}
 
 void langs::loadLocalesInfo(const fs::path& resdir, std::string& fallback) {
-    fs::path file = resdir/fs::path(langs::TEXTS_FOLDER)/fs::path("langs.json");
+    auto file = resdir/fs::u8path(langs::TEXTS_FOLDER)/fs::u8path("langs.json");
     auto root = files::read_json(file);
 
     langs::locales_info.clear();
@@ -85,7 +87,7 @@ void langs::loadLocalesInfo(const fs::path& resdir, std::string& fallback) {
             } else {
                 continue;
             }
-            logline << "[" << key << " (" << name << ")] ";
+            logline << key << " ";
             langs::locales_info[key] = LocaleInfo {key, name};
         } 
         logline << "added";
diff --git a/src/frontend/menu.cpp b/src/frontend/menu.cpp
index 0591441e1..4a36410cf 100644
--- a/src/frontend/menu.cpp
+++ b/src/frontend/menu.cpp
@@ -5,7 +5,7 @@
 #include "screens/MenuScreen.hpp"
 
 #include "delegates.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "data/dv.hpp"
 #include "interfaces/Task.hpp"
 #include "files/engine_paths.hpp"
@@ -24,8 +24,8 @@
 namespace fs = std::filesystem;
 using namespace gui;
 
-void menus::create_version_label(Engine* engine) {
-    auto gui = engine->getGUI();
+void menus::create_version_label(Engine& engine) {
+    auto gui = engine.getGUI();
     auto text = ENGINE_VERSION_STRING+" debug build";
     gui->add(guiutil::create(
         "<label z-index='1000' color='#FFFFFF80' gravity='top-right' margin='4'>"
@@ -34,99 +34,63 @@ void menus::create_version_label(Engine* engine) {
     ));
 }
 
-gui::page_loader_func menus::create_page_loader(Engine* engine) {
-    return [=](const std::string& query) {
-        std::vector<dv::value> args;
-
-        std::string name;
-        size_t index = query.find('?');
-        if (index != std::string::npos) {
-            auto argstr = query.substr(index+1);
-            name = query.substr(0, index);
-            
-            auto map = dv::object();
-            auto filename = "query for "+name;
-            BasicParser parser(filename, argstr);
-            while (parser.hasNext()) {
-                auto key = std::string(parser.readUntil('='));
-                parser.nextChar();
-                auto value = std::string(parser.readUntil('&'));
-                map[key] = value;
-            }
-            args.emplace_back(map);
-        } else {
-            name = query;
-        }
-
-        auto file = engine->getResPaths()->find("layouts/pages/"+name+".xml");
-        auto fullname = "core:pages/"+name;
-
-        auto document_ptr = UiDocument::read(
-            scripting::get_root_environment(),
-            fullname,
-            file,
-            "core:layouts/pages/" + name
-        );
-        auto document = document_ptr.get();
-        engine->getAssets()->store(std::move(document_ptr), fullname);
-        scripting::on_ui_open(document, std::move(args));
-        return document->getRoot();
-    };
-}
-
-bool menus::call(Engine* engine, runnable func) {
+bool menus::call(Engine& engine, runnable func) {
+    if (engine.isHeadless()) {
+        throw std::runtime_error("menus::call(...) in headless mode");
+    }
+    auto gui = engine.getGUI();
     try {
         func();
         return true;
     } catch (const contentpack_error& error) {
-        engine->setScreen(std::make_shared<MenuScreen>(engine));
+        engine.setScreen(std::make_shared<MenuScreen>(engine));
         // could not to find or read pack
         guiutil::alert(
-            engine->getGUI(), langs::get(L"error.pack-not-found")+L": "+
+            engine, langs::get(L"error.pack-not-found")+L": "+
             util::str2wstr_utf8(error.getPackId())
         );
         return false;
     } catch (const assetload::error& error) {
-        engine->setScreen(std::make_shared<MenuScreen>(engine));
+        engine.setScreen(std::make_shared<MenuScreen>(engine));
         guiutil::alert(
-            engine->getGUI(), langs::get(L"Assets Load Error", L"menu")+L":\n"+
+            engine, langs::get(L"Assets Load Error", L"menu")+L":\n"+
             util::str2wstr_utf8(error.what())
         );
         return false;
     } catch (const parsing_error& error) {
-        engine->setScreen(std::make_shared<MenuScreen>(engine));
-        guiutil::alert(engine->getGUI(), util::str2wstr_utf8(error.errorLog()));
+        engine.setScreen(std::make_shared<MenuScreen>(engine));
+        guiutil::alert(engine, util::str2wstr_utf8(error.errorLog()));
         return false;
     } catch (const std::runtime_error& error) {
-        engine->setScreen(std::make_shared<MenuScreen>(engine));
+        engine.setScreen(std::make_shared<MenuScreen>(engine));
         guiutil::alert(
-            engine->getGUI(), langs::get(L"Content Error", L"menu")+L":\n"+
+            engine, langs::get(L"Content Error", L"menu")+L":\n"+
             util::str2wstr_utf8(error.what())
         );
         return false;
     }
 }
 
-UiDocument* menus::show(Engine* engine, const std::string& name, std::vector<dv::value> args) {
-    auto menu = engine->getGUI()->getMenu();
-    auto file = engine->getResPaths()->find("layouts/"+name+".xml");
+UiDocument* menus::show(Engine& engine, const std::string& name, std::vector<dv::value> args) {
+    auto menu = engine.getGUI()->getMenu();
+    auto file = engine.getResPaths()->find("layouts/"+name+".xml");
     auto fullname = "core:layouts/"+name;
 
-    auto document_ptr = UiDocument::read(
+    auto documentPtr = UiDocument::read(
         scripting::get_root_environment(), fullname, file, "core:layouts/"+name
     );
-    auto document = document_ptr.get();
-    engine->getAssets()->store(std::move(document_ptr), fullname);
+    auto document = documentPtr.get();
+    engine.getAssets()->store(std::move(documentPtr), fullname);
     scripting::on_ui_open(document, std::move(args));
     menu->addPage(name, document->getRoot());
     menu->setPage(name);
     return document;
 }
 
-void menus::show_process_panel(Engine* engine, const std::shared_ptr<Task>& task, const std::wstring& text) {
+void menus::show_process_panel(Engine& engine, const std::shared_ptr<Task>& task, const std::wstring& text) {
     uint initialWork = task->getWorkTotal();
 
-    auto menu = engine->getGUI()->getMenu();
+    auto menu = engine.getGUI()->getMenu();
     menu->reset();
     auto doc = menus::show(engine, "process", {
         util::wstr2str_utf8(langs::get(text))
diff --git a/src/frontend/menu.hpp b/src/frontend/menu.hpp
index 7a527c4d7..3ae0cd493 100644
--- a/src/frontend/menu.hpp
+++ b/src/frontend/menu.hpp
@@ -14,17 +14,15 @@ class UiDocument;
 
 namespace menus {
     /// @brief Create development version label at the top-right screen corner
-    void create_version_label(Engine* engine);
-
-    gui::page_loader_func create_page_loader(Engine* engine);
+    void create_version_label(Engine& engine);
 
     UiDocument* show(
-        Engine* engine, 
+        Engine& engine, 
         const std::string& name,
         std::vector<dv::value> args
     );
 
-    void show_process_panel(Engine* engine, const std::shared_ptr<Task>& task, const std::wstring& text=L"");
+    void show_process_panel(Engine& engine, const std::shared_ptr<Task>& task, const std::wstring& text=L"");
 
-    bool call(Engine* engine, runnable func);
+    bool call(Engine& engine, runnable func);
 }
diff --git a/src/frontend/screens/LevelScreen.cpp b/src/frontend/screens/LevelScreen.cpp
index e38b3beca..f045acee9 100644
--- a/src/frontend/screens/LevelScreen.cpp
+++ b/src/frontend/screens/LevelScreen.cpp
@@ -1,27 +1,32 @@
 #include "LevelScreen.hpp"
 
-#include "core_defs.hpp"
-#include "frontend/hud.hpp"
-#include "frontend/LevelFrontend.hpp"
 #include "audio/audio.hpp"
 #include "coders/imageio.hpp"
+#include "content/Content.hpp"
+#include "core_defs.hpp"
 #include "debug/Logger.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "files/files.hpp"
-#include "content/Content.hpp"
+#include "frontend/LevelFrontend.hpp"
+#include "frontend/hud.hpp"
 #include "graphics/core/DrawContext.hpp"
 #include "graphics/core/ImageData.hpp"
 #include "graphics/core/PostProcessing.hpp"
 #include "graphics/core/Viewport.hpp"
-#include "graphics/render/WorldRenderer.hpp"
 #include "graphics/render/Decorator.hpp"
+#include "graphics/render/WorldRenderer.hpp"
+#include "graphics/ui/GUI.hpp"
 #include "graphics/ui/elements/Menu.hpp"
 #include "graphics/ui/GUI.hpp"
 #include "frontend/ContentGfxCache.hpp"
 #include "logic/LevelController.hpp"
+#include "logic/PlayerController.hpp"
+#include "logic/scripting/scripting.hpp"
 #include "logic/scripting/scripting_hud.hpp"
-#include "util/stringutil.hpp"
+#include "maths/voxmaths.hpp"
+#include "objects/Players.hpp"
 #include "physics/Hitbox.hpp"
+#include "util/stringutil.hpp"
 #include "voxels/Chunks.hpp"
 #include "window/Camera.hpp"
 #include "window/Events.hpp"
@@ -31,44 +36,54 @@
 
 static debug::Logger logger("level-screen");
 
-LevelScreen::LevelScreen(Engine* engine, std::unique_ptr<Level> levelPtr)
+LevelScreen::LevelScreen(Engine& engine, std::unique_ptr<Level> levelPtr)
  : Screen(engine), postProcessing(std::make_unique<PostProcessing>()) 
 {
     Level* level = levelPtr.get();
 
-    auto& settings = engine->getSettings();
-    auto& assets = *engine->getAssets();
-    auto menu = engine->getGUI()->getMenu();
+    auto& settings = engine.getSettings();
+    auto& assets = *engine.getAssets();
+    auto menu = engine.getGUI()->getMenu();
     menu->reset();
 
-    controller = std::make_unique<LevelController>(engine, std::move(levelPtr));
+    auto player = level->players->get(0);
+    controller =
+        std::make_unique<LevelController>(&engine, std::move(levelPtr), player);
+    playerController = std::make_unique<PlayerController>(
+        settings,
+        *level,
+        *player,
+        *controller->getBlocksController()
+    );
+
     frontend = std::make_unique<LevelFrontend>(
-        controller->getPlayer(), controller.get(), assets, settings
+        player, controller.get(), assets, settings
     );
     worldRenderer = std::make_unique<WorldRenderer>(
-        engine, *frontend, controller->getPlayer()
+        engine, *frontend, *player
     );
-    hud = std::make_unique<Hud>(engine, *frontend, controller->getPlayer());
+    hud = std::make_unique<Hud>(engine, *frontend, *player);
 
     decorator = std::make_unique<Decorator>(
-        *engine, *controller, *worldRenderer, assets
+        engine, *controller, *worldRenderer, assets, *player
     );
 
     keepAlive(settings.graphics.backlight.observe([=](bool) {
-        controller->getLevel()->chunks->saveAndClear();
+        player->chunks->saveAndClear();
         worldRenderer->clear();
     }));
     keepAlive(settings.graphics.denseRender.observe([=](bool) {
-        controller->getLevel()->chunks->saveAndClear();
+        player->chunks->saveAndClear();
         worldRenderer->clear();
         frontend->getContentGfxCache().refresh();
     }));
     keepAlive(settings.camera.fov.observe([=](double value) {
-        controller->getPlayer()->fpCamera->setFov(glm::radians(value));
+        player->fpCamera->setFov(glm::radians(value));
     }));
     keepAlive(Events::getBinding(BIND_CHUNKS_RELOAD).onactived.add([=](){
-        controller->getLevel()->chunks->saveAndClear();
+        player->chunks->saveAndClear();
         worldRenderer->clear();
+        return false;
     }));
 
     animator = std::make_unique<TextureAnimator>();
@@ -78,8 +93,8 @@ LevelScreen::LevelScreen(Engine* engine, std::unique_ptr<Level> levelPtr)
 }
 
 void LevelScreen::initializeContent() {
-    auto content = controller->getLevel()->content;
-    for (auto& entry : content->getPacks()) {
+    auto& content = controller->getLevel()->content;
+    for (auto& entry : content.getPacks()) {
         initializePack(entry.second.get());
     }
     scripting::on_frontend_init(hud.get(), worldRenderer.get());
@@ -104,15 +119,15 @@ LevelScreen::~LevelScreen() {
     // unblock all bindings
     Events::enableBindings();
     controller->onWorldQuit();
-    engine->getPaths()->setCurrentWorldFolder(fs::path());
+    engine.getPaths().setCurrentWorldFolder(fs::path());
 }
 
 void LevelScreen::saveWorldPreview() {
     try {
         logger.info() << "saving world preview";
-        auto paths = engine->getPaths();
-        auto player = controller->getPlayer();
-        auto& settings = engine->getSettings();
+        const auto& paths = engine.getPaths();
+        auto player = playerController->getPlayer();
+        auto& settings = engine.getSettings();
         int previewSize = settings.ui.worldPreviewSize.get();
 
         // camera special copy for world preview
@@ -127,14 +142,14 @@ void LevelScreen::saveWorldPreview() {
         worldRenderer->draw(ctx, camera, false, true, 0.0f, postProcessing.get());
         auto image = postProcessing->toImage();
         image->flipY();
-        imageio::write(paths->resolve("world:preview.png").u8string(), image.get());
+        imageio::write(paths.resolve("world:preview.png").u8string(), image.get());
     } catch (const std::exception& err) {
         logger.error() << err.what();
     }
 }
 
 void LevelScreen::updateHotkeys() {
-    auto& settings = engine->getSettings();
+    auto& settings = engine.getSettings();
     if (Events::jpressed(keycode::O)) {
         settings.graphics.frustumCulling.toggle();
     }
@@ -142,12 +157,14 @@ void LevelScreen::updateHotkeys() {
         hudVisible = !hudVisible;
     }
     if (Events::jpressed(keycode::F3)) {
-        controller->getPlayer()->debug = !controller->getPlayer()->debug;
+        debug = !debug;
+        hud->setDebug(debug);
+        worldRenderer->setDebug(debug);
     }
 }
 
 void LevelScreen::update(float delta) {
-    gui::GUI* gui = engine->getGUI();
+    gui::GUI* gui = engine.getGUI();
     
     bool inputLocked = hud->isPause() || 
                        hud->isInventoryOpen() || 
@@ -156,7 +173,7 @@ void LevelScreen::update(float delta) {
         updateHotkeys();
     }
 
-    auto player = controller->getPlayer();
+    auto player = playerController->getPlayer();
     auto camera = player->currentCamera;
 
     bool paused = hud->isPause();
@@ -172,22 +189,32 @@ void LevelScreen::update(float delta) {
         camera->dir, 
         glm::vec3(0, 1, 0)
     );
+    auto level = controller->getLevel();
+    const auto& settings = engine.getSettings();
 
     if (!hud->isPause()) {
-        controller->getLevel()->getWorld()->updateTimers(delta);
+        level->getWorld()->updateTimers(delta);
         animator->update(delta);
     }
-    controller->update(glm::min(delta, 0.2f), !inputLocked, hud->isPause());
+    if (!hud->isPause()) {
+        playerController->update(delta, !inputLocked);
+    }
+    controller->update(glm::min(delta, 0.2f), hud->isPause());
+    playerController->postUpdate(delta, !inputLocked, hud->isPause());
+
     hud->update(hudVisible);
     decorator->update(delta, *camera);
 }
 
 void LevelScreen::draw(float delta) {
-    auto camera = controller->getPlayer()->currentCamera;
+    auto camera = playerController->getPlayer()->currentCamera;
 
     Viewport viewport(Window::width, Window::height);
     DrawContext ctx(nullptr, viewport, batch.get());
 
+    if (!hud->isPause()) {
+        scripting::on_entities_render(engine.getTime().getDelta());
+    }
     worldRenderer->draw(
         ctx, *camera, hudVisible, hud->isPause(), delta, postProcessing.get()
     );
diff --git a/src/frontend/screens/LevelScreen.hpp b/src/frontend/screens/LevelScreen.hpp
index db0f04ff4..6a3b4eab6 100644
--- a/src/frontend/screens/LevelScreen.hpp
+++ b/src/frontend/screens/LevelScreen.hpp
@@ -8,6 +8,7 @@ class Engine;
 class LevelFrontend;
 class Hud;
 class LevelController;
+class PlayerController;
 class WorldRenderer;
 class TextureAnimator;
 class PostProcessing;
@@ -18,6 +19,7 @@ class Level;
 class LevelScreen : public Screen {
     std::unique_ptr<LevelFrontend> frontend;
     std::unique_ptr<LevelController> controller;
+    std::unique_ptr<PlayerController> playerController;
     std::unique_ptr<WorldRenderer> worldRenderer;
     std::unique_ptr<TextureAnimator> animator;
     std::unique_ptr<PostProcessing> postProcessing;
@@ -27,11 +29,12 @@ class LevelScreen : public Screen {
     void saveWorldPreview();
 
     bool hudVisible = true;
+    bool debug = false;
     void updateHotkeys();
     void initializeContent();
     void initializePack(ContentPackRuntime* pack);
 public:
-    LevelScreen(Engine* engine, std::unique_ptr<Level> level);
+    LevelScreen(Engine& engine, std::unique_ptr<Level> level);
     ~LevelScreen();
 
     void update(float delta) override;
diff --git a/src/frontend/screens/MenuScreen.cpp b/src/frontend/screens/MenuScreen.cpp
index 305b42eda..f16f73ee3 100644
--- a/src/frontend/screens/MenuScreen.cpp
+++ b/src/frontend/screens/MenuScreen.cpp
@@ -8,12 +8,12 @@
 #include "maths/UVRegion.hpp"
 #include "window/Window.hpp"
 #include "window/Camera.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 
-MenuScreen::MenuScreen(Engine* engine) : Screen(engine) {
-    engine->resetContent();
+MenuScreen::MenuScreen(Engine& engine) : Screen(engine) {
+    engine.resetContent();
     
-    auto menu = engine->getGUI()->getMenu();
+    auto menu = engine.getGUI()->getMenu();
     menu->reset();
     menu->setPage("main");
 
@@ -29,7 +29,7 @@ void MenuScreen::update(float delta) {
 }
 
 void MenuScreen::draw(float delta) {
-    auto assets = engine->getAssets();
+    auto assets = engine.getAssets();
 
     Window::clear();
     Window::setBgColor(glm::vec3(0.2f));
diff --git a/src/frontend/screens/MenuScreen.hpp b/src/frontend/screens/MenuScreen.hpp
index fa6de8ba3..f9b5dd48f 100644
--- a/src/frontend/screens/MenuScreen.hpp
+++ b/src/frontend/screens/MenuScreen.hpp
@@ -10,7 +10,7 @@ class Engine;
 class MenuScreen : public Screen {
     std::unique_ptr<Camera> uicamera;
 public:
-    MenuScreen(Engine* engine);
+    MenuScreen(Engine& engine);
     ~MenuScreen();
 
     void update(float delta) override;
diff --git a/src/frontend/screens/Screen.cpp b/src/frontend/screens/Screen.cpp
index 2c1c998aa..3fd648258 100644
--- a/src/frontend/screens/Screen.cpp
+++ b/src/frontend/screens/Screen.cpp
@@ -1,9 +1,9 @@
 #include "Screen.hpp"
 
 #include "graphics/core/Batch2D.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 
-Screen::Screen(Engine* engine)
+Screen::Screen(Engine& engine)
   : engine(engine), 
     batch(std::make_unique<Batch2D>(1024)) {
 }
diff --git a/src/frontend/screens/Screen.hpp b/src/frontend/screens/Screen.hpp
index 28a49a063..dde2f5554 100644
--- a/src/frontend/screens/Screen.hpp
+++ b/src/frontend/screens/Screen.hpp
@@ -8,10 +8,10 @@ class Batch2D;
 /// @brief Screen is a mainloop state
 class Screen : public util::ObjectsKeeper {
 protected:
-    Engine* engine;
+    Engine& engine;
     std::unique_ptr<Batch2D> batch;
 public:
-    Screen(Engine* engine);
+    Screen(Engine& engine);
     virtual ~Screen();
     virtual void update(float delta) = 0;
     virtual void draw(float delta) = 0;
diff --git a/src/graphics/core/DrawContext.cpp b/src/graphics/core/DrawContext.cpp
index 7062ad56c..936de95b0 100644
--- a/src/graphics/core/DrawContext.cpp
+++ b/src/graphics/core/DrawContext.cpp
@@ -92,6 +92,9 @@ DrawContext DrawContext::sub(Flushable* flushable) const {
     ctx.parent = this;
     ctx.flushable = flushable;
     ctx.scissorsCount = 0;
+    if (auto batch2D = dynamic_cast<Batch2D*>(flushable)) {
+        ctx.g2d = batch2D;
+    }
     return ctx;
 }
 
diff --git a/src/graphics/core/DrawContext.hpp b/src/graphics/core/DrawContext.hpp
index 736b053ee..6c20f37f5 100644
--- a/src/graphics/core/DrawContext.hpp
+++ b/src/graphics/core/DrawContext.hpp
@@ -10,7 +10,7 @@ class Framebuffer;
 class DrawContext {
     const DrawContext* parent;
     Viewport viewport;
-    Batch2D* const g2d;
+    Batch2D* g2d;
     Flushable* flushable = nullptr;
     Framebuffer* fbo = nullptr;
     bool depthMask = true;
diff --git a/src/graphics/core/GLTexture.cpp b/src/graphics/core/GLTexture.cpp
index 3756d7580..a446a88cd 100644
--- a/src/graphics/core/GLTexture.cpp
+++ b/src/graphics/core/GLTexture.cpp
@@ -60,7 +60,7 @@ std::unique_ptr<ImageData> GLTexture::readData() {
     glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, data.get());
     glBindTexture(GL_TEXTURE_2D, 0);
     return std::make_unique<ImageData>(
-        ImageFormat::rgba8888, width, height, data.release()
+        ImageFormat::rgba8888, width, height, std::move(data)
     );
 }
 
diff --git a/src/graphics/core/Mesh.cpp b/src/graphics/core/Mesh.cpp
index e8cffe6ff..808b88c4a 100644
--- a/src/graphics/core/Mesh.cpp
+++ b/src/graphics/core/Mesh.cpp
@@ -1,4 +1,5 @@
 #include "Mesh.hpp"
+#include <assert.h>
 #include <GL/glew.h>
 
 int Mesh::meshesCount = 0;
@@ -9,6 +10,7 @@ inline size_t calc_vertex_size(const VertexAttribute* attrs) {
     for (int i = 0; attrs[i].size; i++) {
         vertexSize += attrs[i].size;
     }
+    assert(vertexSize != 0);
     return vertexSize;
 }
 
diff --git a/src/graphics/core/commons.cpp b/src/graphics/core/commons.cpp
new file mode 100644
index 000000000..98cc5c132
--- /dev/null
+++ b/src/graphics/core/commons.cpp
@@ -0,0 +1,39 @@
+#include "commons.hpp"
+
+#include <map>
+
+std::optional<CursorShape> CursorShape_from(std::string_view name) {
+    static std::map<std::string_view, CursorShape> shapes = {
+        {"arrow", CursorShape::ARROW},
+        {"text", CursorShape::TEXT},
+        {"crosshair", CursorShape::CROSSHAIR},
+        {"pointer", CursorShape::POINTER},
+        {"ew-resize", CursorShape::EW_RESIZE},
+        {"ns-resize", CursorShape::NS_RESIZE},
+        {"nwse-resize", CursorShape::NWSE_RESIZE},
+        {"nesw-resize", CursorShape::NESW_RESIZE},
+        {"all-resize", CursorShape::ALL_RESIZE},
+        {"not-allowed", CursorShape::NOT_ALLOWED}
+    };
+    const auto& found = shapes.find(name);
+    if (found == shapes.end()) {
+        return std::nullopt;
+    }
+    return found->second;
+}
+
+std::string to_string(CursorShape shape) {
+    static std::string names[] = {
+        "arrow",
+        "text",
+        "crosshair",
+        "pointer",
+        "ew-resize",
+        "ns-resize",
+        "nwse-resize",
+        "nesw-resize",
+        "all-resize",
+        "not-allowed"
+    };
+    return names[static_cast<int>(shape)];
+}
diff --git a/src/graphics/core/commons.hpp b/src/graphics/core/commons.hpp
index 4d3f376f2..808192064 100644
--- a/src/graphics/core/commons.hpp
+++ b/src/graphics/core/commons.hpp
@@ -1,5 +1,8 @@
 #pragma once
 
+#include <string>
+#include <optional>
+
 enum class DrawPrimitive {
     point = 0,
     line,
@@ -7,9 +10,47 @@ enum class DrawPrimitive {
 };
 
 enum class BlendMode {
-    normal, addition, inversion
+    /// @brief Normal blending mode.
+    normal, 
+    /// @brief Additive blending mode.
+    addition, 
+    /// @brief Subtractive blending mode.
+    inversion
+};
+
+/// @brief Standard GLFW 3.4 cursor shapes (same order and count as in GLFW).
+/// It also works in GLFW 3.3 (unsupported shapes will be replaced with the arrow).
+enum class CursorShape {
+    /// @brief Regular arrow
+    ARROW,
+    /// @brief Text input I-beam
+    TEXT,
+    /// @brief Crosshair 
+    CROSSHAIR,
+    /// @brief Pointing hand
+    POINTER,
+    /// @brief Horizontal resize arrow
+    EW_RESIZE,
+    /// @brief Vertical resize arrow
+    NS_RESIZE,
+    
+    // GLFW 3.4+ cursor shapes
+    
+    /// @brief Diagonal resize arrow (top-left to bottom-right)
+    NWSE_RESIZE,
+    /// @brief Diagonal resize arrow (top-right to bottom-left)
+    NESW_RESIZE,
+    /// @brief All-direction resize arrow
+    ALL_RESIZE,
+    /// @brief Operation not allowed
+    NOT_ALLOWED,
+    
+    LAST=NOT_ALLOWED
 };
 
+std::optional<CursorShape> CursorShape_from(std::string_view name);
+std::string to_string(CursorShape shape);
+
 class Flushable {
 public:
     virtual ~Flushable() = default;
diff --git a/src/graphics/render/BlockWrapsRenderer.cpp b/src/graphics/render/BlockWrapsRenderer.cpp
index 3ad30ad85..0b833a604 100644
--- a/src/graphics/render/BlockWrapsRenderer.cpp
+++ b/src/graphics/render/BlockWrapsRenderer.cpp
@@ -14,15 +14,18 @@
 #include "window/Window.hpp"
 #include "world/Level.hpp"
 
-BlockWrapsRenderer::BlockWrapsRenderer(const Assets& assets, const Level& level)
-    : assets(assets), level(level), batch(std::make_unique<MainBatch>(1024)) {
+BlockWrapsRenderer::BlockWrapsRenderer(
+    const Assets& assets, const Level& level, const Chunks& chunks
+)
+    : assets(assets),
+      level(level),
+      chunks(chunks),
+      batch(std::make_unique<MainBatch>(1024)) {
 }
 
 BlockWrapsRenderer::~BlockWrapsRenderer() = default;
 
 void BlockWrapsRenderer::draw(const BlockWrapper& wrapper) {
-    const auto& chunks = *level.chunks;
-
     auto textureRegion = util::get_texture_region(assets, wrapper.texture, "");
 
     auto& shader = assets.require<Shader>("entity");
@@ -41,8 +44,7 @@ void BlockWrapsRenderer::draw(const BlockWrapper& wrapper) {
         return;
     }
     if (vox->id != BLOCK_VOID) {
-        const auto& def =
-            level.content->getIndices()->blocks.require(vox->id);
+        const auto& def = level.content.getIndices()->blocks.require(vox->id);
         switch (def.model) {
             case BlockModel::block:
                 batch->cube(
diff --git a/src/graphics/render/BlockWrapsRenderer.hpp b/src/graphics/render/BlockWrapsRenderer.hpp
index 728e664a7..9d6184b90 100644
--- a/src/graphics/render/BlockWrapsRenderer.hpp
+++ b/src/graphics/render/BlockWrapsRenderer.hpp
@@ -10,6 +10,7 @@
 class Assets;
 class Player;
 class Level;
+class Chunks;
 class DrawContext;
 
 struct BlockWrapper {
@@ -20,6 +21,7 @@ struct BlockWrapper {
 class BlockWrapsRenderer {
     const Assets& assets;
     const Level& level;
+    const Chunks& chunks;
     std::unique_ptr<MainBatch> batch;
 
     std::unordered_map<u64id_t, std::unique_ptr<BlockWrapper>> wrappers;
@@ -27,7 +29,9 @@ class BlockWrapsRenderer {
 
     void draw(const BlockWrapper& wrapper);
 public:
-    BlockWrapsRenderer(const Assets& assets, const Level& level);
+    BlockWrapsRenderer(
+        const Assets& assets, const Level& level, const Chunks& chunks
+    );
     ~BlockWrapsRenderer();
 
     void draw(const DrawContext& ctx, const Player& player);
diff --git a/src/graphics/render/BlocksRenderer.cpp b/src/graphics/render/BlocksRenderer.cpp
index 56f1c4e2f..bc05fc72d 100644
--- a/src/graphics/render/BlocksRenderer.cpp
+++ b/src/graphics/render/BlocksRenderer.cpp
@@ -184,12 +184,18 @@ void BlocksRenderer::blockXSprite(
     const UVRegion& texface2, 
     float spread
 ) {
-    glm::vec4 lights[] {
+    glm::vec4 lights1[] {
         pickSoftLight({x, y + 1, z}, {1, 0, 0}, {0, 1, 0}),
         pickSoftLight({x + 1, y + 1, z}, {1, 0, 0}, {0, 1, 0}),
         pickSoftLight({x + 1, y + 1, z}, {1, 0, 0}, {0, 1, 0}),
         pickSoftLight({x, y + 1, z}, {1, 0, 0}, {0, 1, 0})
     };
+    glm::vec4 lights2[] {
+        pickSoftLight({x, y + 1, z}, {-1, 0, 0}, {0, 1, 0}),
+        pickSoftLight({x - 1, y + 1, z}, {-1, 0, 0}, {0, 1, 0}),
+        pickSoftLight({x - 1, y + 1, z}, {-1, 0, 0}, {0, 1, 0}),
+        pickSoftLight({x, y + 1, z}, {-1, 0, 0}, {0, 1, 0})
+    };
     randomizer.setSeed((x * 52321) ^ (z * 389) ^ y);
     short rand = randomizer.rand32();
 
@@ -199,15 +205,15 @@ void BlocksRenderer::blockXSprite(
     const float w = size.x / 1.41f;
     const glm::vec4 tint (0.8f);
 
-    face({x + xs, y, z + zs}, w, size.y, 0, {1, 0, 1}, {0, 1, 0}, glm::vec3(),
-        texface1, lights, tint);
-    face({x + xs, y, z + zs}, w, size.y, 0, {-1, 0, -1}, {0, 1, 0}, glm::vec3(), 
-        texface1, lights, tint);
+    face({x + xs, y, z + zs}, w, size.y, 0, {-1, 0, 1}, {0, 1, 0}, glm::vec3(),
+        texface1, lights2, tint);
+    face({x + xs, y, z + zs}, w, size.y, 0, {1, 0, 1}, {0, 1, 0}, glm::vec3(), 
+        texface1, lights1, tint);
 
+    face({x + xs, y, z + zs}, w, size.y, 0, {-1, 0, -1}, {0, 1, 0}, glm::vec3(), 
+        texface2, lights2, tint);
     face({x + xs, y, z + zs}, w, size.y, 0, {1, 0, -1}, {0, 1, 0}, glm::vec3(), 
-        texface2, lights, tint);
-    face({x + xs, y, z + zs}, w, size.y, 0, {-1, 0, 1}, {0, 1, 0}, glm::vec3(), 
-        texface2, lights, tint);
+        texface2, lights1, tint);
 }
 
 // HINT: texture faces order: {east, west, bottom, top, south, north}
@@ -237,9 +243,9 @@ void BlocksRenderer::blockAABB(
     if (block->rotatable) {
         auto& rotations = block->rotations;
         auto& orient = rotations.variants[rotation];
-        X = orient.axisX;
-        Y = orient.axisY;
-        Z = orient.axisZ;
+        X = orient.axes[0];
+        Y = orient.axes[1];
+        Z = orient.axes[2];
         orient.transform(hitbox);
     }
     coord -= glm::vec3(0.5f) - hitbox.center();
@@ -272,14 +278,13 @@ void BlocksRenderer::blockCustomModel(
     glm::vec3 X(1, 0, 0);
     glm::vec3 Y(0, 1, 0);
     glm::vec3 Z(0, 0, 1);
-    CoordSystem orient(X,Y,Z);
     glm::vec3 coord(icoord);
     if (block->rotatable) {
         auto& rotations = block->rotations;
-        orient = rotations.variants[rotation];
-        X = orient.axisX;
-        Y = orient.axisY;
-        Z = orient.axisZ;
+        CoordSystem orient = rotations.variants[rotation];
+        X = orient.axes[0];
+        Y = orient.axes[1];
+        Z = orient.axes[2];
     }
 
     const auto& model = cache.getModel(block->rt.id);
@@ -333,9 +338,9 @@ void BlocksRenderer::blockCube(
     if (block.rotatable) {
         auto& rotations = block.rotations;
         auto& orient = rotations.variants[states.rotation];
-        X = orient.axisX;
-        Y = orient.axisY;
-        Z = orient.axisZ;
+        X = orient.axes[0];
+        Y = orient.axes[1];
+        Z = orient.axes[2];
     }
     
     if (ao) {
@@ -608,7 +613,7 @@ void BlocksRenderer::build(const Chunk* chunk, const Chunks* chunks) {
     voxelsBuffer->setPosition(
         chunk->x * CHUNK_W - voxelBufferPadding, 0,
         chunk->z * CHUNK_D - voxelBufferPadding);
-    chunks->getVoxels(voxelsBuffer.get(), settings.graphics.backlight.get());
+    chunks->getVoxels(*voxelsBuffer, settings.graphics.backlight.get());
 
     if (voxelsBuffer->pickBlockId(
         chunk->x * CHUNK_W, 0, chunk->z * CHUNK_D
diff --git a/src/graphics/render/ChunksRenderer.cpp b/src/graphics/render/ChunksRenderer.cpp
index f669cfeab..da40d8222 100644
--- a/src/graphics/render/ChunksRenderer.cpp
+++ b/src/graphics/render/ChunksRenderer.cpp
@@ -20,19 +20,29 @@ size_t ChunksRenderer::visibleChunks = 0;
 
 class RendererWorker : public util::Worker<std::shared_ptr<Chunk>, RendererResult> {
     const Level& level;
+    const Chunks& chunks;
     BlocksRenderer renderer;
 public:
     RendererWorker(
-        const Level& level, 
+        const Level& level,
+        const Chunks& chunks,
         const ContentGfxCache& cache,
         const EngineSettings& settings
-    ) : level(level), 
-        renderer(settings.graphics.chunkMaxVertices.get(),
-                 *level.content, cache, settings)
-    {}
+    )
+        : level(level),
+          chunks(chunks),
+          renderer(
+              settings.graphics.denseRender.get()
+                  ? settings.graphics.chunkMaxVerticesDense.get()
+                  : settings.graphics.chunkMaxVertices.get(),
+              level.content,
+              cache,
+              settings
+          ) {
+    }
 
     RendererResult operator()(const std::shared_ptr<Chunk>& chunk) override {
-        renderer.build(chunk.get(), level.chunks.get());
+        renderer.build(chunk.get(), &chunks);
         if (renderer.isCancelled()) {
             return RendererResult {
                 glm::ivec2(chunk->x, chunk->z), true, MeshData()};
@@ -44,33 +54,40 @@ class RendererWorker : public util::Worker<std::shared_ptr<Chunk>, RendererResul
 };
 
 ChunksRenderer::ChunksRenderer(
-    const Level* level, 
+    const Level* level,
+    const Chunks& chunks,
     const Assets& assets,
     const Frustum& frustum,
-    const ContentGfxCache& cache, 
+    const ContentGfxCache& cache,
     const EngineSettings& settings
-) : level(*level),
-    assets(assets),
-    frustum(frustum),
-    settings(settings),
-    threadPool(
-        "chunks-render-pool",
-        [&](){return std::make_shared<RendererWorker>(*level, cache, settings);}, 
-        [&](RendererResult& result){
-            if (!result.cancelled) {
-                auto meshData = std::move(result.meshData);
-                meshes[result.key] = ChunkMesh {
-                    std::make_unique<Mesh>(meshData.mesh),
-                    std::move(meshData.sortingMesh)
-                };
-            }
-            inwork.erase(result.key);
-        }, settings.graphics.chunkMaxRenderers.get())
-{
+)
+    : level(*level),
+      chunks(chunks),
+      assets(assets),
+      frustum(frustum),
+      settings(settings),
+      threadPool(
+          "chunks-render-pool",
+          [&]() {
+              return std::make_shared<RendererWorker>(
+                  *level, chunks, cache, settings
+              );
+          },
+          [&](RendererResult& result) {
+              if (!result.cancelled) {
+                  auto meshData = std::move(result.meshData);
+                  meshes[result.key] = ChunkMesh {
+                      std::make_unique<Mesh>(meshData.mesh),
+                      std::move(meshData.sortingMesh)};
+              }
+              inwork.erase(result.key);
+          },
+          settings.graphics.chunkMaxRenderers.get()
+      ) {
     threadPool.setStopOnFail(false);
     renderer = std::make_unique<BlocksRenderer>(
         settings.graphics.chunkMaxVertices.get(), 
-        *level->content, cache, settings
+        level->content, cache, settings
     );
     logger.info() << "created " << threadPool.getWorkersCount() << " workers";
 }
@@ -83,7 +100,7 @@ const Mesh* ChunksRenderer::render(
 ) {
     chunk->flags.modified = false;
     if (important) {
-        auto mesh = renderer->render(chunk.get(), level.chunks.get());
+        auto mesh = renderer->render(chunk.get(), &chunks);
         meshes[glm::ivec2(chunk->x, chunk->z)] = ChunkMesh {
             std::move(mesh.mesh), std::move(mesh.sortingMeshData)
         };
@@ -131,7 +148,7 @@ void ChunksRenderer::update() {
 const Mesh* ChunksRenderer::retrieveChunk(
     size_t index, const Camera& camera, Shader& shader, bool culling
 ) {
-    auto chunk = level.chunks->getChunks()[index];
+    auto chunk = chunks.getChunks()[index];
     if (chunk == nullptr || !chunk->flags.lighted) {
         return nullptr;
     }
@@ -163,7 +180,6 @@ const Mesh* ChunksRenderer::retrieveChunk(
 void ChunksRenderer::drawChunks(
     const Camera& camera, Shader& shader
 ) {
-    const auto& chunks = *level.chunks;
     const auto& atlas = assets.require<Atlas>("blocks");
 
     atlas.getTexture()->bind();
@@ -232,7 +248,7 @@ void ChunksRenderer::drawSortedMeshes(const Camera& camera, Shader& shader) {
     frameid++;
 
     bool culling = settings.graphics.frustumCulling.get();
-    const auto& chunks = level.chunks->getChunks();
+    const auto& chunks = this->chunks.getChunks();
     const auto& cameraPos = camera.position;
     const auto& atlas = assets.require<Atlas>("blocks");
 
diff --git a/src/graphics/render/ChunksRenderer.hpp b/src/graphics/render/ChunksRenderer.hpp
index 859bca9eb..a25c42413 100644
--- a/src/graphics/render/ChunksRenderer.hpp
+++ b/src/graphics/render/ChunksRenderer.hpp
@@ -20,6 +20,7 @@ class Level;
 class Camera;
 class Shader;
 class Assets;
+class Chunks;
 class Frustum;
 class BlocksRenderer;
 class ContentGfxCache;
@@ -42,6 +43,7 @@ struct RendererResult {
 
 class ChunksRenderer {
     const Level& level;
+    const Chunks& chunks;
     const Assets& assets;
     const Frustum& frustum;
     const EngineSettings& settings;
@@ -57,6 +59,7 @@ class ChunksRenderer {
 public:
     ChunksRenderer(
         const Level* level,
+        const Chunks& chunks,
         const Assets& assets,
         const Frustum& frustum,
         const ContentGfxCache& cache, 
diff --git a/src/graphics/render/Decorator.cpp b/src/graphics/render/Decorator.cpp
index 95ccbcc23..4c9b92899 100644
--- a/src/graphics/render/Decorator.cpp
+++ b/src/graphics/render/Decorator.cpp
@@ -10,10 +10,11 @@
 #include "voxels/Block.hpp"
 #include "world/Level.hpp"
 #include "window/Camera.hpp"
+#include "objects/Player.hpp"
 #include "objects/Players.hpp"
 #include "logic/LevelController.hpp"
 #include "util/stringutil.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "files/files.hpp"
 
 namespace fs = std::filesystem;
@@ -29,13 +30,17 @@ inline constexpr int ITERATIONS = 512;
 inline constexpr int BIG_PRIME = 666667;
 
 Decorator::Decorator(
-    Engine& engine, LevelController& controller, WorldRenderer& renderer, const Assets& assets
+    Engine& engine,
+    LevelController& controller,
+    WorldRenderer& renderer,
+    const Assets& assets,
+    Player& player
 )
     : engine(engine),
       level(*controller.getLevel()),
       renderer(renderer),
       assets(assets),
-      player(*controller.getPlayer()) {
+      player(player) {
     controller.getBlocksController()->listenBlockInteraction(
     [this](auto player, const auto& pos, const auto& def, BlockInteraction type) {
         if (type == BlockInteraction::placing && def.particles) {
@@ -43,7 +48,7 @@ Decorator::Decorator(
         }
     });
     for (const auto& [id, player] : *level.players) {
-        if (id == controller.getPlayer()->getId()) {
+        if (id == this->player.getId()) {
             continue;
         }
         playerTexts[id] = renderer.texts->add(std::make_unique<TextNote>(
@@ -80,8 +85,8 @@ void Decorator::update(
     int index = currentIndex;
     currentIndex = (currentIndex + BIG_PRIME) % UPDATE_BLOCKS;
 
-    const auto& chunks = *level.chunks;
-    const auto& indices = *level.content->getIndices();
+    const auto& chunks = *player.chunks;
+    const auto& indices = *level.content.getIndices();
 
     int lx = index % UPDATE_AREA_DIAMETER;
     int lz = (index / UPDATE_AREA_DIAMETER) % UPDATE_AREA_DIAMETER;
@@ -102,8 +107,8 @@ void Decorator::update(float delta, const Camera& camera) {
     for (int i = 0; i < ITERATIONS; i++) {
         update(delta, pos - glm::ivec3(UPDATE_AREA_DIAMETER / 2), pos);
     }
-    const auto& chunks = *level.chunks;
-    const auto& indices = *level.content->getIndices();
+    const auto& chunks = *player.chunks;
+    const auto& indices = *level.content.getIndices();
     auto iter = blockEmitters.begin();
     while (iter != blockEmitters.end()) {
         auto emitter = renderer.particles->getEmitter(iter->second);
diff --git a/src/graphics/render/Decorator.hpp b/src/graphics/render/Decorator.hpp
index 422f6f777..e1b7eb178 100644
--- a/src/graphics/render/Decorator.hpp
+++ b/src/graphics/render/Decorator.hpp
@@ -39,7 +39,8 @@ class Decorator {
         Engine& engine,
         LevelController& level,
         WorldRenderer& renderer,
-        const Assets& assets
+        const Assets& assets,
+        Player& player
     );
 
     void update(float delta, const Camera& camera);
diff --git a/src/graphics/render/ParticlesRenderer.cpp b/src/graphics/render/ParticlesRenderer.cpp
index e96eb615a..f61b67fdc 100644
--- a/src/graphics/render/ParticlesRenderer.cpp
+++ b/src/graphics/render/ParticlesRenderer.cpp
@@ -16,12 +16,17 @@ size_t ParticlesRenderer::visibleParticles = 0;
 size_t ParticlesRenderer::aliveEmitters = 0;
 
 ParticlesRenderer::ParticlesRenderer(
-    const Assets& assets, const Level& level, const GraphicsSettings* settings
+    const Assets& assets,
+    const Level& level,
+    const Chunks& chunks,
+    const GraphicsSettings* settings
 )
     : batch(std::make_unique<MainBatch>(4096)),
       level(level),
+      chunks(chunks),
       assets(assets),
-      settings(settings) {}
+      settings(settings) {
+}
 
 ParticlesRenderer::~ParticlesRenderer() = default;
 
@@ -46,7 +51,6 @@ void ParticlesRenderer::renderParticles(const Camera& camera, float delta) {
     const auto& right = camera.right;
     const auto& up = camera.up;
 
-    const auto& chunks = *level.chunks;
     bool backlight = settings->backlight.get();
 
     std::vector<const Texture*> unusedTextures;
diff --git a/src/graphics/render/ParticlesRenderer.hpp b/src/graphics/render/ParticlesRenderer.hpp
index 46509d96a..3fe692e5d 100644
--- a/src/graphics/render/ParticlesRenderer.hpp
+++ b/src/graphics/render/ParticlesRenderer.hpp
@@ -10,12 +10,14 @@
 class Texture;
 class Assets;
 class Camera;
+class Chunks;
 class MainBatch;
 class Level;
 struct GraphicsSettings;
 
 class ParticlesRenderer {
     const Level& level;
+    const Chunks& chunks;
     const Assets& assets;
     const GraphicsSettings* settings;
     std::unordered_map<const Texture*, std::vector<Particle>> particles;
@@ -29,6 +31,7 @@ class ParticlesRenderer {
     ParticlesRenderer(
         const Assets& assets,
         const Level& level,
+        const Chunks& chunks,
         const GraphicsSettings* settings
     );
     ~ParticlesRenderer();
diff --git a/src/graphics/render/WorldRenderer.cpp b/src/graphics/render/WorldRenderer.cpp
index 19d6d232f..f83363cdb 100644
--- a/src/graphics/render/WorldRenderer.cpp
+++ b/src/graphics/render/WorldRenderer.cpp
@@ -11,8 +11,9 @@
 #include "assets/Assets.hpp"
 #include "assets/assets_util.hpp"
 #include "content/Content.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "frontend/LevelFrontend.hpp"
+#include "frontend/ContentGfxCache.hpp"
 #include "items/Inventory.hpp"
 #include "items/ItemDef.hpp"
 #include "items/ItemStack.hpp"
@@ -58,37 +59,40 @@ bool WorldRenderer::showChunkBorders = false;
 bool WorldRenderer::showEntitiesDebug = false;
 
 WorldRenderer::WorldRenderer(
-    Engine* engine, LevelFrontend& frontend, Player* player
+    Engine& engine, LevelFrontend& frontend, Player& player
 )
     : engine(engine),
       level(frontend.getLevel()),
       player(player),
-      assets(*engine->getAssets()),
+      assets(*engine.getAssets()),
       frustumCulling(std::make_unique<Frustum>()),
       lineBatch(std::make_unique<LineBatch>()),
       batch3d(std::make_unique<Batch3D>(BATCH3D_CAPACITY)),
       modelBatch(std::make_unique<ModelBatch>(
-          MODEL_BATCH_CAPACITY, assets, *level.chunks, engine->getSettings()
+          MODEL_BATCH_CAPACITY, assets, *player.chunks, engine.getSettings()
       )),
       particles(std::make_unique<ParticlesRenderer>(
-          assets, level, &engine->getSettings().graphics
+          assets, level, *player.chunks, &engine.getSettings().graphics
       )),
       texts(std::make_unique<TextsRenderer>(*batch3d, assets, *frustumCulling)),
       guides(std::make_unique<GuidesRenderer>()),
       chunks(std::make_unique<ChunksRenderer>(
           &level,
+          *player.chunks,
           assets,
           *frustumCulling,
           frontend.getContentGfxCache(),
-          engine->getSettings()
+          engine.getSettings()
       )),
-      blockWraps(std::make_unique<BlockWrapsRenderer>(assets, level)) {
-    auto& settings = engine->getSettings();
+      blockWraps(
+          std::make_unique<BlockWrapsRenderer>(assets, level, *player.chunks)
+      ) {
+    auto& settings = engine.getSettings();
     level.events->listen(
         EVT_CHUNK_HIDDEN,
-        [this](lvl_event_type, Chunk* chunk) { chunks->unload(chunk); }
+        [this](LevelEventType, Chunk* chunk) { chunks->unload(chunk); }
     );
-    auto assets = engine->getAssets();
+    auto assets = engine.getAssets();
     skybox = std::make_unique<Skybox>(
         settings.graphics.skyboxResolution.get(),
         assets->require<Shader>("skybox_gen")
@@ -116,11 +120,11 @@ void WorldRenderer::setupWorldShader(
     shader.uniform3f("u_cameraPos", camera.position);
     shader.uniform1i("u_cubemap", 1);
 
-    auto indices = level.content->getIndices();
+    auto indices = level.content.getIndices();
     // Light emission when an emissive item is chosen
     {
-        auto inventory = player->getInventory();
-        ItemStack& stack = inventory->getSlot(player->getChosenSlot());
+        auto inventory = player.getInventory();
+        ItemStack& stack = inventory->getSlot(player.getChosenSlot());
         auto& item = indices->items.require(stack.getItemId());
         float multiplier = 0.5f;
         shader.uniform3f(
@@ -143,7 +147,7 @@ void WorldRenderer::renderLevel(
 ) {
     texts->render(ctx, camera, settings, hudVisible, false);
 
-    bool culling = engine->getSettings().graphics.frustumCulling.get();
+    bool culling = engine.getSettings().graphics.frustumCulling.get();
     float fogFactor =
         15.0f / static_cast<float>(settings.chunks.loadDistance.get() - 2);
 
@@ -172,7 +176,7 @@ void WorldRenderer::renderLevel(
     setupWorldShader(shader, camera, settings, fogFactor);
 
     chunks->drawChunks(camera, shader);
-    blockWraps->draw(ctx, *player);
+    blockWraps->draw(ctx, player);
 
     if (hudVisible) {
         renderLines(camera, linesShader, ctx);
@@ -188,11 +192,11 @@ void WorldRenderer::renderLevel(
 }
 
 void WorldRenderer::renderBlockSelection() {
-    const auto& selection = player->selection;
-    auto indices = level.content->getIndices();
+    const auto& selection = player.selection;
+    auto indices = level.content.getIndices();
     blockid_t id = selection.vox.id;
     auto& block = indices->blocks.require(id);
-    const glm::ivec3 pos = player->selection.position;
+    const glm::ivec3 pos = player.selection.position;
     const glm::vec3 point = selection.hitPosition;
     const glm::vec3 norm = selection.normal;
 
@@ -207,7 +211,7 @@ void WorldRenderer::renderBlockSelection() {
         lineBatch->box(
             center, size + glm::vec3(0.01), glm::vec4(0.f, 0.f, 0.f, 0.5f)
         );
-        if (player->debug) {
+        if (debug) {
             lineBatch->line(
                 point, point + norm * 0.5f, glm::vec4(1.0f, 0.0f, 1.0f, 1.0f)
             );
@@ -221,12 +225,12 @@ void WorldRenderer::renderLines(
 ) {
     linesShader.use();
     linesShader.uniformMatrix("u_projview", camera.getProjView());
-    if (player->selection.vox.id != BLOCK_VOID) {
+    if (player.selection.vox.id != BLOCK_VOID) {
         renderBlockSelection();
     }
-    if (player->debug && showEntitiesDebug) {
+    if (debug && showEntitiesDebug) {
         auto ctx = pctx.sub(lineBatch.get());
-        bool culling = engine->getSettings().graphics.frustumCulling.get();
+        bool culling = engine.getSettings().graphics.frustumCulling.get();
         level.entities->renderDebug(
             *lineBatch, culling ? frustumCulling.get() : nullptr, ctx
         );
@@ -237,11 +241,11 @@ void WorldRenderer::renderHands(
     const Camera& camera, float delta
 ) {
     auto& entityShader = assets.require<Shader>("entity");
-    auto indices = level.content->getIndices();
+    auto indices = level.content.getIndices();
 
     // get current chosen item
-    const auto& inventory = player->getInventory();
-    int slot = player->getChosenSlot();
+    const auto& inventory = player.getInventory();
+    int slot = player.getChosenSlot();
     const ItemStack& stack = inventory->getSlot(slot);
     const auto& def = indices->items.require(stack.getItemId());
 
@@ -270,8 +274,8 @@ void WorldRenderer::renderHands(
                  glm::mat4(1.0f), -glm::pi<float>() * 0.5f, glm::vec3(0, 1, 0)
              );
     prevRotation = rotation;
-    auto offset = -(camera.position - player->getPosition());
-    float angle = glm::radians(player->cam.x - 90);
+    auto offset = -(camera.position - player.getPosition());
+    float angle = glm::radians(player.rotation.x - 90);
     float cos = glm::cos(angle);
     float sin = glm::sin(angle);
 
@@ -289,7 +293,7 @@ void WorldRenderer::renderHands(
         nullptr
     );
     Window::clearDepth();
-    setupWorldShader(entityShader, hudcam, engine->getSettings(), 0.0f);
+    setupWorldShader(entityShader, hudcam, engine.getSettings(), 0.0f);
     skybox->bind();
     modelBatch->render();
     modelBatch->setLightsOffset(glm::vec3());
@@ -309,12 +313,12 @@ void WorldRenderer::draw(
     const Viewport& vp = pctx.getViewport();
     camera.aspect = vp.getWidth() / static_cast<float>(vp.getHeight());
 
-    const auto& settings = engine->getSettings();
+    const auto& settings = engine.getSettings();
     const auto& worldInfo = world->getInfo();
 
     skybox->refresh(pctx, worldInfo.daytime, 1.0f + worldInfo.fog * 2.0f, 4);
 
-    const auto& assets = *engine->getAssets();
+    const auto& assets = *engine.getAssets();
     auto& linesShader = assets.require<Shader>("lines");
 
     /* World render scope with diegetic HUD included */ {
@@ -333,12 +337,12 @@ void WorldRenderer::draw(
             renderLevel(ctx, camera, settings, delta, pause, hudVisible);
             // Debug lines
             if (hudVisible) {
-                if (player->debug) {
+                if (debug) {
                     guides->renderDebugLines(
                         ctx, camera, *lineBatch, linesShader, showChunkBorders
                     );
                 }
-                if (player->currentCamera == player->fpCamera) {
+                if (player.currentCamera == player.fpCamera) {
                     renderHands(camera, delta * !pause);
                 }
             }
@@ -359,13 +363,12 @@ void WorldRenderer::draw(
 }
 
 void WorldRenderer::renderBlockOverlay(const DrawContext& wctx) {
-    int x = std::floor(player->currentCamera->position.x);
-    int y = std::floor(player->currentCamera->position.y);
-    int z = std::floor(player->currentCamera->position.z);
-    auto block = level.chunks->get(x, y, z);
+    int x = std::floor(player.currentCamera->position.x);
+    int y = std::floor(player.currentCamera->position.y);
+    int z = std::floor(player.currentCamera->position.z);
+    auto block = player.chunks->get(x, y, z);
     if (block && block->id) {
-        const auto& def =
-            level.content->getIndices()->blocks.require(block->id);
+        const auto& def = level.content.getIndices()->blocks.require(block->id);
         if (def.overlayTexture.empty()) {
             return;
         }
@@ -381,7 +384,7 @@ void WorldRenderer::renderBlockOverlay(const DrawContext& wctx) {
         batch3d->begin();
         shader.uniformMatrix("u_projview", glm::mat4(1.0f));
         shader.uniformMatrix("u_apply", glm::mat4(1.0f));
-        auto light = level.chunks->getLight(x, y, z);
+        auto light = player.chunks->getLight(x, y, z);
         float s = Lightmap::extract(light, 3) / 15.0f;
         glm::vec4 tint(
             glm::min(1.0f, Lightmap::extract(light, 0) / 15.0f + s),
@@ -406,3 +409,7 @@ void WorldRenderer::renderBlockOverlay(const DrawContext& wctx) {
 void WorldRenderer::clear() {
     chunks->clear();
 }
+
+void WorldRenderer::setDebug(bool flag) {
+    debug = flag;
+}
diff --git a/src/graphics/render/WorldRenderer.hpp b/src/graphics/render/WorldRenderer.hpp
index c3ea72f18..569858d8b 100644
--- a/src/graphics/render/WorldRenderer.hpp
+++ b/src/graphics/render/WorldRenderer.hpp
@@ -32,9 +32,9 @@ class Assets;
 struct EngineSettings;
 
 class WorldRenderer {
-    Engine* engine;
+    Engine& engine;
     const Level& level;
-    Player* player;
+    Player& player;
     const Assets& assets;
     std::unique_ptr<Frustum> frustumCulling;
     std::unique_ptr<LineBatch> lineBatch;
@@ -45,6 +45,7 @@ class WorldRenderer {
     std::unique_ptr<ModelBatch> modelBatch;
     
     float timer = 0.0f;
+    bool debug = false;
 
     /// @brief Render block selection lines
     void renderBlockSelection();
@@ -74,7 +75,7 @@ class WorldRenderer {
     static bool showChunkBorders;
     static bool showEntitiesDebug;
 
-    WorldRenderer(Engine* engine, LevelFrontend& frontend, Player* player);
+    WorldRenderer(Engine& engine, LevelFrontend& frontend, Player& player);
     ~WorldRenderer();
 
     void draw(
@@ -100,4 +101,6 @@ class WorldRenderer {
     );
 
     void clear();
+
+    void setDebug(bool flag);
 };
diff --git a/src/graphics/ui/GUI.cpp b/src/graphics/ui/GUI.cpp
index 38bc22573..4285179ed 100644
--- a/src/graphics/ui/GUI.cpp
+++ b/src/graphics/ui/GUI.cpp
@@ -23,7 +23,7 @@
 
 using namespace gui;
 
-GUI::GUI() {
+GUI::GUI() : batch2D(std::make_unique<Batch2D>(1024)) {
     container = std::make_shared<Container>(glm::vec2(1000));
     uicamera = std::make_unique<Camera>(glm::vec3(), Window::height);
     uicamera->perspective = false;
@@ -46,6 +46,15 @@ GUI::GUI() {
 
 GUI::~GUI() = default;
 
+void GUI::setPageLoader(PageLoaderFunc pageLoader) {
+    this->pagesLoader = std::move(pageLoader);
+    menu->setPageLoader(this->pagesLoader);
+}
+
+PageLoaderFunc GUI::getPagesLoader() {
+    return pagesLoader;
+}
+
 std::shared_ptr<Menu> GUI::getMenu() {
     return menu;
 }
@@ -198,7 +207,9 @@ void GUI::act(float delta, const Viewport& vp) {
 }
 
 void GUI::draw(const DrawContext& pctx, const Assets& assets) {
-    auto& viewport = pctx.getViewport();
+    auto ctx = pctx.sub(batch2D.get());
+
+    auto& viewport = ctx.getViewport();
     glm::vec2 wsize = viewport.size();
 
     menu->setPos((wsize - menu->getSize()) / 2.0f);
@@ -208,8 +219,12 @@ void GUI::draw(const DrawContext& pctx, const Assets& assets) {
     uishader->use();
     uishader->uniformMatrix("u_projview", uicamera->getProjView());
 
-    pctx.getBatch2D()->begin();
-    container->draw(pctx, assets);
+    batch2D->begin();
+    container->draw(ctx, assets);
+
+    if (hover) {
+        Window::setCursor(hover->getCursor());
+    }
 }
 
 std::shared_ptr<UINode> GUI::getFocused() const {
diff --git a/src/graphics/ui/GUI.hpp b/src/graphics/ui/GUI.hpp
index c0dec6490..f8cea3ef0 100644
--- a/src/graphics/ui/GUI.hpp
+++ b/src/graphics/ui/GUI.hpp
@@ -13,6 +13,7 @@ class Viewport;
 class DrawContext;
 class Assets;
 class Camera;
+class Batch2D;
 
 /*
  Some info about padding and margin.
@@ -50,8 +51,11 @@ namespace gui {
     class Container;
     class Menu;
 
+    using PageLoaderFunc = std::function<std::shared_ptr<UINode>(const std::string&)>;
+
     /// @brief The main UI controller
     class GUI {
+        std::unique_ptr<Batch2D> batch2D;
         std::shared_ptr<Container> container;
         std::shared_ptr<UINode> hover;
         std::shared_ptr<UINode> pressed;
@@ -63,6 +67,8 @@ namespace gui {
         std::shared_ptr<Menu> menu;
         std::queue<runnable> postRunnables;
 
+        PageLoaderFunc pagesLoader;
+
         float tooltipTimer = 0.0f;
         float doubleClickTimer = 0.0f;
         float doubleClickDelay = 0.5f;
@@ -76,6 +82,10 @@ namespace gui {
         GUI();
         ~GUI();
 
+        void setPageLoader(PageLoaderFunc pageLoader);
+        
+        PageLoaderFunc getPagesLoader();
+
         /// @brief Get the main menu (Menu) node
         std::shared_ptr<Menu> getMenu();
 
diff --git a/src/graphics/ui/elements/Container.hpp b/src/graphics/ui/elements/Container.hpp
index f0d37a8d4..c51d528a9 100644
--- a/src/graphics/ui/elements/Container.hpp
+++ b/src/graphics/ui/elements/Container.hpp
@@ -2,11 +2,12 @@
 
 #include "UINode.hpp"
 #include "commons.hpp"
+#include "util/ObjectsKeeper.hpp"
 
 #include <vector>
 
 namespace gui {
-    class Container : public UINode {
+    class Container : public UINode, public util::ObjectsKeeper {
         int prevScrollY = -1;
     protected:
         std::vector<std::shared_ptr<UINode>> nodes;
diff --git a/src/graphics/ui/elements/Menu.cpp b/src/graphics/ui/elements/Menu.cpp
index 99d631bfc..1756baec9 100644
--- a/src/graphics/ui/elements/Menu.cpp
+++ b/src/graphics/ui/elements/Menu.cpp
@@ -13,34 +13,40 @@ bool Menu::has(const std::string& name) {
            pageSuppliers.find(name) != pageSuppliers.end();
 }
 
-void Menu::addPage(const std::string& name, const std::shared_ptr<UINode> &panel) {
-    pages[name] = Page{name, panel};
+void Menu::addPage(
+    const std::string& name, const std::shared_ptr<UINode>& panel, bool temporal
+) {
+    pages[name] = Page {name, panel, temporal};
 }
 
-void Menu::addSupplier(const std::string &name, const supplier<std::shared_ptr<UINode>> &pageSupplier) {
+void Menu::removePage(const std::string& name) {
+    pages.erase(name);
+}
+
+void Menu::addSupplier(const std::string& name, const supplier<std::shared_ptr<UINode>>& pageSupplier) {
     pageSuppliers[name] = pageSupplier;
 }
 
-std::shared_ptr<UINode> Menu::fetchPage(const std::string& name) {
+Page Menu::fetchPage(const std::string& name) {
     auto found = pages.find(name);
     if (found == pages.end()) {
         auto supplier = pageSuppliers.find(name);
         if (supplier == pageSuppliers.end()) {
             if (pagesLoader) {
-                return pagesLoader(name);
+                return {name, pagesLoader(name), false};
             }
-            return nullptr;
+            return {};
         } else {
-            return supplier->second();
+            return {name, supplier->second(), false};
             // supplied pages caching is not implemented
         }
     } else {
-        return found->second.panel;
+        return found->second;
     }
 }
 
 void Menu::setPage(const std::string &name, bool history) {
-    Page page {name, fetchPage(name)};
+    Page page = fetchPage(name);
     if (page.panel == nullptr) {
         throw std::runtime_error("no page found");
     }
@@ -50,7 +56,7 @@ void Menu::setPage(const std::string &name, bool history) {
 void Menu::setPage(Page page, bool history) {
     if (current.panel) {
         Container::remove(current.panel);
-        if (history) {
+        if (history && !current.temporal) {
             pageStack.push(current);
         }
     }
@@ -64,19 +70,23 @@ void Menu::back() {
         return;
     Page page = pageStack.top();
     pageStack.pop();
-    
+
     auto updated = fetchPage(page.name);
-    if (updated) {
-        page.panel = updated;
+    if (updated.panel) {
+        page.panel = updated.panel;
     }
 
     setPage(page, false);
 }
 
-void Menu::setPageLoader(page_loader_func loader) {
+void Menu::setPageLoader(PageLoaderFunc loader) {
     pagesLoader = std::move(loader);
 }
 
+PageLoaderFunc Menu::getPageLoader() {
+    return pagesLoader;
+}
+
 Page& Menu::getCurrent() {
     return current;
 }
@@ -89,6 +99,6 @@ void Menu::reset() {
     clearHistory();
     if (current.panel) {
         Container::remove(current.panel);
-        current = Page{"", nullptr};
+        current = Page {"", nullptr};
     }
 }
diff --git a/src/graphics/ui/elements/Menu.hpp b/src/graphics/ui/elements/Menu.hpp
index 5a201c01d..a65509070 100644
--- a/src/graphics/ui/elements/Menu.hpp
+++ b/src/graphics/ui/elements/Menu.hpp
@@ -8,9 +8,10 @@ namespace gui {
     struct Page {
         std::string name;
         std::shared_ptr<UINode> panel;
+        bool temporal = false;
     };
 
-    using page_loader_func = std::function<std::shared_ptr<UINode>(const std::string& name)>;
+    using PageLoaderFunc = std::function<std::shared_ptr<UINode>(const std::string&)>;
 
     class Menu : public Container {
     protected:
@@ -18,7 +19,7 @@ namespace gui {
         std::stack<Page> pageStack;
         Page current;
         std::unordered_map<std::string, supplier<std::shared_ptr<UINode>>> pageSuppliers;
-        page_loader_func pagesLoader = nullptr;
+        PageLoaderFunc pagesLoader = nullptr;
     public:
         Menu();
 
@@ -31,16 +32,26 @@ namespace gui {
         /// @param history previous page will not be saved in history if false
         void setPage(const std::string &name, bool history=true);
         void setPage(Page page, bool history=true);
-        void addPage(const std::string& name, const std::shared_ptr<UINode>& panel);
-        std::shared_ptr<UINode> fetchPage(const std::string& name);
+        void addPage(
+            const std::string& name,
+            const std::shared_ptr<UINode>& panel,
+            bool temporal = false
+        );
+        void removePage(const std::string& name);
+        Page fetchPage(const std::string& name);
 
         /// @brief Add page supplier used if page is not found
         /// @param name page name
         /// @param pageSupplier page supplier function
-        void addSupplier(const std::string& name, const supplier<std::shared_ptr<UINode>>& pageSupplier);
+        void addSupplier(
+            const std::string& name,
+            const supplier<std::shared_ptr<UINode>>& pageSupplier
+        );
 
         /// @brief Page loader is called if accessed page is not found 
-        void setPageLoader(page_loader_func loader);
+        void setPageLoader(PageLoaderFunc loader);
+
+        PageLoaderFunc getPageLoader();
 
         /// @brief Set page to previous saved in history
         void back();
diff --git a/src/graphics/ui/elements/TextBox.cpp b/src/graphics/ui/elements/TextBox.cpp
index fb24c7e85..f1ed66087 100644
--- a/src/graphics/ui/elements/TextBox.cpp
+++ b/src/graphics/ui/elements/TextBox.cpp
@@ -25,6 +25,7 @@ TextBox::TextBox(std::wstring placeholder, glm::vec4 padding)
     input(L""),
     placeholder(std::move(placeholder))
 {
+    setCursor(CursorShape::TEXT);
     setOnUpPressed(nullptr);
     setOnDownPressed(nullptr);
     setColor(glm::vec4(0.0f, 0.0f, 0.0f, 0.75f));
@@ -698,6 +699,10 @@ std::shared_ptr<UINode> TextBox::getAt(
 void TextBox::setOnUpPressed(const runnable &callback) {
     if (callback == nullptr) {
         onUpPressed = [this]() {
+            if (Events::pressed(keycode::LEFT_CONTROL)) {
+                scrolled(1);
+                return;
+            }
             bool shiftPressed = Events::pressed(keycode::LEFT_SHIFT);
             bool breakSelection = getSelectionLength() != 0 && !shiftPressed;
             stepDefaultUp(shiftPressed, breakSelection);
@@ -710,6 +715,10 @@ void TextBox::setOnUpPressed(const runnable &callback) {
 void TextBox::setOnDownPressed(const runnable &callback) {
     if (callback == nullptr) {
         onDownPressed = [this]() {
+            if (Events::pressed(keycode::LEFT_CONTROL)) {
+                scrolled(-1);
+                return;
+            }
             bool shiftPressed = Events::pressed(keycode::LEFT_SHIFT);
             bool breakSelection = getSelectionLength() != 0 && !shiftPressed;
             stepDefaultDown(shiftPressed, breakSelection);
diff --git a/src/graphics/ui/elements/UINode.cpp b/src/graphics/ui/elements/UINode.cpp
index 0dc305ed1..a6fa38c2e 100644
--- a/src/graphics/ui/elements/UINode.cpp
+++ b/src/graphics/ui/elements/UINode.cpp
@@ -150,6 +150,14 @@ float UINode::getTooltipDelay() const {
     return tooltipDelay;
 }
 
+void UINode::setCursor(CursorShape shape) {
+    cursor = shape;
+}
+
+CursorShape UINode::getCursor() const {
+    return cursor;
+}
+
 glm::vec2 UINode::calcPos() const {
     if (parent) {
         return pos + parent->calcPos() + parent->getContentOffset();
diff --git a/src/graphics/ui/elements/UINode.hpp b/src/graphics/ui/elements/UINode.hpp
index 19f3b8bbc..af0ab1454 100644
--- a/src/graphics/ui/elements/UINode.hpp
+++ b/src/graphics/ui/elements/UINode.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "delegates.hpp"
+#include "graphics/core/commons.hpp"
 #include "window/input.hpp"
 
 #include <glm/glm.hpp>
@@ -112,6 +113,8 @@ namespace gui {
         std::wstring tooltip;
         /// @brief element tooltip delay
         float tooltipDelay = 0.5f;
+        /// @brief cursor shape when mouse is over the element
+        CursorShape cursor = CursorShape::ARROW;
 
         UINode(glm::vec2 size);
     public:
@@ -206,6 +209,9 @@ namespace gui {
         virtual void setTooltipDelay(float delay);
         virtual float getTooltipDelay() const;
 
+        virtual void setCursor(CursorShape shape);
+        virtual CursorShape getCursor() const;
+
         virtual glm::vec4 calcColor() const;
 
         /// @brief Get inner content offset. Used for scroll
diff --git a/src/graphics/ui/gui_util.cpp b/src/graphics/ui/gui_util.cpp
index 95e375146..b84dcfd0e 100644
--- a/src/graphics/ui/gui_util.cpp
+++ b/src/graphics/ui/gui_util.cpp
@@ -11,6 +11,9 @@
 #include "util/stringutil.hpp"
 #include "delegates.hpp"
 
+#include "window/Events.hpp"
+#include "engine/Engine.hpp"
+
 #include <glm/glm.hpp>
 
 using namespace gui;
@@ -23,64 +26,109 @@ std::shared_ptr<gui::UINode> guiutil::create(const std::string& source, scripten
     return reader.readXML("[string]", source);
 }
 
-void guiutil::alert(GUI* gui, const std::wstring& text, const runnable& on_hidden) {
-    auto menu = gui->getMenu();
-    auto panel = std::make_shared<Panel>(glm::vec2(500, 300), glm::vec4(8.0f), 8.0f);
+void guiutil::alert(
+    Engine& engine,
+    const std::wstring& text,
+    const runnable& on_hidden
+) {
+    auto panel = std::make_shared<Panel>(glm::vec2(500, 300), glm::vec4(4.0f), 4.0f);
     panel->setColor(glm::vec4(0.0f, 0.0f, 0.0f, 0.5f));
+
+    auto menu = engine.getGUI()->getMenu();
+    runnable on_hidden_final = [on_hidden, menu, &engine]() {
+        menu->removePage("<alert>");
+        if (on_hidden) {
+            on_hidden();
+        } else {
+            menu->back();
+        }
+    };
     
     auto label = std::make_shared<Label>(text);
     label->setMultiline(true);
-    label->setSize(glm::vec2(1, 90));
+    label->setSize(glm::vec2(1, 24));
     panel->add(label);
     panel->add(std::make_shared<Button>(
         langs::get(L"Ok"), glm::vec4(10.f), 
         [=](GUI*) {
-            if (on_hidden) {
-                on_hidden();
-            }
-            menu->back();
+            on_hidden_final();
         }
     ));
     panel->refresh();
-    menu->addPage("<alert>", panel);
+    panel->keepAlive(Events::keyCallbacks[keycode::ENTER].add([=](){
+        on_hidden_final();
+        return true;
+    }));
+    panel->keepAlive(Events::keyCallbacks[keycode::ESCAPE].add([=](){
+        on_hidden_final();
+        return true;
+    }));
+    menu->addPage("<alert>", panel, true);
     menu->setPage("<alert>");
 }
 
 void guiutil::confirm(
-        GUI* gui, 
-        const std::wstring& text, 
-        const runnable& on_confirm,
-        std::wstring yestext, 
-        std::wstring notext) {
+    Engine& engine,
+    const std::wstring& text,
+    const runnable& on_confirm,
+    const runnable& on_deny,
+    std::wstring yestext,
+    std::wstring notext
+) {
     if (yestext.empty()) yestext = langs::get(L"Yes");
     if (notext.empty()) notext = langs::get(L"No");
 
-    auto menu = gui->getMenu();
     auto panel = std::make_shared<Panel>(glm::vec2(600, 200), glm::vec4(8.0f), 8.0f);
     panel->setColor(glm::vec4(0.0f, 0.0f, 0.0f, 0.5f));
     panel->add(std::make_shared<Label>(text));
     auto subpanel = std::make_shared<Panel>(glm::vec2(600, 53));
     subpanel->setColor(glm::vec4(0));
 
-    subpanel->add(std::make_shared<Button>(yestext, glm::vec4(8.f), [=](GUI*){
-        if (on_confirm)
+    auto menu = engine.getGUI()->getMenu();
+
+    runnable on_confirm_final = [on_confirm, menu, &engine]() {
+        menu->removePage("<confirm>");
+        if (on_confirm) {
             on_confirm();
-        menu->back();
+        } else {
+            menu->back();
+        }
+    };
+
+    runnable on_deny_final = [on_deny, menu, &engine]() {
+        menu->removePage("<confirm>");
+        if (on_deny) {
+            on_deny();
+        } else {
+            menu->back();
+        }
+    };
+
+    subpanel->add(std::make_shared<Button>(yestext, glm::vec4(8.f), [=](GUI*){
+        on_confirm_final();
     }));
 
     subpanel->add(std::make_shared<Button>(notext, glm::vec4(8.f), [=](GUI*){
-        menu->back();
+        on_deny_final();
     }));
 
     panel->add(subpanel);
+    panel->keepAlive(Events::keyCallbacks[keycode::ENTER].add([=](){
+        on_confirm_final();
+        return true;
+    }));
+    panel->keepAlive(Events::keyCallbacks[keycode::ESCAPE].add([=](){
+        on_deny_final();
+        return true;
+    }));
 
     panel->refresh();
-    menu->addPage("<confirm>", panel);
+    menu->addPage("<confirm>", panel, true);
     menu->setPage("<confirm>");
 }
 
-void guiutil::confirmWithMemo(
-        gui::GUI* gui, 
+void guiutil::confirm_with_memo(
+        const std::shared_ptr<gui::Menu>& menu,
         const std::wstring& text, 
         const std::wstring& memo,
         const runnable& on_confirm,
@@ -90,7 +138,6 @@ void guiutil::confirmWithMemo(
     if (yestext.empty()) yestext = langs::get(L"Yes");
     if (notext.empty()) notext = langs::get(L"No");
 
-    auto menu = gui->getMenu();
     auto panel = std::make_shared<Panel>(glm::vec2(600, 500), glm::vec4(8.0f), 8.0f);
     panel->setColor(glm::vec4(0.0f, 0.0f, 0.0f, 0.5f));
     panel->add(std::make_shared<Label>(text));
@@ -119,6 +166,6 @@ void guiutil::confirmWithMemo(
     panel->add(subpanel);
 
     panel->refresh();
-    menu->addPage("<confirm>", panel);
+    menu->addPage("<confirm>", panel, true);
     menu->setPage("<confirm>");
 }
diff --git a/src/graphics/ui/gui_util.hpp b/src/graphics/ui/gui_util.hpp
index 7f8d750eb..c52c57d64 100644
--- a/src/graphics/ui/gui_util.hpp
+++ b/src/graphics/ui/gui_util.hpp
@@ -7,26 +7,29 @@
 #include <memory>
 #include <string>
 
+class Engine;
+
 namespace guiutil {
     /// @brief Create element from XML
     /// @param source XML
     std::shared_ptr<gui::UINode> create(const std::string& source, scriptenv env=0);
 
     void alert(
-        gui::GUI* gui, 
+        Engine& engine,
         const std::wstring& text, 
         const runnable& on_hidden=nullptr
     );
 
     void confirm(
-        gui::GUI* gui, 
+        Engine& engine,
         const std::wstring& text, 
         const runnable& on_confirm=nullptr,
+        const runnable& on_deny=nullptr,
         std::wstring yestext=L"", 
         std::wstring notext=L"");
 
-    void confirmWithMemo(
-        gui::GUI* gui, 
+    void confirm_with_memo(
+        const std::shared_ptr<gui::Menu>& menu,
         const std::wstring& text, 
         const std::wstring& memo,
         const runnable& on_confirm=nullptr,
diff --git a/src/graphics/ui/gui_xml.cpp b/src/graphics/ui/gui_xml.cpp
index 22e3caf48..c705d16d9 100644
--- a/src/graphics/ui/gui_xml.cpp
+++ b/src/graphics/ui/gui_xml.cpp
@@ -9,6 +9,8 @@
 #include "elements/TrackBar.hpp"
 #include "elements/InputBindBox.hpp"
 #include "elements/InventoryView.hpp"
+#include "GUI.hpp"
+#include "engine/Engine.hpp"
 
 #include "frontend/menu.hpp"
 #include "frontend/locale.hpp"
@@ -156,6 +158,11 @@ static void _readUINode(
     if (element.has("tooltip-delay")) {
         node.setTooltipDelay(element.attr("tooltip-delay").asFloat());
     }
+    if (element.has("cursor")) {
+        if (auto cursor = CursorShape_from(element.attr("cursor").getText())) {
+            node.setCursor(*cursor);
+        }
+    }
 
     if (auto onclick = create_action(reader, element, "onclick")) {
         node.listenAction(onclick);
@@ -611,8 +618,8 @@ static std::shared_ptr<UINode> readInventory(UiXmlReader& reader, const xml::xml
 
 static std::shared_ptr<UINode> readPageBox(UiXmlReader& reader, const xml::xmlelement& element) {
     auto menu = std::make_shared<Menu>();
-    // fixme
-    menu->setPageLoader(menus::create_page_loader(scripting::engine));
+    // FIXME
+    menu->setPageLoader(scripting::engine->getGUI()->getMenu()->getPageLoader());
     _readContainer(reader, element, *menu);
 
     return menu;
diff --git a/src/interfaces/Process.hpp b/src/interfaces/Process.hpp
new file mode 100644
index 000000000..b62b1e0f0
--- /dev/null
+++ b/src/interfaces/Process.hpp
@@ -0,0 +1,12 @@
+#pragma once
+
+/// @brief Process interface.
+class Process {
+public:
+    virtual ~Process() {}
+
+    virtual bool isActive() const = 0;
+    virtual void update() = 0;
+    virtual void waitForEnd() = 0;
+    virtual void terminate() = 0;
+};
diff --git a/src/items/Inventory.cpp b/src/items/Inventory.cpp
index 00c5589e0..9797a15ed 100644
--- a/src/items/Inventory.cpp
+++ b/src/items/Inventory.cpp
@@ -23,10 +23,13 @@ size_t Inventory::findEmptySlot(size_t begin, size_t end) const {
     return npos;
 }
 
-size_t Inventory::findSlotByItem(itemid_t id, size_t begin, size_t end) {
+size_t Inventory::findSlotByItem(
+    itemid_t id, size_t begin, size_t end, size_t minCount
+) {
     end = std::min(slots.size(), end);
     for (size_t i = begin; i < end; i++) {
-        if (slots[i].getItemId() == id) {
+        const auto& stack = slots[i];
+        if (stack.getItemId() == id && stack.getCount() >= minCount) {
             return i;
         }
     }
diff --git a/src/items/Inventory.hpp b/src/items/Inventory.hpp
index 176ad7eea..495605237 100644
--- a/src/items/Inventory.hpp
+++ b/src/items/Inventory.hpp
@@ -22,7 +22,9 @@ class Inventory : public Serializable {
 
     ItemStack& getSlot(size_t index);
     size_t findEmptySlot(size_t begin = 0, size_t end = -1) const;
-    size_t findSlotByItem(itemid_t id, size_t begin = 0, size_t end = -1);
+    size_t findSlotByItem(
+        itemid_t id, size_t begin = 0, size_t end = -1, size_t minCount = 1
+    );
 
     inline size_t size() const {
         return slots.size();
diff --git a/src/items/ItemDef.hpp b/src/items/ItemDef.hpp
index 7a2ef8d15..f6d612081 100644
--- a/src/items/ItemDef.hpp
+++ b/src/items/ItemDef.hpp
@@ -6,7 +6,7 @@
 #include "data/dv.hpp"
 #include "typedefs.hpp"
 
-struct item_funcs_set {
+struct ItemFuncsSet {
     bool init : 1;
     bool on_use : 1;
     bool on_use_on_block : 1;
@@ -43,7 +43,7 @@ struct ItemDef {
     struct {
         itemid_t id;
         blockid_t placingBlock;
-        item_funcs_set funcsset {};
+        ItemFuncsSet funcsset {};
         bool emissive = false;
     } rt {};
 
diff --git a/src/lighting/LightSolver.cpp b/src/lighting/LightSolver.cpp
index adc34d696..be608f1db 100644
--- a/src/lighting/LightSolver.cpp
+++ b/src/lighting/LightSolver.cpp
@@ -9,8 +9,8 @@
 #include "voxels/voxel.hpp"
 #include "voxels/Block.hpp"
 
-LightSolver::LightSolver(const ContentIndices* contentIds, Chunks* chunks, int channel) 
-    : blockDefs(contentIds->blocks.getDefs()),
+LightSolver::LightSolver(const ContentIndices& contentIds, Chunks& chunks, int channel) 
+    : blockDefs(contentIds.blocks.getDefs()),
       chunks(chunks), 
       channel(channel) {
 }
@@ -18,7 +18,7 @@ LightSolver::LightSolver(const ContentIndices* contentIds, Chunks* chunks, int c
 void LightSolver::add(int x, int y, int z, int emission) {
     if (emission <= 1)
         return;
-    Chunk* chunk = chunks->getChunkByVoxel(x, y, z);
+    Chunk* chunk = chunks.getChunkByVoxel(x, y, z);
     if (chunk == nullptr)
         return;
     ubyte light = chunk->lightmap.get(x-chunk->x*CHUNK_W, y, z-chunk->z*CHUNK_D, channel);
@@ -31,12 +31,11 @@ void LightSolver::add(int x, int y, int z, int emission) {
 }
 
 void LightSolver::add(int x, int y, int z) {
-    assert (chunks != nullptr);
-    add(x,y,z, chunks->getLight(x,y,z, channel));
+    add(x,y,z, chunks.getLight(x,y,z, channel));
 }
 
 void LightSolver::remove(int x, int y, int z) {
-    Chunk* chunk = chunks->getChunkByVoxel(x, y, z);
+    Chunk* chunk = chunks.getChunkByVoxel(x, y, z);
     if (chunk == nullptr)
         return;
 
@@ -68,7 +67,7 @@ void LightSolver::solve(){
             int y = entry.y+coords[imul3+1];
             int z = entry.z+coords[imul3+2];
             
-            Chunk* chunk = chunks->getChunkByVoxel(x,y,z);
+            Chunk* chunk = chunks.getChunkByVoxel(x,y,z);
             if (chunk) {
                 int lx = x - chunk->x * CHUNK_W;
                 int lz = z - chunk->z * CHUNK_D;
@@ -76,7 +75,7 @@ void LightSolver::solve(){
 
                 ubyte light = chunk->lightmap.get(lx,y,lz, channel);
                 if (light != 0 && light == entry.light-1){
-                    voxel* vox = chunks->get(x, y, z);
+                    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]) {
@@ -105,7 +104,7 @@ void LightSolver::solve(){
             int y = entry.y+coords[imul3+1];
             int z = entry.z+coords[imul3+2];
 
-            Chunk* chunk = chunks->getChunkByVoxel(x,y,z);
+            Chunk* chunk = chunks.getChunkByVoxel(x,y,z);
             if (chunk) {
                 int lx = x - chunk->x * CHUNK_W;
                 int lz = z - chunk->z * CHUNK_D;
diff --git a/src/lighting/LightSolver.hpp b/src/lighting/LightSolver.hpp
index 83b994827..e51863e1e 100644
--- a/src/lighting/LightSolver.hpp
+++ b/src/lighting/LightSolver.hpp
@@ -17,10 +17,10 @@ class LightSolver {
     std::queue<lightentry> addqueue;
     std::queue<lightentry> remqueue;
     const Block* const* blockDefs;
-    Chunks* chunks;
+    Chunks& chunks;
     int channel;
 public:
-    LightSolver(const ContentIndices* contentIds, Chunks* chunks, int channel);
+    LightSolver(const ContentIndices& contentIds, Chunks& chunks, int channel);
 
     void add(int x, int y, int z);
     void add(int x, int y, int z, int emission);
diff --git a/src/lighting/Lighting.cpp b/src/lighting/Lighting.cpp
index 6aad3049d..bf55e001a 100644
--- a/src/lighting/Lighting.cpp
+++ b/src/lighting/Lighting.cpp
@@ -11,9 +11,9 @@
 
 #include <memory>
 
-Lighting::Lighting(const Content* content, Chunks* chunks) 
+Lighting::Lighting(const Content& content, Chunks& chunks) 
   : content(content), chunks(chunks) {
-    auto indices = content->getIndices();
+    auto& indices = *content.getIndices();
     solverR = std::make_unique<LightSolver>(indices, chunks, 0);
     solverG = std::make_unique<LightSolver>(indices, chunks, 1);
     solverB = std::make_unique<LightSolver>(indices, chunks, 2);
@@ -23,7 +23,7 @@ Lighting::Lighting(const Content* content, Chunks* chunks)
 Lighting::~Lighting() = default;
 
 void Lighting::clear(){
-    const auto& chunks = this->chunks->getChunks();
+    const auto& chunks = this->chunks.getChunks();
     for (size_t index = 0; index < chunks.size(); index++){
         auto chunk = chunks[index];
         if (chunk == nullptr)
@@ -35,34 +35,34 @@ void Lighting::clear(){
     }
 }
 
-void Lighting::prebuildSkyLight(Chunk* chunk, const ContentIndices* indices){
-    const auto* blockDefs = indices->blocks.getDefs();
+void Lighting::prebuildSkyLight(Chunk& chunk, const ContentIndices& indices){
+    const auto* blockDefs = indices.blocks.getDefs();
 
     int highestPoint = 0;
     for (int z = 0; z < CHUNK_D; z++){
         for (int x = 0; x < CHUNK_W; x++){
             for (int y = CHUNK_H-1; y >= 0; y--){
                 int index = (y * CHUNK_D + z) * CHUNK_W + x;
-                voxel& vox = chunk->voxels[index];
+                voxel& vox = chunk.voxels[index];
                 const Block* block = blockDefs[vox.id];
                 if (!block->skyLightPassing) {
                     if (highestPoint < y)
                         highestPoint = y;
                     break;
                 }
-                chunk->lightmap.setS(x,y,z, 15);
+                chunk.lightmap.setS(x,y,z, 15);
             }
         }
     }
     if (highestPoint < CHUNK_H-1)
         highestPoint++;
-    chunk->lightmap.highestPoint = highestPoint;
+    chunk.lightmap.highestPoint = highestPoint;
 }
 
 void Lighting::buildSkyLight(int cx, int cz){
-    const auto blockDefs = content->getIndices()->blocks.getDefs();
+    const auto blockDefs = content.getIndices()->blocks.getDefs();
 
-    Chunk* chunk = chunks->getChunk(cx, cz);
+    Chunk* chunk = chunks.getChunk(cx, cz);
     for (int z = 0; z < CHUNK_D; z++){
         for (int x = 0; x < CHUNK_W; x++){
             int gx = x + cx * CHUNK_W;
@@ -86,14 +86,15 @@ void Lighting::buildSkyLight(int cx, int cz){
     solverS->solve();
 }
 
-void Lighting::onChunkLoaded(int cx, int cz, bool expand){
-    LightSolver* solverR = this->solverR.get();
-    LightSolver* solverG = this->solverG.get();
-    LightSolver* solverB = this->solverB.get();
-    LightSolver* solverS = this->solverS.get();
 
-    auto blockDefs = content->getIndices()->blocks.getDefs();
-    auto chunk = chunks->getChunk(cx, cz);
+void Lighting::onChunkLoaded(int cx, int cz, bool expand) {
+    auto& solverR = *this->solverR;
+    auto& solverG = *this->solverG;
+    auto& solverB = *this->solverB;
+    auto& solverS = *this->solverS;
+
+    auto blockDefs = content.getIndices()->blocks.getDefs();
+    auto chunk = chunks.getChunk(cx, cz);
 
     for (uint y = 0; y < CHUNK_H; y++){
         for (uint z = 0; z < CHUNK_D; z++){
@@ -103,9 +104,9 @@ void Lighting::onChunkLoaded(int cx, int cz, bool expand){
                 int gx = x + cx * CHUNK_W;
                 int gz = z + cz * CHUNK_D;
                 if (block->rt.emissive){
-                    solverR->add(gx,y,gz,block->emission[0]);
-                    solverG->add(gx,y,gz,block->emission[1]);
-                    solverB->add(gx,y,gz,block->emission[2]);
+                    solverR.add(gx,y,gz,block->emission[0]);
+                    solverG.add(gx,y,gz,block->emission[1]);
+                    solverB.add(gx,y,gz,block->emission[2]);
                 }
             }
         }
@@ -119,10 +120,10 @@ void Lighting::onChunkLoaded(int cx, int cz, bool expand){
                     int gz = z + cz * CHUNK_D;
                     int rgbs = chunk->lightmap.get(x, y, z);
                     if (rgbs){
-                        solverR->add(gx,y,gz, Lightmap::extract(rgbs, 0));
-                        solverG->add(gx,y,gz, Lightmap::extract(rgbs, 1));
-                        solverB->add(gx,y,gz, Lightmap::extract(rgbs, 2));
-                        solverS->add(gx,y,gz, Lightmap::extract(rgbs, 3));
+                        solverR.add(gx,y,gz, Lightmap::extract(rgbs, 0));
+                        solverG.add(gx,y,gz, Lightmap::extract(rgbs, 1));
+                        solverB.add(gx,y,gz, Lightmap::extract(rgbs, 2));
+                        solverS.add(gx,y,gz, Lightmap::extract(rgbs, 3));
                     }
                 }
             }
@@ -134,23 +135,23 @@ void Lighting::onChunkLoaded(int cx, int cz, bool expand){
                     int gz = z + cz * CHUNK_D;
                     int rgbs = chunk->lightmap.get(x, y, z);
                     if (rgbs){
-                        solverR->add(gx,y,gz, Lightmap::extract(rgbs, 0));
-                        solverG->add(gx,y,gz, Lightmap::extract(rgbs, 1));
-                        solverB->add(gx,y,gz, Lightmap::extract(rgbs, 2));
-                        solverS->add(gx,y,gz, Lightmap::extract(rgbs, 3));
+                        solverR.add(gx,y,gz, Lightmap::extract(rgbs, 0));
+                        solverG.add(gx,y,gz, Lightmap::extract(rgbs, 1));
+                        solverB.add(gx,y,gz, Lightmap::extract(rgbs, 2));
+                        solverS.add(gx,y,gz, Lightmap::extract(rgbs, 3));
                     }
                 }
             }
         }
     }
-    solverR->solve();
-    solverG->solve();
-    solverB->solve();
-    solverS->solve();
+    solverR.solve();
+    solverG.solve();
+    solverB.solve();
+    solverS.solve();
 }
 
 void Lighting::onBlockSet(int x, int y, int z, blockid_t id){
-    const auto& block = content->getIndices()->blocks.require(id);
+    const auto& block = content.getIndices()->blocks.require(id);
     solverR->remove(x,y,z);
     solverG->remove(x,y,z);
     solverB->remove(x,y,z);
@@ -159,9 +160,9 @@ void Lighting::onBlockSet(int x, int y, int z, blockid_t id){
         solverR->solve();
         solverG->solve();
         solverB->solve();
-        if (chunks->getLight(x,y+1,z, 3) == 0xF){
+        if (chunks.getLight(x,y+1,z, 3) == 0xF){
             for (int i = y; i >= 0; i--){
-                voxel* vox = chunks->get(x,i,z);
+                voxel* vox = chunks.get(x,i,z);
                 if ((vox == nullptr || vox->id != 0) && block.skyLightPassing)
                     break;
                 solverS->add(x,i,z, 0xF);
@@ -182,7 +183,7 @@ void Lighting::onBlockSet(int x, int y, int z, blockid_t id){
             solverS->remove(x,y,z);
             for (int i = y-1; i >= 0; i--){
                 solverS->remove(x,i,z);
-                if (i == 0 || chunks->get(x,i-1,z)->id != 0){
+                if (i == 0 || chunks.get(x,i-1,z)->id != 0){
                     break;
                 }
             }
diff --git a/src/lighting/Lighting.hpp b/src/lighting/Lighting.hpp
index b1ea2fbc1..622027f05 100644
--- a/src/lighting/Lighting.hpp
+++ b/src/lighting/Lighting.hpp
@@ -9,14 +9,14 @@ class Chunks;
 class LightSolver;
 
 class Lighting {
-    const Content* const content;
-    Chunks* chunks;
+    const Content& content;
+    Chunks& chunks;
     std::unique_ptr<LightSolver> solverR;
     std::unique_ptr<LightSolver> solverG;
     std::unique_ptr<LightSolver> solverB;
     std::unique_ptr<LightSolver> solverS;
 public:
-    Lighting(const Content* content, Chunks* chunks);
+    Lighting(const Content& content, Chunks& chunks);
     ~Lighting();
 
     void clear();
@@ -24,5 +24,5 @@ class Lighting {
     void onChunkLoaded(int cx, int cz, bool expand);
     void onBlockSet(int x, int y, int z, blockid_t id);
 
-    static void prebuildSkyLight(Chunk* chunk, const ContentIndices* indices);
+    static void prebuildSkyLight(Chunk& chunk, const ContentIndices& indices);
 };
diff --git a/src/lighting/Lightmap.cpp b/src/lighting/Lightmap.cpp
index cb077b8b1..24581e246 100644
--- a/src/lighting/Lightmap.cpp
+++ b/src/lighting/Lightmap.cpp
@@ -2,16 +2,15 @@
 
 #include "util/data_io.hpp"
 
-#include <assert.h>
+#include <cassert>
+#include <cstring>
 
 void Lightmap::set(const Lightmap* lightmap) {
     set(lightmap->map);
 }
 
 void Lightmap::set(const light_t* map) {
-    for (size_t i = 0; i < CHUNK_VOL; i++) {
-        this->map[i] = map[i];
-    }
+    std::memcpy(this->map, map, sizeof(light_t) * CHUNK_VOL);
 }
 
 static_assert(sizeof(light_t) == 2, "replace dataio calls to new light_t");
diff --git a/src/logic/BlocksController.cpp b/src/logic/BlocksController.cpp
index 980c8bfee..cdc25b483 100644
--- a/src/logic/BlocksController.cpp
+++ b/src/logic/BlocksController.cpp
@@ -1,5 +1,7 @@
 #include "BlocksController.hpp"
 
+#include <set>
+
 #include "content/Content.hpp"
 #include "items/Inventories.hpp"
 #include "items/Inventory.hpp"
@@ -11,17 +13,19 @@
 #include "voxels/Chunk.hpp"
 #include "voxels/Chunks.hpp"
 #include "voxels/voxel.hpp"
+#include "voxels/blocks_agent.hpp"
 #include "world/Level.hpp"
 #include "world/World.hpp"
+#include "objects/Player.hpp"
+#include "objects/Players.hpp"
 
-BlocksController::BlocksController(const Level& level, uint padding)
+BlocksController::BlocksController(const Level& level, Lighting* lighting)
     : level(level),
       chunks(*level.chunks),
-      lighting(*level.lighting),
+      lighting(lighting),
       randTickClock(20, 3),
       blocksTickClock(20, 1),
-      worldTickClock(20, 1),
-      padding(padding) {
+      worldTickClock(20, 1) {
 }
 
 void BlocksController::updateSides(int x, int y, int z) {
@@ -34,12 +38,12 @@ void BlocksController::updateSides(int x, int y, int z) {
 }
 
 void BlocksController::updateSides(int x, int y, int z, int w, int h, int d) {
-    voxel* vox = chunks.get(x, y, z);
-    const auto& def = level.content->getIndices()->blocks.require(vox->id);
+    voxel* vox = blocks_agent::get(chunks, x, y, z);
+    const auto& def = level.content.getIndices()->blocks.require(vox->id);
     const auto& rot = def.rotations.variants[vox->state.rotation];
-    const auto& xaxis = rot.axisX;
-    const auto& yaxis = rot.axisY;
-    const auto& zaxis = rot.axisZ;
+    const auto& xaxis = rot.axes[0];
+    const auto& yaxis = rot.axes[1];
+    const auto& zaxis = rot.axes[2];
     for (int ly = -1; ly <= h; ly++) {
         for (int lz = -1; lz <= d; lz++) {
             for (int lx = -1; lx <= w; lx++) {
@@ -62,8 +66,10 @@ void BlocksController::breakBlock(
     onBlockInteraction(
         player, glm::ivec3(x, y, z), def, BlockInteraction::destruction
     );
-    chunks.set(x, y, z, 0, {});
-    lighting.onBlockSet(x, y, z, 0);
+    blocks_agent::set(chunks, x, y, z, 0, {});
+    if (lighting) {
+        lighting->onBlockSet(x, y, z, 0);
+    }
     scripting::on_block_broken(player, def, glm::ivec3(x, y, z));
     if (def.rt.extended) {
         updateSides(x, y, z , def.size.x, def.size.y, def.size.z);
@@ -75,18 +81,20 @@ void BlocksController::breakBlock(
 void BlocksController::placeBlock(
     Player* player, const Block& def, blockstate state, int x, int y, int z
 ) {
-    auto voxel = chunks.get(x, y, z);
+    auto voxel = blocks_agent::get(chunks, x, y, z);
     if (voxel == nullptr) {
         return;
     }
-    const auto& prevDef = level.content->getIndices()->blocks.require(voxel->id);
+    const auto& prevDef = level.content.getIndices()->blocks.require(voxel->id);
     scripting::on_block_replaced(player, prevDef, {x, y, z});
 
     onBlockInteraction(
         player, glm::ivec3(x, y, z), def, BlockInteraction::placing
     );
-    chunks.set(x, y, z, def.rt.id, state);
-    lighting.onBlockSet(x, y, z, def.rt.id);
+    blocks_agent::set(chunks, x, y, z, def.rt.id, state);
+    if (lighting) {
+        lighting->onBlockSet(x, y, z, def.rt.id);
+    }
     scripting::on_block_placed(player, def, glm::ivec3(x, y, z));
     if (def.rt.extended) {
         updateSides(x, y, z , def.size.x, def.size.y, def.size.z);
@@ -96,12 +104,12 @@ void BlocksController::placeBlock(
 }
 
 void BlocksController::updateBlock(int x, int y, int z) {
-    voxel* vox = chunks.get(x, y, z);
+    voxel* vox = blocks_agent::get(chunks, x, y, z);
     if (vox == nullptr) return;
-    const auto& def = level.content->getIndices()->blocks.require(vox->id);
+    const auto& def = level.content.getIndices()->blocks.require(vox->id);
     if (def.grounded) {
         const auto& vec = get_ground_direction(def, vox->state.rotation);
-        if (!chunks.isSolidBlock(x + vec.x, y + vec.y, z + vec.z)) {
+        if (!blocks_agent::is_solid_at(chunks, x + vec.x, y + vec.y, z + vec.z)) {
             breakBlock(nullptr, def, x, y, z);
             return;
         }
@@ -111,9 +119,9 @@ void BlocksController::updateBlock(int x, int y, int z) {
     }
 }
 
-void BlocksController::update(float delta) {
+void BlocksController::update(float delta, uint padding) {
     if (randTickClock.update(delta)) {
-        randomTick(randTickClock.getPart(), randTickClock.getParts());
+        randomTick(randTickClock.getPart(), randTickClock.getParts(), padding);
     }
     if (blocksTickClock.update(delta)) {
         onBlocksTick(blocksTickClock.getPart(), blocksTickClock.getParts());
@@ -124,7 +132,7 @@ void BlocksController::update(float delta) {
 }
 
 void BlocksController::onBlocksTick(int tickid, int parts) {
-    const auto& indices = level.content->getIndices()->blocks;
+    const auto& indices = level.content.getIndices()->blocks;
     int tickRate = blocksTickClock.getTickRate();
     for (size_t id = 0; id < indices.count(); id++) {
         if ((id + tickid) % parts != 0) continue;
@@ -160,37 +168,57 @@ void BlocksController::randomTick(
     }
 }
 
-void BlocksController::randomTick(int tickid, int parts) {
-    auto indices = level.content->getIndices();
-    int width = chunks.getWidth();
-    int height = chunks.getHeight();
-    int segments = 4;
-
-    for (uint z = padding; z < height - padding; z++) {
-        for (uint x = padding; x < width - padding; x++) {
-            int index = z * width + x;
-            if ((index + tickid) % parts != 0) {
-                continue;
-            }
-            auto& chunk = chunks.getChunks()[index];
-            if (chunk == nullptr || !chunk->flags.lighted) {
-                continue;
+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;
+
+        for (uint z = padding; z < height - padding; z++) {
+            for (uint x = padding; x < width - padding; x++) {
+                int index = z * width + x;
+                if ((index + tickid) % parts != 0) {
+                    continue;
+                }
+                auto& chunk = chunks.getChunks()[index];
+                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()) {
+                    continue;
+                }
+                chunksIterated.insert(posU.key);
+                randomTick(*chunk, segments, indices);
             }
-            randomTick(*chunk, segments, indices);
         }
     }
 }
 
 int64_t BlocksController::createBlockInventory(int x, int y, int z) {
-    auto chunk = chunks.getChunkByVoxel(x, y, z);
-    if (chunk == nullptr) {
+    auto chunk = blocks_agent::get_chunk(
+        chunks, floordiv<CHUNK_W>(x), floordiv<CHUNK_D>(z)
+    );
+    if (chunk == nullptr || y < 0 || y >= CHUNK_H) {
         return 0;
     }
     int lx = x - chunk->x * CHUNK_W;
     int lz = z - chunk->z * CHUNK_D;
     auto inv = chunk->getBlockInventory(lx, y, lz);
     if (inv == nullptr) {
-        const auto& indices = level.content->getIndices()->blocks;
+        const auto& indices = level.content.getIndices()->blocks;
         auto& def = indices.require(chunk->voxels[vox_index(lx, y, lz)].id);
         int invsize = def.inventorySize;
         if (invsize == 0) {
@@ -203,7 +231,9 @@ int64_t BlocksController::createBlockInventory(int x, int y, int z) {
 }
 
 void BlocksController::bindInventory(int64_t invid, int x, int y, int z) {
-    auto chunk = chunks.getChunkByVoxel(x, y, z);
+    auto chunk = blocks_agent::get_chunk(
+        chunks, floordiv<CHUNK_W>(x), floordiv<CHUNK_D>(z)
+    );
     if (chunk == nullptr) {
         throw std::runtime_error("block does not exists");
     }
@@ -216,7 +246,9 @@ void BlocksController::bindInventory(int64_t invid, int x, int y, int z) {
 }
 
 void BlocksController::unbindInventory(int x, int y, int z) {
-    auto chunk = chunks.getChunkByVoxel(x, y, z);
+    auto chunk = blocks_agent::get_chunk(
+        chunks, floordiv<CHUNK_W>(x), floordiv<CHUNK_D>(z)
+    );
     if (chunk == nullptr) {
         throw std::runtime_error("block does not exists");
     }
diff --git a/src/logic/BlocksController.hpp b/src/logic/BlocksController.hpp
index 0937b3f78..f3fa5f67a 100644
--- a/src/logic/BlocksController.hpp
+++ b/src/logic/BlocksController.hpp
@@ -14,27 +14,27 @@ class Level;
 class Chunk;
 class Chunks;
 class Lighting;
+class GlobalChunks;
 class ContentIndices;
 
 enum class BlockInteraction { step, destruction, placing };
 
 /// @brief Player argument is nullable
 using on_block_interaction = std::function<
-    void(Player*, const glm::ivec3&, const Block&, BlockInteraction type)>;
+    void(Player*, const glm::ivec3&, const Block&, BlockInteraction)>;
 
 /// BlocksController manages block updates and data (inventories, metadata)
 class BlocksController {
     const Level& level;
-    Chunks& chunks;
-    Lighting& lighting;
+    GlobalChunks& chunks;
+    Lighting* lighting;
     util::Clock randTickClock;
     util::Clock blocksTickClock;
     util::Clock worldTickClock;
-    uint padding;
     FastRandom random {};
     std::vector<on_block_interaction> blockInteractionCallbacks;
 public:
-    BlocksController(const Level& level, uint padding);
+    BlocksController(const Level& level, Lighting* lighting);
 
     void updateSides(int x, int y, int z);
     void updateSides(int x, int y, int z, int w, int h, int d);
@@ -45,11 +45,11 @@ class BlocksController {
         Player* player, const Block& def, blockstate state, int x, int y, int z
     );
 
-    void update(float delta);
+    void update(float delta, uint padding);
     void randomTick(
         const Chunk& chunk, int segments, const ContentIndices* indices
     );
-    void randomTick(int tickid, int parts);
+    void randomTick(int tickid, int parts, uint padding);
     void onBlocksTick(int tickid, int parts);
     int64_t createBlockInventory(int x, int y, int z);
     void bindInventory(int64_t invid, int x, int y, int z);
diff --git a/src/logic/ChunksController.cpp b/src/logic/ChunksController.cpp
index f61a27550..8bb0fff4e 100644
--- a/src/logic/ChunksController.cpp
+++ b/src/logic/ChunksController.cpp
@@ -1,8 +1,6 @@
 #include "ChunksController.hpp"
 
 #include <limits.h>
-
-#include <iostream>
 #include <memory>
 
 #include "content/Content.hpp"
@@ -11,10 +9,11 @@
 #include "lighting/Lighting.hpp"
 #include "maths/voxmaths.hpp"
 #include "util/timeutil.hpp"
+#include "objects/Player.hpp"
 #include "voxels/Block.hpp"
 #include "voxels/Chunk.hpp"
 #include "voxels/Chunks.hpp"
-#include "voxels/ChunksStorage.hpp"
+#include "voxels/GlobalChunks.hpp"
 #include "world/Level.hpp"
 #include "world/World.hpp"
 #include "world/generator/WorldGenerator.hpp"
@@ -22,13 +21,10 @@
 const uint MAX_WORK_PER_FRAME = 128;
 const uint MIN_SURROUNDING = 9;
 
-ChunksController::ChunksController(Level& level, uint padding)
+ChunksController::ChunksController(Level& level)
     : level(level),
-      chunks(*level.chunks),
-      lighting(*level.lighting),
-      padding(padding),
       generator(std::make_unique<WorldGenerator>(
-          level.content->generators.require(level.getWorld()->getGenerator()),
+          level.content.generators.require(level.getWorld()->getGenerator()),
           level.content,
           level.getWorld()->getSeed()
       )) {}
@@ -36,15 +32,22 @@ ChunksController::ChunksController(Level& level, uint padding)
 ChunksController::~ChunksController() = default;
 
 void ChunksController::update(
-    int64_t maxDuration, int loadDistance, int centerX, int centerY
-) {
-    generator->update(centerX, centerY, loadDistance);
+    int64_t maxDuration, int loadDistance, uint padding, Player& player
+) const {
+    const auto& position = player.getPosition();
+    int centerX = floordiv<CHUNK_W>(position.x);
+    int centerY = floordiv<CHUNK_D>(position.z);
+    
+    if (player.isLoadingChunks()) {
+        /// FIXME: one generator for multiple players
+        generator->update(centerX, centerY, loadDistance);
+    }
 
     int64_t mcstotal = 0;
 
     for (uint i = 0; i < MAX_WORK_PER_FRAME; i++) {
         timeutil::Timer timer;
-        if (loadVisible()) {
+        if (loadVisible(player, padding)) {
             int64_t mcs = timer.stop();
             if (mcstotal + mcs < maxDuration * 1000) {
                 mcstotal += mcs;
@@ -55,7 +58,8 @@ void ChunksController::update(
     }
 }
 
-bool ChunksController::loadVisible() {
+bool ChunksController::loadVisible(const Player& player, uint padding) const {
+    const auto& chunks = *player.chunks;
     int sizeX = chunks.getWidth();
     int sizeY = chunks.getHeight();
 
@@ -69,7 +73,7 @@ bool ChunksController::loadVisible() {
             auto& chunk = chunks.getChunks()[index];
             if (chunk != nullptr) {
                 if (chunk->flags.loaded && !chunk->flags.lighted) {
-                    if (buildLights(chunk)) {
+                    if (buildLights(player, chunk)) {
                         return true;
                     }
                 }
@@ -93,32 +97,41 @@ bool ChunksController::loadVisible() {
     }
     int offsetX = chunks.getOffsetX();
     int offsetY = chunks.getOffsetY();
-    createChunk(nearX + offsetX, nearZ + offsetY);
+    createChunk(player, nearX + offsetX, nearZ + offsetY);
     return true;
 }
 
-bool ChunksController::buildLights(const std::shared_ptr<Chunk>& chunk) {
+bool ChunksController::buildLights(const Player& player, const std::shared_ptr<Chunk>& chunk) const {
     int surrounding = 0;
     for (int oz = -1; oz <= 1; oz++) {
         for (int ox = -1; ox <= 1; ox++) {
-            if (chunks.getChunk(chunk->x + ox, chunk->z + oz)) surrounding++;
+            if (player.chunks->getChunk(chunk->x + ox, chunk->z + oz))
+                surrounding++;
         }
     }
     if (surrounding == MIN_SURROUNDING) {
-        bool lightsCache = chunk->flags.loadedLights;
-        if (!lightsCache) {
-            lighting.buildSkyLight(chunk->x, chunk->z);
+        if (lighting) {
+            bool lightsCache = chunk->flags.loadedLights;
+            if (!lightsCache) {
+                lighting->buildSkyLight(chunk->x, chunk->z);
+            }
+            lighting->onChunkLoaded(chunk->x, chunk->z, !lightsCache);
         }
-        lighting.onChunkLoaded(chunk->x, chunk->z, !lightsCache);
         chunk->flags.lighted = true;
         return true;
     }
     return false;
 }
 
-void ChunksController::createChunk(int x, int z) {
-    auto chunk = level.chunksStorage->create(x, z);
-    chunks.putChunk(chunk);
+void ChunksController::createChunk(const Player& player, int x, int z) const {
+    if (!player.isLoadingChunks()) {
+        if (auto chunk = level.chunks->fetch(x, z)) {
+            player.chunks->putChunk(chunk);
+        }
+        return;
+    }
+    auto chunk = level.chunks->create(x, z);
+    player.chunks->putChunk(chunk);
     auto& chunkFlags = chunk->flags;
 
     if (!chunkFlags.loaded) {
@@ -128,7 +141,7 @@ void ChunksController::createChunk(int x, int z) {
     chunk->updateHeights();
 
     if (!chunkFlags.loadedLights) {
-        Lighting::prebuildSkyLight(chunk.get(), level.content->getIndices());
+        Lighting::prebuildSkyLight(*chunk, *level.content.getIndices());
     }
     chunkFlags.loaded = true;
     chunkFlags.ready = true;
diff --git a/src/logic/ChunksController.hpp b/src/logic/ChunksController.hpp
index e9f1ab62a..80901bff2 100644
--- a/src/logic/ChunksController.hpp
+++ b/src/logic/ChunksController.hpp
@@ -7,6 +7,7 @@
 class Level;
 class Chunk;
 class Chunks;
+class Player;
 class Lighting;
 class WorldGenerator;
 
@@ -14,25 +15,22 @@ class WorldGenerator;
 class ChunksController {
 private:
     Level& level;
-    Chunks& chunks;
-    Lighting& lighting;
-    uint padding;
     std::unique_ptr<WorldGenerator> generator;
 
     /// @brief Process one chunk: load it or calculate lights for it
-    bool loadVisible();
-    bool buildLights(const std::shared_ptr<Chunk>& chunk);
-    void createChunk(int x, int y);
+    bool loadVisible(const Player& player, uint padding) const;
+    bool buildLights(const Player& player, const std::shared_ptr<Chunk>& chunk) const;
+    void createChunk(const Player& player, int x, int y) const;
 public:
-    ChunksController(Level& level, uint padding);
+    std::unique_ptr<Lighting> lighting;
+
+    ChunksController(Level& level);
     ~ChunksController();
 
     /// @param maxDuration milliseconds reserved for chunks loading
     void update(
-        int64_t maxDuration,
-        int loadDistance,
-        int centerX,
-        int centerY);
+        int64_t maxDuration, int loadDistance, uint padding, Player& player
+    ) const;
 
     const WorldGenerator* getGenerator() const {
         return generator.get();
diff --git a/src/logic/EngineController.cpp b/src/logic/EngineController.cpp
index 4c38fc786..86210cf4b 100644
--- a/src/logic/EngineController.cpp
+++ b/src/logic/EngineController.cpp
@@ -4,9 +4,10 @@
 #include <filesystem>
 #include <memory>
 
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "coders/commons.hpp"
 #include "debug/Logger.hpp"
+#include "coders/json.hpp"
 #include "content/ContentReport.hpp"
 #include "files/WorldConverter.hpp"
 #include "files/WorldFiles.hpp"
@@ -16,6 +17,7 @@
 #include "frontend/screens/MenuScreen.hpp"
 #include "graphics/ui/elements/Menu.hpp"
 #include "graphics/ui/gui_util.hpp"
+#include "objects/Players.hpp"
 #include "interfaces/Task.hpp"
 #include "util/stringutil.hpp"
 #include "world/Level.hpp"
@@ -26,24 +28,34 @@ namespace fs = std::filesystem;
 
 static debug::Logger logger("engine-control");
 
-EngineController::EngineController(Engine* engine) : engine(engine) {
+EngineController::EngineController(Engine& engine) : engine(engine) {
 }
 
 void EngineController::deleteWorld(const std::string& name) {
-    fs::path folder = engine->getPaths()->getWorldFolderByName(name);
+    fs::path folder = engine.getPaths().getWorldFolderByName(name);
+
+    auto deletion = [this, folder]() {
+        logger.info() << "deleting " << folder;
+        fs::remove_all(folder);
+        if (!engine.isHeadless()) {
+            engine.getGUI()->getMenu()->back();
+        }
+    };
+
+    if (engine.isHeadless()) {
+        deletion();
+        return;
+    }
     guiutil::confirm(
-        engine->getGUI(),
+        engine,
         langs::get(L"delete-confirm", L"world") + L" (" +
             util::str2wstr_utf8(folder.u8string()) + L")",
-        [=]() {
-            logger.info() << "deleting " << folder.u8string();
-            fs::remove_all(folder);
-        }
+        deletion
     );
 }
 
 std::shared_ptr<Task> create_converter(
-    Engine* engine,
+    Engine& engine,
     const std::shared_ptr<WorldFiles>& worldFiles,
     const Content* content,
     const std::shared_ptr<ContentReport>& report,
@@ -61,25 +73,25 @@ std::shared_ptr<Task> create_converter(
         worldFiles,
         content,
         report,
-        [=]() {
-            auto menu = engine->getGUI()->getMenu();
-            menu->reset();
-            menu->setPage("main", false);
-            engine->getGUI()->postRunnable([=]() { postRunnable(); });
+        [&engine, postRunnable]() {
+            //auto menu = engine.getGUI()->getMenu();
+            //menu->reset();
+            //menu->setPage("main", false);
+            engine.postRunnable([=]() { postRunnable(); });
         },
         mode,
         true
     );
 }
 
-void show_convert_request(
-    Engine* engine,
+static void show_convert_request(
+    Engine& engine,
     const Content* content,
     const std::shared_ptr<ContentReport>& report,
     const std::shared_ptr<WorldFiles>& worldFiles,
     const runnable& postRunnable
 ) {
-    auto on_confirm = [=]() {
+    auto on_confirm = [&engine, worldFiles, content, report, postRunnable]() {
             auto converter =
                 create_converter(engine, worldFiles, content, report, postRunnable);
             menus::show_process_panel(
@@ -99,8 +111,8 @@ void show_convert_request(
         for (const auto& line : report->getDataLoss()) {
             text += util::str2wstr_utf8(line) + L"\n";
         }
-        guiutil::confirmWithMemo(
-            engine->getGUI(),
+        guiutil::confirm_with_memo(
+            engine.getGUI()->getMenu(),
             langs::get(message),
             text,
             on_confirm,
@@ -110,16 +122,47 @@ void show_convert_request(
         return;
     }
     guiutil::confirm(
-        engine->getGUI(),
+        engine,
         langs::get(message),
         on_confirm,
+        nullptr,
         L"",
         langs::get(L"Cancel")
     );
 }
 
-static void show_content_missing(
-    Engine* engine, const std::shared_ptr<ContentReport>& report
+static bool load_world_content(Engine& engine, const fs::path& folder) {
+    if (engine.isHeadless()) {
+        engine.loadWorldContent(folder);
+        return true;
+    } else {
+        return menus::call(engine, [&engine, folder]() {
+            engine.loadWorldContent(folder);
+        });
+    }
+}
+
+static void load_world(
+    Engine& engine, const std::shared_ptr<WorldFiles>& worldFiles
+) {
+    try {
+        auto content = engine.getContent();
+        auto& packs = engine.getContentPacks();
+        auto& settings = engine.getSettings();
+
+        auto level = World::load(worldFiles, settings, *content, packs);
+        engine.onWorldOpen(std::move(level));
+    } catch (const world_load_error& error) {
+        guiutil::alert(
+            engine,
+            langs::get(L"Error") + L": " + util::str2wstr_utf8(error.what())
+        );
+        return;
+    }
+}
+
+static dv::value create_missing_content_report(
+    const std::shared_ptr<ContentReport>& report
 ) {
     auto root = dv::object();
     auto& contentEntries = root.list("content");
@@ -129,61 +172,59 @@ static void show_content_missing(
         contentEntry["type"] = contentName;
         contentEntry["name"] = entry.name;
     }
-    menus::show(engine, "reports/missing_content", {std::move(root)});
+    return root;
 }
 
-static bool loadWorldContent(Engine* engine, const fs::path& folder) {
-    return menus::call(engine, [engine, folder]() {
-        engine->loadWorldContent(folder);
-    });
-}
-
-static void loadWorld(Engine* engine, const std::shared_ptr<WorldFiles>& worldFiles) {
-    try {
-        auto content = engine->getContent();
-        auto& packs = engine->getContentPacks();
-        auto& settings = engine->getSettings();
-
-        auto level = World::load(worldFiles, settings, content, packs);
-        engine->setScreen(
-            std::make_shared<LevelScreen>(engine, std::move(level))
+void EngineController::onMissingContent(const std::shared_ptr<ContentReport>& report) {
+    if (engine.isHeadless()) {
+        throw std::runtime_error(
+            "missing content: " +
+            json::stringify(create_missing_content_report(report), true)
         );
-    } catch (const world_load_error& error) {
-        guiutil::alert(
-            engine->getGUI(),
-            langs::get(L"Error") + L": " + util::str2wstr_utf8(error.what())
+    } else {
+        engine.setScreen(std::make_shared<MenuScreen>(engine));
+        menus::show(
+            engine,
+            "reports/missing_content",
+            {create_missing_content_report(report)}
         );
-        return;
     }
 }
 
 void EngineController::openWorld(const std::string& name, bool confirmConvert) {
-    auto paths = engine->getPaths();
-    auto folder = paths->getWorldsFolder() / fs::u8path(name);
-    if (!loadWorldContent(engine, folder)) {
+    const auto& paths = engine.getPaths();
+    auto folder = paths.getWorldsFolder() / fs::u8path(name);
+    auto worldFile = folder / fs::u8path("world.json");
+    if (!fs::exists(worldFile)) {
+        throw std::runtime_error(worldFile.u8string() + " does not exists");
+    }
+
+    if (!load_world_content(engine, folder)) {
         return;
     }
 
-    auto* content = engine->getContent();
+    const Content* content = engine.getContent();
     auto worldFiles = std::make_shared<WorldFiles>(
-        folder, engine->getSettings().debug);
+        folder, engine.getSettings().debug);
     if (auto report = World::checkIndices(worldFiles, content)) {
         if (report->hasMissingContent()) {
-            engine->setScreen(std::make_shared<MenuScreen>(engine));
-            show_content_missing(engine, report);
+            onMissingContent(report);
         } else {
             if (confirmConvert) {
-                menus::show_process_panel(
+                auto task = create_converter(
                     engine,
-                    create_converter(
-                        engine,
-                        worldFiles,
-                        content,
-                        report,
-                        [=]() { openWorld(name, false); }
-                    ),
-                    L"Converting world..."
+                    worldFiles,
+                    content,
+                    report,
+                    [=]() { openWorld(name, false); }
                 );
+                if (engine.isHeadless()) {
+                    task->waitForEnd();
+                } else {
+                    menus::show_process_panel(
+                        engine, task, L"Converting world..."
+                    );
+                }
             } else {
                 show_convert_request(engine, content, report, std::move(worldFiles), [=]() {
                     openWorld(name, false);
@@ -192,7 +233,7 @@ void EngineController::openWorld(const std::string& name, bool confirmConvert) {
         }
         return;
     }
-    loadWorld(engine, std::move(worldFiles));
+    load_world(engine, std::move(worldFiles));
 }
 
 inline uint64_t str2seed(const std::string& seedstr) {
@@ -216,12 +257,15 @@ void EngineController::createWorld(
 ) {
     uint64_t seed = str2seed(seedstr);
 
-    EnginePaths* paths = engine->getPaths();
-    auto folder = paths->getWorldsFolder() / fs::u8path(name);
+    EnginePaths& paths = engine.getPaths();
+    auto folder = paths.getWorldsFolder() / fs::u8path(name);
 
-    if (!menus::call(engine, [this, paths, folder]() {
-            engine->loadContent();
-            paths->setCurrentWorldFolder(folder);
+    if (engine.isHeadless()) {
+        engine.loadContent();
+        paths.setCurrentWorldFolder(folder);
+    } else if (!menus::call(engine, [this, &paths, folder]() {
+            engine.loadContent();
+            paths.setCurrentWorldFolder(folder);
         })) {
         return;
     }
@@ -230,18 +274,20 @@ void EngineController::createWorld(
         generatorID,
         folder,
         seed,
-        engine->getSettings(),
-        engine->getContent(),
-        engine->getContentPacks()
+        engine.getSettings(),
+        *engine.getContent(),
+        engine.getContentPacks()
     );
-    engine->setScreen(std::make_shared<LevelScreen>(engine, std::move(level)));
+    if (!engine.isHeadless()) {
+        level->players->create();
+    }
+    engine.onWorldOpen(std::move(level));
 }
 
 void EngineController::reopenWorld(World* world) {
-    std::string wname = world->wfile->getFolder().filename().u8string();
-    engine->setScreen(nullptr);
-    engine->setScreen(std::make_shared<MenuScreen>(engine));
-    openWorld(wname, true);
+    std::string name = world->wfile->getFolder().filename().u8string();
+    engine.onWorldClosed();
+    openWorld(name, true);
 }
 
 void EngineController::reconfigPacks(
@@ -249,7 +295,7 @@ void EngineController::reconfigPacks(
     const std::vector<std::string>& packsToAdd,
     const std::vector<std::string>& packsToRemove
 ) {
-    auto content = engine->getContent();
+    auto content = engine.getContent();
     bool hasIndices = false;
 
     std::stringstream ss;
@@ -266,13 +312,12 @@ void EngineController::reconfigPacks(
         }
     }
 
-    runnable removeFunc = [=]() {
+    runnable removeFunc = [this, controller, packsToAdd, packsToRemove]() {
         if (controller == nullptr) {
             try {
-                auto manager = engine->createPacksManager(fs::path(""));
+                auto manager = engine.createPacksManager(fs::path(""));
                 manager.scan();
-                std::vector<std::string> names =
-                    PacksManager::getNames(engine->getContentPacks());
+                auto names = PacksManager::getNames(engine.getContentPacks());
                 for (const auto& id : packsToAdd) {
                     names.push_back(id);
                 }
@@ -280,8 +325,8 @@ void EngineController::reconfigPacks(
                     manager.exclude(id);
                     names.erase(std::find(names.begin(), names.end(), id));
                 }
-                names = manager.assembly(names);
-                engine->getContentPacks() = manager.getAll(names);
+                names = manager.assemble(names);
+                engine.getContentPacks() = manager.getAll(names);
             } catch (const contentpack_error& err) {
                 throw std::runtime_error(
                     std::string(err.what()) + " [" + err.getPackId() + "]"
@@ -289,9 +334,9 @@ void EngineController::reconfigPacks(
             }
         } else {
             auto world = controller->getLevel()->getWorld();
-            auto wfile = world->wfile.get();
+            auto& wfile = *world->wfile;
             controller->saveWorld();
-            auto manager = engine->createPacksManager(wfile->getFolder());
+            auto manager = engine.createPacksManager(wfile.getFolder());
             manager.scan();
 
             auto names = PacksManager::getNames(world->getPacks());
@@ -300,17 +345,23 @@ void EngineController::reconfigPacks(
             }
             for (const auto& id : packsToRemove) {
                 manager.exclude(id);
-                names.erase(std::find(names.begin(), names.end(), id));
+                const auto& found = std::find(names.begin(), names.end(), id);
+                if (found != names.end()) {
+                    names.erase(found);
+                } else {
+                    logger.warning()
+                        << "attempt to remove non-installed pack: " << id;
+                }
             }
-            wfile->removeIndices(packsToRemove);
-            wfile->writePacks(manager.getAll(names));
+            wfile.removeIndices(packsToRemove);
+            wfile.writePacks(manager.getAll(names));
             reopenWorld(world);
         }
     };
 
-    if (hasIndices) {
+    if (hasIndices && !engine.isHeadless()) {
         guiutil::confirm(
-            engine->getGUI(),
+            engine,
             langs::get(L"remove-confirm", L"pack") + L" (" +
                 util::str2wstr_utf8(ss.str()) + L")",
             [=]() { removeFunc(); }
diff --git a/src/logic/EngineController.hpp b/src/logic/EngineController.hpp
index 96b8f0995..948a8fce0 100644
--- a/src/logic/EngineController.hpp
+++ b/src/logic/EngineController.hpp
@@ -2,15 +2,19 @@
 
 #include <string>
 #include <vector>
+#include <memory>
 
 class Engine;
 class World;
+class ContentReport;
 class LevelController;
 
 class EngineController {
-    Engine* engine;
+    Engine& engine;
+
+    void onMissingContent(const std::shared_ptr<ContentReport>& report);
 public:
-    EngineController(Engine* engine);
+    EngineController(Engine& engine);
 
     /// @brief Load world, convert if required and set to LevelScreen.
     /// @param name world name
diff --git a/src/logic/LevelController.cpp b/src/logic/LevelController.cpp
index 5d2ddd9b5..15ed2eb8d 100644
--- a/src/logic/LevelController.cpp
+++ b/src/logic/LevelController.cpp
@@ -3,59 +3,104 @@
 #include <algorithm>
 
 #include "debug/Logger.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "files/WorldFiles.hpp"
+#include "maths/voxmaths.hpp"
 #include "objects/Entities.hpp"
+#include "objects/Players.hpp"
+#include "objects/Player.hpp"
 #include "physics/Hitbox.hpp"
+#include "voxels/Chunks.hpp"
+#include "scripting/scripting.hpp"
+#include "lighting/Lighting.hpp"
 #include "settings.hpp"
 #include "world/Level.hpp"
 #include "world/World.hpp"
-#include "maths/voxmaths.hpp"
-#include "scripting/scripting.hpp"
 
 static debug::Logger logger("level-control");
 
-LevelController::LevelController(Engine* engine, std::unique_ptr<Level> levelPtr)
+LevelController::LevelController(
+    Engine* engine, std::unique_ptr<Level> levelPtr, Player* clientPlayer
+)
     : settings(engine->getSettings()),
       level(std::move(levelPtr)),
-      blocks(std::make_unique<BlocksController>(
-          *level, settings.chunks.padding.get()
-      )),
-      chunks(std::make_unique<ChunksController>(
-          *level, settings.chunks.padding.get()
-      )),
-      player(std::make_unique<PlayerController>(
-        settings, level.get(), blocks.get()
-      )) {
+      chunks(std::make_unique<ChunksController>(*level)),
+      playerTickClock(20, 3) {
+    if (clientPlayer) {
+        chunks->lighting = std::make_unique<Lighting>(
+            level->content, *clientPlayer->chunks
+        );
+    }
+    blocks = std::make_unique<BlocksController>(
+        *level, chunks ? chunks->lighting.get() : nullptr
+    );
     scripting::on_world_load(this);
-}
 
-void LevelController::update(float delta, bool input, bool pause) {
-    glm::vec3 position = player->getPlayer()->getPosition();
-    level->loadMatrix(
-        position.x,
-        position.z,
-        settings.chunks.loadDistance.get() + settings.chunks.padding.get() * 2
-    );
-    chunks->update(
-        settings.chunks.loadSpeed.get(), settings.chunks.loadDistance.get(),
-        floordiv(position.x, CHUNK_W), floordiv(position.z, CHUNK_D)
-    );
+    // TODO: do something to players added later
+    int confirmed;
+    do {
+        confirmed = 0;
+        for (const auto& [_, player] : *level->players) {
+            glm::vec3 position = player->getPosition();
+            player->chunks->configure(
+                std::floor(position.x), std::floor(position.z), 1
+            );
+            chunks->update(16, 1, 0, *player);
+            if (player->chunks->get(
+                    std::floor(position.x), 0, std::floor(position.z)
+                )) {
+                confirmed++;
+            }
+        }
+    } while (confirmed < level->players->size());
+}
 
+void LevelController::update(float delta, bool pause) {
+    for (const auto& [_, player] : *level->players) {
+        glm::vec3 position = player->getPosition();
+        player->chunks->configure(
+            position.x,
+            position.z,
+            settings.chunks.loadDistance.get() + settings.chunks.padding.get()
+        );
+        chunks->update(
+            settings.chunks.loadSpeed.get(),
+            settings.chunks.loadDistance.get(),
+            settings.chunks.padding.get(),
+            *player
+        );
+    }
     if (!pause) {
         // update all objects that needed
-        blocks->update(delta);
-        player->update(delta, input, pause);
+        blocks->update(delta, settings.chunks.padding.get());
         level->entities->updatePhysics(delta);
         level->entities->update(delta);
+        for (const auto& [_, player] : *level->players) {
+            if (playerTickClock.update(delta)) {
+                if (player->getId() % playerTickClock.getParts() ==
+                    playerTickClock.getPart()) {
+                    
+                    const auto& position = player->getPosition();
+                    if (player->chunks->get(
+                        std::floor(position.x),
+                        std::floor(position.y),
+                        std::floor(position.z)
+                    )){
+                        scripting::on_player_tick(
+                            player.get(), playerTickClock.getTickRate()
+                        );
+                    }
+                }
+            }
+        }
     }
     level->entities->clean();
-    player->postUpdate(delta, input, pause);
 }
 
 void LevelController::saveWorld() {
-    level->getWorld()->wfile->createDirectories();
-    logger.info() << "writing world";
+    auto world = level->getWorld();
+    logger.info() << "writing world '" << world->getName() << "'";
+    world->wfile->createDirectories();
     scripting::on_world_save();
     level->onSave();
     level->getWorld()->write(level.get());
@@ -69,10 +114,6 @@ Level* LevelController::getLevel() {
     return level.get();
 }
 
-Player* LevelController::getPlayer() {
-    return player->getPlayer();
-}
-
 BlocksController* LevelController::getBlocksController() {
     return blocks.get();
 }
@@ -80,7 +121,3 @@ BlocksController* LevelController::getBlocksController() {
 ChunksController* LevelController::getChunksController() {
     return chunks.get();
 }
-
-PlayerController* LevelController::getPlayerController() {
-    return player.get();
-}
diff --git a/src/logic/LevelController.hpp b/src/logic/LevelController.hpp
index 94e0ac2c5..7ae0fc5b6 100644
--- a/src/logic/LevelController.hpp
+++ b/src/logic/LevelController.hpp
@@ -4,7 +4,7 @@
 
 #include "BlocksController.hpp"
 #include "ChunksController.hpp"
-#include "PlayerController.hpp"
+#include "util/Clock.hpp"
 
 class Engine;
 class Level;
@@ -18,23 +18,21 @@ class LevelController {
     // Sub-controllers
     std::unique_ptr<BlocksController> blocks;
     std::unique_ptr<ChunksController> chunks;
-    std::unique_ptr<PlayerController> player;
+
+    util::Clock playerTickClock;
 public:
-    LevelController(Engine* engine, std::unique_ptr<Level> level);
+    LevelController(Engine* engine, std::unique_ptr<Level> level, Player* clientPlayer);
 
     /// @param delta time elapsed since the last update
-    /// @param input is user input allowed to be handled
     /// @param pause is world and player simulation paused
-    void update(float delta, bool input, bool pause);
+    void update(float delta, bool pause);
 
     void saveWorld();
 
     void onWorldQuit();
 
     Level* getLevel();
-    Player* getPlayer();
 
     BlocksController* getBlocksController();
     ChunksController* getChunksController();
-    PlayerController* getPlayerController();
 };
diff --git a/src/logic/PlayerController.cpp b/src/logic/PlayerController.cpp
index 96fed03ab..d81e2c5b6 100644
--- a/src/logic/PlayerController.cpp
+++ b/src/logic/PlayerController.cpp
@@ -41,43 +41,45 @@ const float C_ZOOM = 0.1f;
 const float CROUCH_SHIFT_Y = -0.2f;
 
 CameraControl::CameraControl(
-    Player* player, const CameraSettings& settings
+    Player& player, const CameraSettings& settings
 )
     : player(player),
-      camera(player->fpCamera),
+      camera(player.fpCamera),
       settings(settings),
       offset(0.0f, 0.7f, 0.0f) {
 }
 
 void CameraControl::refresh() {
-    camera->position = player->getPosition() + offset;
+    camera->position = player.getPosition() + offset;
 }
 
 void CameraControl::updateMouse(PlayerInput& input) {
-    glm::vec3& cam = player->cam;
+    glm::vec3& rotation = player.rotation;
 
     float sensitivity =
         (input.zoom ? settings.sensitivity.get() / 4.f
                     : settings.sensitivity.get());
 
     auto d = glm::degrees(Events::delta / (float)Window::height * sensitivity);
-    cam.x -= d.x;
-    cam.y -= d.y;
+    rotation.x -= d.x;
+    rotation.y -= d.y;
 
-    if (cam.y < -89.9f) {
-        cam.y = -89.9f;
-    } else if (cam.y > 89.9f) {
-        cam.y = 89.9f;
+    if (rotation.y < -89.9f) {
+        rotation.y = -89.9f;
+    } else if (rotation.y > 89.9f) {
+        rotation.y = 89.9f;
     }
-    if (cam.x > 180.f) {
-        cam.x -= 360.f;
-    } else if (cam.x < -180.f) {
-        cam.x += 360.f;
+    if (rotation.x > 180.f) {
+        rotation.x -= 360.f;
+    } else if (rotation.x < -180.f) {
+        rotation.x += 360.f;
     }
 
     camera->rotation = glm::mat4(1.0f);
     camera->rotate(
-        glm::radians(cam.y), glm::radians(cam.x), glm::radians(cam.z)
+        glm::radians(rotation.y),
+        glm::radians(rotation.x),
+        glm::radians(rotation.z)
     );
 }
 
@@ -131,28 +133,31 @@ void CameraControl::updateFovEffects(
 // more extensible but uglier
 void CameraControl::switchCamera() {
     const std::vector<std::shared_ptr<Camera>> playerCameras {
-        camera, player->tpCamera, player->spCamera};
+        camera, player.tpCamera, player.spCamera
+    };
 
     auto index = std::distance(
         playerCameras.begin(),
         std::find_if(
             playerCameras.begin(),
             playerCameras.end(),
-            [=](auto ptr) { return ptr.get() == player->currentCamera.get(); }
+            [this](auto& ptr) { return ptr.get() == player.currentCamera.get(); }
         )
     );
     if (static_cast<size_t>(index) != playerCameras.size()) {
         index = (index + 1) % playerCameras.size();
-        player->currentCamera = playerCameras.at(index);
+        player.currentCamera = playerCameras.at(index);
     } else {
-        player->currentCamera = camera;
+        player.currentCamera = camera;
     }
 }
 
-void CameraControl::update(PlayerInput input, float delta, Chunks* chunks) {
+void CameraControl::update(
+    PlayerInput input, float delta, const Chunks& chunks
+) {
     offset = glm::vec3(0.0f, 0.0f, 0.0f);
 
-    if (auto hitbox = player->getHitbox()) {
+    if (auto hitbox = player.getHitbox()) {
         offset.y += hitbox->halfsize.y * (0.7f / 0.9f);
         if (settings.shaking.get() && !input.cheat) {
             offset += updateCameraShaking(*hitbox, delta);
@@ -165,39 +170,44 @@ void CameraControl::update(PlayerInput input, float delta, Chunks* chunks) {
         switchCamera();
     }
 
-    auto spCamera = player->spCamera;
-    auto tpCamera = player->tpCamera;
+    auto& spCamera = player.spCamera;
+    auto& tpCamera = player.tpCamera;
 
     refresh();
 
-    if (player->currentCamera == spCamera) {
+    camera->updateVectors();
+    if (player.currentCamera == spCamera) {
         spCamera->position =
-            chunks->rayCastToObstacle(camera->position, camera->front, 3.0f) -
+            chunks.rayCastToObstacle(camera->position, camera->front, 3.0f) -
             0.4f * camera->front;
         spCamera->dir = -camera->dir;
         spCamera->front = -camera->front;
-    } else if (player->currentCamera == tpCamera) {
+        spCamera->right = -camera->right;
+    } else if (player.currentCamera == tpCamera) {
         tpCamera->position =
-            chunks->rayCastToObstacle(camera->position, -camera->front, 3.0f) +
+            chunks.rayCastToObstacle(camera->position, -camera->front, 3.0f) +
             0.4f * camera->front;
         tpCamera->dir = camera->dir;
         tpCamera->front = camera->front;
+        tpCamera->right = camera->right;
     }
-    if (player->currentCamera == spCamera ||
-        player->currentCamera == tpCamera || player->currentCamera == camera) {
-        player->currentCamera->setFov(glm::radians(settings.fov.get()));
+    if (player.currentCamera == spCamera ||
+        player.currentCamera == tpCamera || player.currentCamera == camera) {
+        player.currentCamera->setFov(glm::radians(settings.fov.get()));
     }
 }
 
 PlayerController::PlayerController(
-    const EngineSettings& settings, Level* level,
-    BlocksController* blocksController
+    const EngineSettings& settings,
+    Level& level,
+    Player& player,
+    BlocksController& blocksController
 )
-    : settings(settings), level(level),
-      player(level->players->get(0)),
+    : settings(settings),
+      level(level),
+      player(player),
       camControl(player, settings.camera),
-      blocksController(blocksController),
-      playerTickClock(60, 1) {
+      blocksController(blocksController) {
 }
 
 void PlayerController::onFootstep(const Hitbox& hitbox) {
@@ -209,14 +219,14 @@ void PlayerController::onFootstep(const Hitbox& hitbox) {
             int x = std::floor(pos.x + half.x * offsetX);
             int y = std::floor(pos.y - half.y * 1.1f);
             int z = std::floor(pos.z + half.z * offsetZ);
-            auto vox = level->chunks->get(x, y, z);
+            auto vox = player.chunks->get(x, y, z);
             if (vox) {
-                auto& def = level->content->getIndices()->blocks.require(vox->id);
+                auto& def = level.content.getIndices()->blocks.require(vox->id);
                 if (!def.obstacle) {
                     continue;
                 }
-                blocksController->onBlockInteraction(
-                    player,
+                blocksController.onBlockInteraction(
+                    &player,
                     glm::ivec3(x, y, z),
                     def,
                     BlockInteraction::step
@@ -228,7 +238,7 @@ void PlayerController::onFootstep(const Hitbox& hitbox) {
 }
 
 void PlayerController::updateFootsteps(float delta) {
-    auto hitbox = player->getHitbox();
+    auto hitbox = player.getHitbox();
     if (hitbox && hitbox->grounded) {
         const glm::vec3& vel = hitbox->velocity;
         float f = glm::length(glm::vec2(vel.x, vel.z));
@@ -242,23 +252,14 @@ void PlayerController::updateFootsteps(float delta) {
     }
 }
 
-void PlayerController::update(float delta, bool input, bool pause) {
-    if (!pause) {
-        if (input) {
-            updateKeyboard();
-            player->updateSelectedEntity();
-        } else {
-            resetKeyboard();
-        }
-        updatePlayer(delta);
-
-        if (playerTickClock.update(delta)) {
-            if (player->getId() % playerTickClock.getParts() ==
-                playerTickClock.getPart()) {
-                scripting::on_player_tick(player, playerTickClock.getTickRate());
-            }
-        }
+void PlayerController::update(float delta, bool input) {
+    if (input) {
+        updateKeyboard();
+        player.updateSelectedEntity();
+    } else {
+        resetKeyboard();
     }
+    updatePlayer(delta);
 }
 
 void PlayerController::postUpdate(float delta, bool input, bool pause) {
@@ -269,12 +270,12 @@ void PlayerController::postUpdate(float delta, bool input, bool pause) {
     if (!pause && input) {
         camControl.updateMouse(this->input);
     }
-    player->postUpdate();
-    camControl.update(this->input, pause ? 0.0f : delta, level->chunks.get());
+    player.postUpdate();
+    camControl.update(this->input, pause ? 0.0f : delta, *player.chunks);
     if (input) {
         updateInteraction(delta);
     } else {
-        player->selection = {};
+        player.selection = {};
     }
 }
 
@@ -289,8 +290,6 @@ void PlayerController::updateKeyboard() {
     input.jump = Events::active(BIND_MOVE_JUMP);
     input.zoom = Events::active(BIND_CAM_ZOOM);
     input.cameraMode = Events::jactive(BIND_CAM_MODE);
-    input.noclip = Events::jactive(BIND_PLAYER_NOCLIP);
-    input.flight = Events::jactive(BIND_PLAYER_FLIGHT);
 }
 
 void PlayerController::resetKeyboard() {
@@ -306,8 +305,8 @@ void PlayerController::resetKeyboard() {
 }
 
 void PlayerController::updatePlayer(float delta) {
-    player->updateEntity();
-    player->updateInput(input, delta);
+    player.updateEntity();
+    player.updateInput(input, delta);
 }
 
 static int determine_rotation(
@@ -342,34 +341,16 @@ static int determine_rotation(
     return 0;
 }
 
-static void pick_block(
-    ContentIndices* indices, Chunks* chunks, Player* player, int x, int y, int z
-) {
-    auto& block = indices->blocks.require(chunks->get(x, y, z)->id);
-    itemid_t id = block.rt.pickingItem;
-    auto inventory = player->getInventory();
-    size_t slotid = inventory->findSlotByItem(id, 0, 10);
-    if (slotid == Inventory::npos) {
-        slotid = player->getChosenSlot();
-    } else {
-        player->setChosenSlot(slotid);
-    }
-    ItemStack& stack = inventory->getSlot(slotid);
-    if (stack.getItemId() != id) {
-        stack.set(ItemStack(id, 1));
-    }
-}
-
 voxel* PlayerController::updateSelection(float maxDistance) {
-    auto indices = level->content->getIndices();
-    auto chunks = level->chunks.get();
-    auto camera = player->fpCamera.get();
-    auto& selection = player->selection;
+    auto indices = level.content.getIndices();
+    auto& chunks = *player.chunks;
+    auto camera = player.fpCamera.get();
+    auto& selection = player.selection;
 
     glm::vec3 end;
     glm::ivec3 iend;
     glm::ivec3 norm;
-    voxel* vox = chunks->rayCast(
+    voxel* vox = chunks.rayCast(
         camera->position, camera->front, maxDistance, end, norm, iend
     );
     if (vox) {
@@ -378,8 +359,8 @@ voxel* PlayerController::updateSelection(float maxDistance) {
     auto prevEntity = selection.entity;
     selection.entity = ENTITY_NONE;
     selection.actualPosition = iend;
-    if (auto result = level->entities->rayCast(
-            camera->position, camera->front, maxDistance, player->getEntity()
+    if (auto result = level.entities->rayCast(
+            camera->position, camera->front, maxDistance, player.getEntity()
         )) {
         selection.entity = result->entity;
         selection.hitPosition =
@@ -390,13 +371,13 @@ voxel* PlayerController::updateSelection(float maxDistance) {
     }
     if (selection.entity != prevEntity) {
         if (prevEntity != ENTITY_NONE) {
-            if (auto pentity = level->entities->get(prevEntity)) {
-                scripting::on_aim_off(*pentity, player);
+            if (auto pentity = level.entities->get(prevEntity)) {
+                scripting::on_aim_off(*pentity, &player);
             }
         }
         if (selection.entity != ENTITY_NONE) {
-            if (auto pentity = level->entities->get(selection.entity)) {
-                scripting::on_aim_on(*pentity, player);
+            if (auto pentity = level.entities->get(selection.entity)) {
+                scripting::on_aim_on(*pentity, &player);
             }
         }
     }
@@ -407,12 +388,12 @@ voxel* PlayerController::updateSelection(float maxDistance) {
     blockstate selectedState = vox->state;
     selection.vox = *vox;
     if (selectedState.segment) {
-        selection.position = chunks->seekOrigin(
+        selection.position = chunks.seekOrigin(
             iend, indices->blocks.require(selection.vox.id), selectedState
         );
-        auto origin = chunks->get(selection.position);
+        auto origin = chunks.get(selection.position);
         if (origin && origin->id != vox->id) {
-            chunks->set(iend.x, iend.y, iend.z, 0, {});
+            chunks.set(iend.x, iend.y, iend.z, 0, {});
             return updateSelection(maxDistance);
         }
     } else {
@@ -424,16 +405,16 @@ voxel* PlayerController::updateSelection(float maxDistance) {
 }
 
 void PlayerController::processRightClick(const Block& def, const Block& target) {
-    const auto& selection = player->selection;
-    auto chunks = level->chunks.get();
-    auto camera = player->fpCamera.get();
+    const auto& selection = player.selection;
+    auto& chunks = *player.chunks;
+    auto camera = player.fpCamera.get();
 
     blockstate state {};
     state.rotation = determine_rotation(&def, selection.normal, camera->dir);
 
     if (!input.shift && target.rt.funcsset.oninteract) {
         if (scripting::on_block_interact(
-            player, target, selection.actualPosition
+            &player, target, selection.actualPosition
         )) {
             return;
         }
@@ -449,33 +430,33 @@ void PlayerController::processRightClick(const Block& def, const Block& target)
     if (def.obstacle) {
         const auto& hitboxes = def.rt.hitboxes[state.rotation];
         for (const AABB& blockAABB : hitboxes) {
-            if (level->entities->hasBlockingInside(blockAABB.translated(coord))) {
+            if (level.entities->hasBlockingInside(blockAABB.translated(coord))) {
                 return;
             }
         }
     }
-    auto vox = chunks->get(coord);
+    auto vox = chunks.get(coord);
     if (vox == nullptr) {
         return;
     }
-    if (!chunks->checkReplaceability(def, state, coord)) {
+    if (!chunks.checkReplaceability(def, state, coord)) {
         return;
     }
     if (def.grounded) {
         const auto& vec = get_ground_direction(def, state.rotation);
-        if (!chunks->isSolidBlock(
+        if (!chunks.isSolidBlock(
                 coord.x + vec.x, coord.y + vec.y, coord.z + vec.z
             )) {
             return;
         }
     }
     if (chosenBlock != vox->id && chosenBlock) {
-        if (!player->isInfiniteItems()) {
-            auto& slot = player->getInventory()->getSlot(player->getChosenSlot());
+        if (!player.isInfiniteItems()) {
+            auto& slot = player.getInventory()->getSlot(player.getChosenSlot());
             slot.setCount(slot.getCount()-1);
         }
-        blocksController->placeBlock(
-            player, def, state, coord.x, coord.y, coord.z
+        blocksController.placeBlock(
+            &player, def, state, coord.x, coord.y, coord.z
         );
     }
 }
@@ -483,23 +464,22 @@ void PlayerController::processRightClick(const Block& def, const Block& target)
 void PlayerController::updateEntityInteraction(
     entityid_t eid, bool lclick, bool rclick
 ) {
-    auto entityOpt = level->entities->get(eid);
+    auto entityOpt = level.entities->get(eid);
     if (!entityOpt.has_value()) {
         return;
     }
     auto entity = *entityOpt;
     if (lclick) {
-        scripting::on_attacked(entity, player, player->getEntity());
+        scripting::on_attacked(entity, &player, player.getEntity());
     }
     if (rclick) {
-        scripting::on_entity_used(entity, player);
+        scripting::on_entity_used(entity, &player);
     }
 }
 
 void PlayerController::updateInteraction(float delta) {
-    auto indices = level->content->getIndices();
-    auto chunks = level->chunks.get();
-    const auto& selection = player->selection;
+    auto indices = level.content.getIndices();
+    const auto& selection = player.selection;
     
     if (interactionTimer > 0.0f) {
         interactionTimer -= delta;
@@ -516,14 +496,14 @@ void PlayerController::updateInteraction(float delta) {
         interactionTimer = INTERACTION_RELOAD;
     }
 
-    auto inventory = player->getInventory();
-    const ItemStack& stack = inventory->getSlot(player->getChosenSlot());
+    auto inventory = player.getInventory();
+    const ItemStack& stack = inventory->getSlot(player.getChosenSlot());
     auto& item = indices->items.require(stack.getItemId());
 
     auto vox = updateSelection(maxDistance);
     if (vox == nullptr) {
         if (rclick && item.rt.funcsset.on_use) {
-            scripting::on_item_use(player, item);
+            scripting::on_item_use(&player, item);
         }
         if (selection.entity) {
             updateEntityInteraction(selection.entity, lattack, rclick);
@@ -534,16 +514,17 @@ void PlayerController::updateInteraction(float delta) {
     auto iend = selection.position;
     if (lclick && !input.shift && item.rt.funcsset.on_block_break_by) {
         if (scripting::on_item_break_block(
-            player, item, iend.x, iend.y, iend.z
+            &player, item, iend.x, iend.y, iend.z
         )) {
             return;
         }
     }
     auto& target = indices->blocks.require(vox->id);
     if (lclick) {
-        if (player->isInstantDestruction() && target.breakable) {
-            blocksController->breakBlock(
-                player, target, iend.x, iend.y, iend.z
+        scripting::on_block_breaking(&player, target, iend);
+        if (player.isInstantDestruction() && target.breakable) {
+            blocksController.breakBlock(
+                &player, target, iend.x, iend.y, iend.z
             );
         }
     }
@@ -551,10 +532,10 @@ void PlayerController::updateInteraction(float delta) {
         bool preventDefault = false;
         if (item.rt.funcsset.on_use_on_block) {
             preventDefault = scripting::on_item_use_on_block(
-                player, item, iend, selection.normal
+                &player, item, iend, selection.normal
             );
         } else if (item.rt.funcsset.on_use) {
-            preventDefault = scripting::on_item_use(player, item);
+            preventDefault = scripting::on_item_use(&player, item);
         }
         if (preventDefault) {
             return;
@@ -564,12 +545,8 @@ void PlayerController::updateInteraction(float delta) {
     if (def && rclick) {
         processRightClick(*def, target);
     }
-    if (Events::jactive(BIND_PLAYER_PICK)) {
-        auto coord = selection.actualPosition;
-        pick_block(indices, chunks, player, coord.x, coord.y, coord.z);
-    }
 }
 
 Player* PlayerController::getPlayer() {
-    return player;
+    return &player;
 }
diff --git a/src/logic/PlayerController.hpp b/src/logic/PlayerController.hpp
index 8d82a3f99..88e3a5f45 100644
--- a/src/logic/PlayerController.hpp
+++ b/src/logic/PlayerController.hpp
@@ -18,7 +18,7 @@ struct CameraSettings;
 struct EngineSettings;
 
 class CameraControl {
-    Player* player;
+    Player& player;
     std::shared_ptr<Camera> camera;
     const CameraSettings& settings;
     glm::vec3 offset;
@@ -39,24 +39,21 @@ class CameraControl {
     /// @brief Switch active player camera
     void switchCamera();
 public:
-    CameraControl(
-        Player* player, const CameraSettings& settings
-    );
+    CameraControl(Player& player, const CameraSettings& settings);
     void updateMouse(PlayerInput& input);
-    void update(PlayerInput input, float delta, Chunks* chunks);
+    void update(PlayerInput input, float delta, const Chunks& chunks);
     void refresh();
 };
 
 class PlayerController {
     const EngineSettings& settings;
-    Level* level;
-    Player* player;
+    Level& level;
+    Player& player;
     PlayerInput input {};
     CameraControl camControl;
-    BlocksController* blocksController;
-    util::Clock playerTickClock;
-
+    BlocksController& blocksController;
     float interactionTimer = 0.0f;
+    
     void updateKeyboard();
     void resetKeyboard();
     void updatePlayer(float delta);
@@ -71,9 +68,21 @@ class PlayerController {
     voxel* updateSelection(float maxDistance);
 public:
     PlayerController(
-        const EngineSettings& settings, Level* level, BlocksController* blocksController
+        const EngineSettings& settings,
+        Level& level,
+        Player& player,
+        BlocksController& blocksController
     );
-    void update(float delta, bool input, bool pause);
+
+    /// @brief Called after blocks update if not paused
+    /// @param delta delta time
+    /// @param input process user input
+    void update(float delta, bool input);
+
+    /// @brief Called after whole level update
+    /// @param delta delta time
+    /// @param input process user input
+    /// @param pause is game paused
     void postUpdate(float delta, bool input, bool pause);
     Player* getPlayer();
 };
diff --git a/src/logic/scripting/lua/libs/api_lua.hpp b/src/logic/scripting/lua/libs/api_lua.hpp
index a3b2d152c..1b7d42d6b 100644
--- a/src/logic/scripting/lua/libs/api_lua.hpp
+++ b/src/logic/scripting/lua/libs/api_lua.hpp
@@ -19,6 +19,7 @@ extern const luaL_Reg base64lib[];
 extern const luaL_Reg bjsonlib[];
 extern const luaL_Reg blocklib[];
 extern const luaL_Reg blockwrapslib[]; // gfx.blockwraps
+extern const luaL_Reg byteutillib[];
 extern const luaL_Reg cameralib[];
 extern const luaL_Reg consolelib[];
 extern const luaL_Reg corelib[];
@@ -37,6 +38,7 @@ extern const luaL_Reg packlib[];
 extern const luaL_Reg particleslib[]; // gfx.particles
 extern const luaL_Reg playerlib[];
 extern const luaL_Reg quatlib[];
+extern const luaL_Reg applib[];
 extern const luaL_Reg text3dlib[]; // gfx.text3d
 extern const luaL_Reg timelib[];
 extern const luaL_Reg tomllib[];
diff --git a/src/logic/scripting/lua/libs/libapp.cpp b/src/logic/scripting/lua/libs/libapp.cpp
new file mode 100644
index 000000000..bd61bc7a8
--- /dev/null
+++ b/src/logic/scripting/lua/libs/libapp.cpp
@@ -0,0 +1,6 @@
+#include "api_lua.hpp"
+
+const luaL_Reg applib[] = {
+    // see libcore.cpp an stdlib.lua
+    {NULL, NULL}
+};
diff --git a/src/logic/scripting/lua/libs/libaudio.cpp b/src/logic/scripting/lua/libs/libaudio.cpp
index ee311585e..aa7b0f8f7 100644
--- a/src/logic/scripting/lua/libs/libaudio.cpp
+++ b/src/logic/scripting/lua/libs/libaudio.cpp
@@ -1,5 +1,5 @@
 #include "audio/audio.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "api_lua.hpp"
 
 inline const char* DEFAULT_CHANNEL = "regular";
diff --git a/src/logic/scripting/lua/libs/libblock.cpp b/src/logic/scripting/lua/libs/libblock.cpp
index 2f24e0feb..f37b4ba35 100644
--- a/src/logic/scripting/lua/libs/libblock.cpp
+++ b/src/logic/scripting/lua/libs/libblock.cpp
@@ -7,6 +7,8 @@
 #include "voxels/Chunk.hpp"
 #include "voxels/Chunks.hpp"
 #include "voxels/voxel.hpp"
+#include "voxels/GlobalChunks.hpp"
+#include "voxels/blocks_agent.hpp"
 #include "world/Level.hpp"
 #include "maths/voxmaths.hpp"
 #include "data/StructLayout.hpp"
@@ -14,13 +16,13 @@
 
 using namespace scripting;
 
-static const Block* require_block(lua::State* L) {
+static inline const Block* require_block(lua::State* L) {
     auto indices = content->getIndices();
     auto id = lua::tointeger(L, 1);
     return indices->blocks.get(id);
 }
 
-static int l_get_def(lua::State* L) {
+static inline int l_get_def(lua::State* L) {
     if (auto def = require_block(L)) {
         return lua::pushstring(L, def->name);
     }
@@ -38,8 +40,9 @@ static int l_is_solid_at(lua::State* L) {
     auto x = lua::tointeger(L, 1);
     auto y = lua::tointeger(L, 2);
     auto z = lua::tointeger(L, 3);
-
-    return lua::pushboolean(L, level->chunks->isSolidBlock(x, y, z));
+    return lua::pushboolean(
+        L, blocks_agent::is_solid_at(*level->chunks, x, y, z)
+    );
 }
 
 static int l_count(lua::State* L) {
@@ -69,7 +72,7 @@ static int l_is_segment(lua::State* L) {
     auto x = lua::tointeger(L, 1);
     auto y = lua::tointeger(L, 2);
     auto z = lua::tointeger(L, 3);
-    const auto& vox = level->chunks->require(x, y, z);
+    const auto& vox = blocks_agent::require(*level->chunks, x, y, z);
     return lua::pushboolean(L, vox.state.segment);
 }
 
@@ -77,10 +80,10 @@ static int l_seek_origin(lua::State* L) {
     auto x = lua::tointeger(L, 1);
     auto y = lua::tointeger(L, 2);
     auto z = lua::tointeger(L, 3);
-    const auto& vox = level->chunks->require(x, y, z);
+    const auto& vox = blocks_agent::require(*level->chunks, x, y, z);
     auto& def = indices->blocks.require(vox.id);
     return lua::pushivec_stack(
-        L, level->chunks->seekOrigin({x, y, z}, def, vox.state)
+        L, blocks_agent::seek_origin(*level->chunks, {x, y, z}, def, vox.state)
     );
 }
 
@@ -94,11 +97,21 @@ static int l_set(lua::State* L) {
     if (static_cast<size_t>(id) >= indices->blocks.count()) {
         return 0;
     }
-    if (!level->chunks->get(x, y, z)) {
+    int cx = floordiv<CHUNK_W>(x);
+    int cz = floordiv<CHUNK_D>(z);
+    if (!blocks_agent::get_chunk(*level->chunks, cx, cz)) {
         return 0;
     }
-    level->chunks->set(x, y, z, id, int2blockstate(state));
-    level->lighting->onBlockSet(x, y, z, id);
+    blocks_agent::set(*level->chunks, x, y, z, id, int2blockstate(state));
+
+    auto chunksController = controller->getChunksController();
+    if (chunksController == nullptr) {
+        return 1;
+    }
+    if (chunksController->lighting) {
+        Lighting& lighting = *chunksController->lighting;
+        lighting.onBlockSet(x, y, z, id);
+    }
     if (!noupdate) {
         blocks->updateSides(x, y, z);
     }
@@ -109,67 +122,59 @@ static int l_get(lua::State* L) {
     auto x = lua::tointeger(L, 1);
     auto y = lua::tointeger(L, 2);
     auto z = lua::tointeger(L, 3);
-    auto vox = level->chunks->get(x, y, z);
+    auto vox = blocks_agent::get(*level->chunks, x, y, z);
     int id = vox == nullptr ? -1 : vox->id;
     return lua::pushinteger(L, id);
 }
 
-static int l_get_x(lua::State* L) {
+template<int n>
+static int get_axis(lua::State* L, const Block& def, int rotation) {
+    const CoordSystem& rot = def.rotations.variants[rotation];
+    return lua::pushivec_stack(L, rot.axes[n]);
+}
+
+template<int n>
+static int get_axis(lua::State* L) {
     auto x = lua::tointeger(L, 1);
     auto y = lua::tointeger(L, 2);
+    if (lua::gettop(L) == 2) {
+        const auto& def = level->content.getIndices()->blocks.require(x);
+        return get_axis<n>(L, def, y);
+    }
     auto z = lua::tointeger(L, 3);
-    auto vox = level->chunks->get(x, y, z);
+
+    glm::ivec3 defAxis;
+    defAxis[n] = 1;
+
+    auto vox = blocks_agent::get(*level->chunks, x, y, z);
     if (vox == nullptr) {
-        return lua::pushivec_stack(L, glm::ivec3(1, 0, 0));
+        return lua::pushivec_stack(L, defAxis);
     }
-    const auto& def = level->content->getIndices()->blocks.require(vox->id);
+    const auto& def = level->content.getIndices()->blocks.require(vox->id);
     if (!def.rotatable) {
-        return lua::pushivec_stack(L, glm::ivec3(1, 0, 0));
+        return lua::pushivec_stack(L, defAxis);
     } else {
-        const CoordSystem& rot = def.rotations.variants[vox->state.rotation];
-        return lua::pushivec_stack(L, rot.axisX);
+        return get_axis<n>(L, def, vox->state.rotation);
     }
 }
 
+static int l_get_x(lua::State* L) {
+    return get_axis<0>(L);
+}
+
 static int l_get_y(lua::State* L) {
-    auto x = lua::tointeger(L, 1);
-    auto y = lua::tointeger(L, 2);
-    auto z = lua::tointeger(L, 3);
-    auto vox = level->chunks->get(x, y, z);
-    if (vox == nullptr) {
-        return lua::pushivec_stack(L, glm::ivec3(0, 1, 0));
-    }
-    const auto& def = level->content->getIndices()->blocks.require(vox->id);
-    if (!def.rotatable) {
-        return lua::pushivec_stack(L, glm::ivec3(0, 1, 0));
-    } else {
-        const CoordSystem& rot = def.rotations.variants[vox->state.rotation];
-        return lua::pushivec_stack(L, rot.axisY);
-    }
+    return get_axis<1>(L);
 }
 
 static int l_get_z(lua::State* L) {
-    auto x = lua::tointeger(L, 1);
-    auto y = lua::tointeger(L, 2);
-    auto z = lua::tointeger(L, 3);
-    auto vox = level->chunks->get(x, y, z);
-    if (vox == nullptr) {
-        return lua::pushivec_stack(L, glm::ivec3(0, 0, 1));
-    }
-    const auto& def = level->content->getIndices()->blocks.require(vox->id);
-    if (!def.rotatable) {
-        return lua::pushivec_stack(L, glm::ivec3(0, 0, 1));
-    } else {
-        const CoordSystem& rot = def.rotations.variants[vox->state.rotation];
-        return lua::pushivec_stack(L, rot.axisZ);
-    }
+    return get_axis<2>(L);
 }
 
 static int l_get_rotation(lua::State* L) {
     auto x = lua::tointeger(L, 1);
     auto y = lua::tointeger(L, 2);
     auto z = lua::tointeger(L, 3);
-    voxel* vox = level->chunks->get(x, y, z);
+    auto vox = blocks_agent::get(*level->chunks, x, y, z);
     int rotation = vox == nullptr ? 0 : vox->state.rotation;
     return lua::pushinteger(L, rotation);
 }
@@ -179,7 +184,7 @@ static int l_set_rotation(lua::State* L) {
     auto y = lua::tointeger(L, 2);
     auto z = lua::tointeger(L, 3);
     auto value = lua::tointeger(L, 4);
-    level->chunks->setRotation(x, y, z, value);
+    blocks_agent::set_rotation(*level->chunks, x, y, z, value);
     return 0;
 }
 
@@ -187,7 +192,7 @@ static int l_get_states(lua::State* L) {
     auto x = lua::tointeger(L, 1);
     auto y = lua::tointeger(L, 2);
     auto z = lua::tointeger(L, 3);
-    auto vox = level->chunks->get(x, y, z);
+    auto vox = blocks_agent::get(*level->chunks, x, y, z);
     int states = vox == nullptr ? 0 : blockstate2int(vox->state);
     return lua::pushinteger(L, states);
 }
@@ -197,13 +202,18 @@ static int l_set_states(lua::State* L) {
     auto y = lua::tointeger(L, 2);
     auto z = lua::tointeger(L, 3);
     auto states = lua::tointeger(L, 4);
-
-    auto chunk = level->chunks->getChunkByVoxel(x, y, z);
+    if (y < 0 || y >= CHUNK_H) {
+        return 0;
+    }
+    int cx = floordiv<CHUNK_W>(x);
+    int cz = floordiv<CHUNK_D>(z);
+    auto chunk = blocks_agent::get_chunk(*level->chunks, cx, cz);
     if (chunk == nullptr) {
         return 0;
     }
-    auto vox = level->chunks->get(x, y, z);
-    vox->state = int2blockstate(states);
+    int lx = x - cx * CHUNK_W;
+    int lz = z - cz * CHUNK_D;
+    chunk->voxels[vox_index(lx, y, lz)].state = int2blockstate(states);
     chunk->setModifiedAndUnsaved();
     return 0;
 }
@@ -216,14 +226,16 @@ static int l_get_user_bits(lua::State* L) {
     auto offset = lua::tointeger(L, 4) + VOXEL_USER_BITS_OFFSET;
     auto bits = lua::tointeger(L, 5);
 
-    auto vox = level->chunks->get(x, y, z);
+    auto vox = blocks_agent::get(*level->chunks, x, y, z);
     if (vox == nullptr) {
         return lua::pushinteger(L, 0);
     }
     const auto& def = content->getIndices()->blocks.require(vox->id);
     if (def.rt.extended) {
-        auto origin = level->chunks->seekOrigin({x, y, z}, def, vox->state);
-        vox = level->chunks->get(origin.x, origin.y, origin.z);
+        auto origin = blocks_agent::seek_origin(
+            *level->chunks, {x, y, z}, def, vox->state
+        );
+        vox = blocks_agent::get(*level->chunks, origin.x, origin.y, origin.z);
         if (vox == nullptr) {
             return lua::pushinteger(L, 0);
         }
@@ -234,6 +246,7 @@ static int l_get_user_bits(lua::State* L) {
 }
 
 static int l_set_user_bits(lua::State* L) {
+    auto& chunks = *level->chunks;
     auto x = lua::tointeger(L, 1);
     auto y = lua::tointeger(L, 2);
     auto z = lua::tointeger(L, 3);
@@ -243,18 +256,19 @@ static int l_set_user_bits(lua::State* L) {
     size_t mask = ((1 << bits) - 1) << offset;
     auto value = (lua::tointeger(L, 6) << offset) & mask;
 
-    auto chunk = level->chunks->getChunkByVoxel(x, y, z);
-    if (chunk == nullptr) {
-        return 0;
-    }
-    auto vox = level->chunks->get(x, y, z);
-    if (vox == nullptr) {
+    int cx = floordiv<CHUNK_W>(x);
+    int cz = floordiv<CHUNK_D>(z);
+    auto chunk = blocks_agent::get_chunk(chunks, cx, cz);
+    if (chunk == nullptr || y < 0 || y >= CHUNK_H) {
         return 0;
     }
+    int lx = x - cx * CHUNK_W;
+    int lz = z - cz * CHUNK_D;
+    auto vox = &chunk->voxels[vox_index(lx, y, lz)];
     const auto& def = content->getIndices()->blocks.require(vox->id);
     if (def.rt.extended) {
-        auto origin = level->chunks->seekOrigin({x, y, z}, def, vox->state);
-        vox = level->chunks->get(origin);
+        auto origin = blocks_agent::seek_origin(chunks, {x, y, z}, def, vox->state);
+        vox = blocks_agent::get(chunks, origin.x, origin.y, origin.z);
         if (vox == nullptr) {
             return 0;
         }
@@ -268,7 +282,9 @@ static int l_is_replaceable_at(lua::State* L) {
     auto x = lua::tointeger(L, 1);
     auto y = lua::tointeger(L, 2);
     auto z = lua::tointeger(L, 3);
-    return lua::pushboolean(L, level->chunks->isReplaceableBlock(x, y, z));
+    return lua::pushboolean(
+        L, blocks_agent::is_replaceable_at(*level->chunks, x, y, z)
+    );
 }
 
 static int l_caption(lua::State* L) {
@@ -342,10 +358,10 @@ static int l_place(lua::State* L) {
     if (static_cast<size_t>(id) >= indices->blocks.count()) {
         return 0;
     }
-    if (!level->chunks->get(x, y, z)) {
+    if (!blocks_agent::get(*level->chunks, x, y, z)) {
         return 0;
     }
-    const auto def = level->content->getIndices()->blocks.get(id);
+    const auto def = level->content.getIndices()->blocks.get(id);
     if (def == nullptr) {
         throw std::runtime_error(
             "there is no block with index " + std::to_string(id)
@@ -363,11 +379,11 @@ static int l_destruct(lua::State* L) {
     auto y = lua::tointeger(L, 2);
     auto z = lua::tointeger(L, 3);
     auto playerid = lua::gettop(L) >= 4 ? lua::tointeger(L, 4) : -1;
-    auto voxel = level->chunks->get(x, y, z);
-    if (voxel == nullptr) {
+    auto vox = blocks_agent::get(*level->chunks, x, y, z);
+    if (vox == nullptr) {
         return 0;
     }
-    auto& def = level->content->getIndices()->blocks.require(voxel->id);
+    auto& def = level->content.getIndices()->blocks.require(vox->id);
     auto player = level->players->get(playerid);
     controller->getBlocksController()->breakBlock(player, def, x, y, z);
     return 0;
@@ -397,8 +413,15 @@ static int l_raycast(lua::State* L) {
     glm::vec3 end;
     glm::ivec3 normal;
     glm::ivec3 iend;
-    if (auto voxel = level->chunks->rayCast(
-            start, dir, maxDistance, end, normal, iend, filteredBlocks
+    if (auto voxel = blocks_agent::raycast(
+            *level->chunks,
+            start,
+            dir,
+            maxDistance,
+            end,
+            normal,
+            iend,
+            filteredBlocks
         )) {
         if (lua::gettop(L) >= 4 && !lua::isnil(L, 4)) {
             lua::pushvalue(L, 4);
@@ -494,12 +517,15 @@ static int l_get_field(lua::State* L) {
     }
     auto cx = floordiv(x, CHUNK_W);
     auto cz = floordiv(z, CHUNK_D);
-    auto chunk = level->chunks->getChunk(cx, cz);
+    auto chunk = blocks_agent::get_chunk(*level->chunks, cx, cz);
+    if (chunk == nullptr || y < 0 || y >= CHUNK_H) {
+        return 0;
+    }
     auto lx = x - cx * CHUNK_W;
     auto lz = z - cz * CHUNK_W;
     size_t voxelIndex = vox_index(lx, y, lz);
 
-    const auto& vox = level->chunks->require(x, y, z);
+    const auto& vox = chunk->voxels[voxelIndex];
     const auto& def = content->getIndices()->blocks.require(vox.id);
     if (def.dataStruct == nullptr) {
         return 0;
@@ -558,15 +584,18 @@ static int l_set_field(lua::State* L) {
     if (lua::gettop(L) >= 6) {
         index = lua::tointeger(L, 6);
     }
-    auto vox = level->chunks->get(x, y, z);
     auto cx = floordiv(x, CHUNK_W);
     auto cz = floordiv(z, CHUNK_D);
-    auto chunk = level->chunks->getChunk(cx, cz);
     auto lx = x - cx * CHUNK_W;
     auto lz = z - cz * CHUNK_W;
+    auto chunk = blocks_agent::get_chunk(*level->chunks, cx, cz);
+    if (chunk == nullptr || y < 0 || y >= CHUNK_H) {
+        return 0;
+    }
     size_t voxelIndex = vox_index(lx, y, lz);
+    const auto& vox = chunk->voxels[voxelIndex];
 
-    const auto& def = content->getIndices()->blocks.require(vox->id);
+    const auto& def = content->getIndices()->blocks.require(vox.id);
     if (def.dataStruct == nullptr) {
         return 0;
     }
diff --git a/src/logic/scripting/lua/libs/libbyteutil.cpp b/src/logic/scripting/lua/libs/libbyteutil.cpp
new file mode 100644
index 000000000..a757712fd
--- /dev/null
+++ b/src/logic/scripting/lua/libs/libbyteutil.cpp
@@ -0,0 +1,205 @@
+#include "api_lua.hpp"
+
+#include <string>
+
+#include "coders/byte_utils.hpp"
+#include "util/data_io.hpp"
+
+static size_t calc_size(const char* format) {
+    size_t outSize = 0;
+    for (size_t i = 0; format[i]; i++) {
+        switch (format[i]) {
+            case 'b':
+            case 'B':
+            case '?':
+                outSize += 1;
+                break;
+            case 'h':
+            case 'H':
+                outSize += 2;
+                break;
+            case 'i':
+            case 'I':
+            case 'f':
+                outSize += 4;
+                break;
+            case 'd':
+            case 'l':
+            case 'L':
+                outSize += 8;
+                break;
+            default:
+                break;
+        }
+    }
+    return outSize;
+}
+
+static int pack(lua::State* L, const char* format, bool usetable) {
+    size_t outSize = calc_size(format);
+    bool bigEndian = false;
+
+    ByteBuilder builder(outSize);
+    int index = 2;
+    for (int i = 0; format[i]; i++) {
+        switch (format[i]) {
+            case 'b':
+                builder.put(lua::tointeger(L, index));
+                break;
+            case 'B':
+                builder.put(lua::tointeger(L, index) & 0xFF);
+                break;
+            case '?':
+                builder.put(lua::toboolean(L, index) ? 1 : 0);
+                break;
+            case 'h':
+                builder.putInt16(lua::tointeger(L, index), bigEndian);
+                break;
+            case 'H':
+                builder.putInt16(lua::tointeger(L, index) & 0xFFFFU, bigEndian);
+                break;
+            case 'i':
+                builder.putInt32(lua::tointeger(L, index), bigEndian);
+                break;
+            case 'I':
+                builder.putInt32(lua::tointeger(L, index) & 0xFFFFFFFFULL, bigEndian);
+                break;
+            case 'l':
+            case 'L':
+                builder.putInt64(lua::tointeger(L, index), bigEndian);
+                break;
+            case 'f':
+                builder.putFloat32(lua::tonumber(L, index), bigEndian);
+                break;
+            case 'd':
+                builder.putFloat64(lua::tonumber(L, index), bigEndian);
+                break;
+            case '!':
+            case '>':
+                bigEndian = true;
+                continue;
+            case '<':
+                bigEndian = false;
+                continue;
+            case '@':
+            case '=':
+                bigEndian = dataio::is_big_endian();
+                continue;
+            default:
+                continue;
+        }
+        index++;
+    }
+    if (usetable) {
+        lua::createtable(L, outSize, 0);
+        const ubyte* data = builder.data();
+        for (size_t i = 0; i < outSize; i++) {
+            lua::pushinteger(L, data[i]);
+            lua::rawseti(L, i + 1);
+        }
+        return 1;
+    } else {
+        return lua::newuserdata<lua::LuaBytearray>(L, builder.build());
+    }
+}
+
+static int count_elements(const char* format) {
+    int count = 0;
+    for (size_t i = 0; format[i]; i++) {
+        switch (format[i]) {
+            case 'b':
+            case 'B':
+            case '?':
+            case 'h':
+            case 'H':
+            case 'i':
+            case 'I':
+            case 'l':
+            case 'L':
+            case 'f':
+            case 'd':
+                count++;
+                break;
+            default:
+                break;
+        }
+    }
+    return count;
+}
+
+static int l_unpack(lua::State* L) {
+    const char* format = lua::require_string(L, 1);
+    int count = count_elements(format);
+    auto bytes = lua::require_bytearray(L, 2);
+    ByteReader reader(bytes);
+    bool bigEndian = false;
+
+    for (size_t i = 0; format[i]; i++) {
+        switch (format[i]) {
+            case 'b':
+                lua::pushinteger(L, reader.get());
+                break;
+            case 'B':
+                lua::pushinteger(L, reader.get() & 0xFF);
+                break;
+            case '?':
+                lua::pushboolean(L, reader.get() != 0);
+                break;
+            case 'h':
+                lua::pushinteger(L, reader.getInt16(bigEndian));
+                break;
+            case 'H':
+                lua::pushinteger(L, reader.getInt16(bigEndian) & 0xFFFF);
+                break;
+            case 'i':
+                lua::pushinteger(L, reader.getInt32(bigEndian));
+                break;
+            case 'I':
+                lua::pushinteger(L, reader.getInt32(bigEndian) & 0xFFFFFFFF);
+                break;
+            case 'l':
+                lua::pushinteger(L, reader.getInt64(bigEndian));
+                break;
+            case 'L':
+                lua::pushinteger(L, reader.getInt64(bigEndian));
+                break;
+            case 'f':
+                lua::pushnumber(L, reader.getFloat32(bigEndian));
+                break;
+            case 'd':
+                lua::pushnumber(L, reader.getFloat64(bigEndian));
+                break;
+            case '!':
+            case '>':
+                bigEndian = true;
+                continue;
+            case '<':
+                bigEndian = false;
+                continue;
+            case '@':
+            case '=':
+                bigEndian = dataio::is_big_endian();
+                continue;
+            default:
+                continue;
+        }
+    }
+    return count;
+}
+
+static int l_pack(lua::State* L) {
+    const char* format = lua::require_string(L, 1);
+    return pack(L, format, false);
+}
+
+static int l_tpack(lua::State* L) {
+    const char* format = lua::require_string(L, 1);
+    return pack(L, format, true);
+}
+
+const luaL_Reg byteutillib[] = {
+    {"pack", l_pack},
+    {"tpack", l_tpack},
+    {"unpack", l_unpack},
+    {NULL, NULL}
+};
diff --git a/src/logic/scripting/lua/libs/libconsole.cpp b/src/logic/scripting/lua/libs/libconsole.cpp
index 1e9168ef1..295d264b3 100644
--- a/src/logic/scripting/lua/libs/libconsole.cpp
+++ b/src/logic/scripting/lua/libs/libconsole.cpp
@@ -1,5 +1,5 @@
 #include "coders/commons.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "logic/CommandsInterpreter.hpp"
 #include "api_lua.hpp"
 
diff --git a/src/logic/scripting/lua/libs/libcore.cpp b/src/logic/scripting/lua/libs/libcore.cpp
index 9b048e443..80a924c5a 100644
--- a/src/logic/scripting/lua/libs/libcore.cpp
+++ b/src/logic/scripting/lua/libs/libcore.cpp
@@ -6,7 +6,7 @@
 #include "constants.hpp"
 #include "content/Content.hpp"
 #include "debug/Logger.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "files/engine_paths.hpp"
 #include "files/files.hpp"
 #include "files/settings_io.hpp"
@@ -16,6 +16,7 @@
 #include "logic/EngineController.hpp"
 #include "logic/LevelController.hpp"
 #include "util/listutil.hpp"
+#include "util/platform.hpp"
 #include "window/Events.hpp"
 #include "window/Window.hpp"
 #include "world/Level.hpp"
@@ -29,6 +30,19 @@ static int l_get_version(lua::State* L) {
     );
 }
 
+static int l_load_content(lua::State* L) {
+    engine->loadContent();
+    return 0;
+}
+
+static int l_reset_content(lua::State* L) {
+    if (level != nullptr) {
+        throw std::runtime_error("world must be closed before");
+    }
+    engine->resetContent();
+    return 0;
+}
+
 /// @brief Creating new world
 /// @param name Name world
 /// @param seed Seed world
@@ -55,10 +69,22 @@ static int l_open_world(lua::State* L) {
 /// @brief Reopen world
 static int l_reopen_world(lua::State*) {
     auto controller = engine->getController();
+    if (level == nullptr) {
+        throw std::runtime_error("no world open");
+    }
     controller->reopenWorld(level->getWorld());
     return 0;
 }
 
+/// @brief Save world
+static int l_save_world(lua::State* L) {
+    if (controller == nullptr) {
+        throw std::runtime_error("no world open");
+    }
+    controller->saveWorld();
+    return 0;
+}
+
 /// @brief Close world
 /// @param flag Save world (bool)
 static int l_close_world(lua::State* L) {
@@ -69,10 +95,7 @@ static int l_close_world(lua::State* L) {
     if (save_world) {
         controller->saveWorld();
     }
-    // destroy LevelScreen and run quit callbacks
-    engine->setScreen(nullptr);
-    // create and go to menu screen
-    engine->setScreen(std::make_shared<MenuScreen>(engine));
+    engine->onWorldClosed();
     return 0;
 }
 
@@ -90,36 +113,27 @@ static int l_delete_world(lua::State* L) {
 /// @param remPacks An array of packs to remove
 static int l_reconfig_packs(lua::State* L) {
     if (!lua::istable(L, 1)) {
-        throw std::runtime_error("strings array expected as the first argument"
-        );
+        throw std::runtime_error("strings array expected as the first argument");
     }
     if (!lua::istable(L, 2)) {
-        throw std::runtime_error("strings array expected as the second argument"
-        );
+        throw std::runtime_error("strings array expected as the second argument");
     }
     std::vector<std::string> addPacks;
-    if (!lua::istable(L, 1)) {
-        throw std::runtime_error("an array expected as argument 1");
-    }
     int addLen = lua::objlen(L, 1);
     for (int i = 0; i < addLen; i++) {
         lua::rawgeti(L, i + 1, 1);
-        addPacks.emplace_back(lua::tostring(L, -1));
+        addPacks.emplace_back(lua::require_lstring(L, -1));
         lua::pop(L);
     }
-
     std::vector<std::string> remPacks;
-    if (!lua::istable(L, 2)) {
-        throw std::runtime_error("an array expected as argument 2");
-    }
     int remLen = lua::objlen(L, 2);
     for (int i = 0; i < remLen; i++) {
         lua::rawgeti(L, i + 1, 2);
-        remPacks.emplace_back(lua::tostring(L, -1));
+        remPacks.emplace_back(lua::require_lstring(L, -1));
         lua::pop(L);
     }
-    auto engine_controller = engine->getController();
-    engine_controller->reconfigPacks(controller, addPacks, remPacks);
+    auto engineController = engine->getController();
+    engineController->reconfigPacks(controller, addPacks, remPacks);
     return 0;
 }
 
@@ -223,25 +237,31 @@ static int l_load_texture(lua::State* L) {
     return 0;
 }
 
-#include "util/platform.hpp"
-
 static int l_open_folder(lua::State* L) {
-    auto path = engine->getPaths()->resolve(lua::require_string(L, 1));
+    auto path = engine->getPaths().resolve(lua::require_string(L, 1));
     platform::open_folder(path);
     return 0;
 }
 
 /// @brief Quit the game
 static int l_quit(lua::State*) {
-    Window::setShouldClose(true);
+    engine->quit();
+    return 0;
+}
+
+static int l_blank(lua::State*) {
     return 0;
 }
 
 const luaL_Reg corelib[] = {
+    {"blank", lua::wrap<l_blank>},
     {"get_version", lua::wrap<l_get_version>},
+    {"load_content", lua::wrap<l_load_content>},
+    {"reset_content", lua::wrap<l_reset_content>},
     {"new_world", lua::wrap<l_new_world>},
     {"open_world", lua::wrap<l_open_world>},
     {"reopen_world", lua::wrap<l_reopen_world>},
+    {"save_world", lua::wrap<l_save_world>},
     {"close_world", lua::wrap<l_close_world>},
     {"delete_world", lua::wrap<l_delete_world>},
     {"reconfig_packs", lua::wrap<l_reconfig_packs>},
diff --git a/src/logic/scripting/lua/libs/libentity.cpp b/src/logic/scripting/lua/libs/libentity.cpp
index ba3bd349b..211bf5b1a 100644
--- a/src/logic/scripting/lua/libs/libentity.cpp
+++ b/src/logic/scripting/lua/libs/libentity.cpp
@@ -1,7 +1,7 @@
 #include "libentity.hpp"
 
 #include "content/Content.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "objects/Entities.hpp"
 #include "objects/EntityDef.hpp"
 #include "objects/Player.hpp"
@@ -9,6 +9,7 @@
 #include "physics/Hitbox.hpp"
 #include "voxels/Chunks.hpp"
 #include "voxels/Block.hpp"
+#include "voxels/blocks_agent.hpp"
 #include "window/Camera.hpp"
 
 using namespace scripting;
@@ -149,8 +150,15 @@ static int l_raycast(lua::State* L) {
 
     blockid_t block = BLOCK_VOID;
 
-    if (auto voxel = level->chunks->rayCast(
-            start, dir, maxDistance, end, normal, iend, filteredBlocks
+    if (auto voxel = blocks_agent::raycast(
+            *level->chunks,
+            start,
+            dir,
+            maxDistance,
+            end,
+            normal,
+            iend,
+            filteredBlocks
         )) {
         maxDistance = glm::distance(start, end);
         block = voxel->id;
diff --git a/src/logic/scripting/lua/libs/libfile.cpp b/src/logic/scripting/lua/libs/libfile.cpp
index a38081c9d..7fc70f469 100644
--- a/src/logic/scripting/lua/libs/libfile.cpp
+++ b/src/logic/scripting/lua/libs/libfile.cpp
@@ -3,7 +3,7 @@
 #include <set>
 
 #include "coders/gzip.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "files/engine_paths.hpp"
 #include "files/files.hpp"
 #include "util/stringutil.hpp"
@@ -14,14 +14,14 @@ namespace fs = std::filesystem;
 using namespace scripting;
 
 static fs::path resolve_path(const std::string& path) {
-    return engine->getPaths()->resolve(path);
+    return engine->getPaths().resolve(path);
 }
 
 static fs::path resolve_path_soft(const std::string& path) {
     if (path.find(':') == std::string::npos) {
         return fs::u8path("");
     }
-    return engine->getPaths()->resolve(path, false);
+    return engine->getPaths().resolve(path, false);
 }
 
 static int l_find(lua::State* L) {
@@ -57,12 +57,7 @@ static fs::path get_writeable_path(lua::State* L) {
     fs::path path = resolve_path(rawpath);
     auto entryPoint = rawpath.substr(0, rawpath.find(':'));
     if (writeable_entry_points.find(entryPoint) == writeable_entry_points.end()) {
-        if (lua::getglobal(L, "__vc_warning")) {
-            lua::pushstring(L, "writing to read-only entry point");
-            lua::pushstring(L, entryPoint);
-            lua::pushinteger(L, 1);
-            lua::call_nothrow(L, 3);
-        }
+        throw std::runtime_error("access denied");
     }
     return path;
 }
@@ -243,6 +238,16 @@ static int l_read_combined_object(lua::State* L) {
     return lua::pushvalue(L, engine->getResPaths()->readCombinedObject(path));
 }
 
+static int l_is_writeable(lua::State* L) {
+    std::string rawpath = lua::require_string(L, 1);
+    fs::path path = resolve_path(rawpath);
+    auto entryPoint = rawpath.substr(0, rawpath.find(':'));
+    if (writeable_entry_points.find(entryPoint) == writeable_entry_points.end()) {
+        return lua::pushboolean(L, false);
+    }
+    return lua::pushboolean(L, true);
+}
+
 const luaL_Reg filelib[] = {
     {"exists", lua::wrap<l_exists>},
     {"find", lua::wrap<l_find>},
@@ -263,4 +268,5 @@ const luaL_Reg filelib[] = {
     {"gzip_decompress", lua::wrap<l_gzip_decompress>},
     {"read_combined_list", lua::wrap<l_read_combined_list>},
     {"read_combined_object", lua::wrap<l_read_combined_object>},
+    {"is_writeable", lua::wrap<l_is_writeable>},
     {NULL, NULL}};
diff --git a/src/logic/scripting/lua/libs/libgeneration.cpp b/src/logic/scripting/lua/libs/libgeneration.cpp
index 034f6597e..90b681c39 100644
--- a/src/logic/scripting/lua/libs/libgeneration.cpp
+++ b/src/logic/scripting/lua/libs/libgeneration.cpp
@@ -6,15 +6,15 @@
 #include "world/Level.hpp"
 #include "world/generator/VoxelFragment.hpp"
 #include "content/ContentLoader.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "../lua_custom_types.hpp"
 
 using namespace scripting;
 
 static int l_save_fragment(lua::State* L) {
-    auto paths = engine->getPaths();
+    const auto& paths = engine->getPaths();
     auto fragment = lua::touserdata<lua::LuaVoxelFragment>(L, 1);
-    auto file = paths->resolve(lua::require_string(L, 2), true);
+    auto file = paths.resolve(lua::require_string(L, 2), true);
     auto map = fragment->getFragment()->serialize();
     auto bytes = json::to_binary(map, true);
     files::write_bytes(file, bytes.data(), bytes.size());
@@ -28,16 +28,16 @@ static int l_create_fragment(lua::State* L) {
     bool saveEntities = lua::toboolean(L, 4);
 
     auto fragment =
-        VoxelFragment::create(level, pointA, pointB, crop, saveEntities);
+        VoxelFragment::create(*level, pointA, pointB, crop, saveEntities);
     return lua::newuserdata<lua::LuaVoxelFragment>(
         L, std::shared_ptr<VoxelFragment>(std::move(fragment))
     );
 }
 
 static int l_load_fragment(lua::State* L) {
-    auto paths = engine->getPaths();
+    const auto& paths = engine->getPaths();
     auto filename = lua::require_string(L, 1);
-    auto path = paths->resolve(filename);
+    auto path = paths.resolve(filename);
     if (!std::filesystem::exists(path)) {
         throw std::runtime_error("file "+path.u8string()+" does not exist");
     }
diff --git a/src/logic/scripting/lua/libs/libgui.cpp b/src/logic/scripting/lua/libs/libgui.cpp
index 2a485be79..48cf73cf4 100644
--- a/src/logic/scripting/lua/libs/libgui.cpp
+++ b/src/logic/scripting/lua/libs/libgui.cpp
@@ -1,6 +1,6 @@
+#include "libgui.hpp"
 #include "assets/Assets.hpp"
-#include "engine.hpp"
-#include "frontend/UiDocument.hpp"
+#include "engine/Engine.hpp"
 #include "frontend/locale.hpp"
 #include "graphics/ui/elements/Button.hpp"
 #include "graphics/ui/elements/CheckBox.hpp"
@@ -10,24 +10,17 @@
 #include "graphics/ui/elements/Panel.hpp"
 #include "graphics/ui/elements/TextBox.hpp"
 #include "graphics/ui/elements/TrackBar.hpp"
-#include "graphics/ui/elements/UINode.hpp"
 #include "graphics/ui/gui_util.hpp"
 #include "graphics/ui/markdown.hpp"
 #include "graphics/core/Font.hpp"
 #include "items/Inventories.hpp"
 #include "util/stringutil.hpp"
 #include "world/Level.hpp"
-#include "api_lua.hpp"
 
 using namespace gui;
 using namespace scripting;
 
-struct DocumentNode {
-    UiDocument* document;
-    std::shared_ptr<UINode> node;
-};
-
-static DocumentNode getDocumentNode(
+static DocumentNode get_document_node_impl(
     lua::State*, const std::string& name, const std::string& nodeName
 ) {
     auto doc = engine->getAssets()->get<UiDocument>(name);
@@ -43,18 +36,18 @@ static DocumentNode getDocumentNode(
     return {doc, node};
 }
 
-static DocumentNode getDocumentNode(lua::State* L, int idx = 1) {
+DocumentNode get_document_node(lua::State* L, int idx) {
     lua::getfield(L, "docname", idx);
     lua::getfield(L, "name", idx);
     auto docname = lua::require_string(L, -2);
     auto name = lua::require_string(L, -1);
-    auto node = getDocumentNode(L, docname, name);
+    auto node = get_document_node_impl(L, docname, name);
     lua::pop(L, 2);
     return node;
 }
 
 static int l_menu_back(lua::State* L) {
-    auto node = getDocumentNode(L);
+    auto node = get_document_node(L);
     if (auto menu = dynamic_cast<Menu*>(node.node.get())) {
         menu->back();
     }
@@ -62,7 +55,7 @@ static int l_menu_back(lua::State* L) {
 }
 
 static int l_menu_reset(lua::State* L) {
-    auto node = getDocumentNode(L);
+    auto node = get_document_node(L);
     if (auto menu = dynamic_cast<Menu*>(node.node.get())) {
         menu->reset();
     }
@@ -70,7 +63,7 @@ static int l_menu_reset(lua::State* L) {
 }
 
 static int l_textbox_paste(lua::State* L) {
-    auto node = getDocumentNode(L);
+    auto node = get_document_node(L);
     if (auto box = dynamic_cast<TextBox*>(node.node.get())) {
         auto text = lua::require_string(L, 2);
         box->paste(util::str2wstr_utf8(text));
@@ -79,7 +72,7 @@ static int l_textbox_paste(lua::State* L) {
 }
 
 static int l_container_add(lua::State* L) {
-    auto docnode = getDocumentNode(L);
+    auto docnode = get_document_node(L);
     auto node = dynamic_cast<Container*>(docnode.node.get());
     if (node == nullptr) {
         return 0;
@@ -97,7 +90,7 @@ static int l_container_add(lua::State* L) {
 }
 
 static int l_node_destruct(lua::State* L) {
-    auto docnode = getDocumentNode(L);
+    auto docnode = get_document_node(L);
     auto node = docnode.node;
     engine->getGUI()->postRunnable([node]() {
         auto parent = node->getParent();
@@ -109,7 +102,7 @@ static int l_node_destruct(lua::State* L) {
 }
 
 static int l_container_clear(lua::State* L) {
-    auto node = getDocumentNode(L, 1);
+    auto node = get_document_node(L, 1);
     if (auto container = std::dynamic_pointer_cast<Container>(node.node)) {
         container->clear();
     }
@@ -117,7 +110,7 @@ static int l_container_clear(lua::State* L) {
 }
 
 static int l_container_set_interval(lua::State* L) {
-    auto node = getDocumentNode(L, 1);
+    auto node = get_document_node(L, 1);
     auto interval = lua::tointeger(L, 2) / 1000.0f;
     if (auto container = std::dynamic_pointer_cast<Container>(node.node)) {
         lua::pushvalue(L, 3);
@@ -128,8 +121,8 @@ static int l_container_set_interval(lua::State* L) {
 }
 
 static int l_move_into(lua::State* L) {
-    auto node = getDocumentNode(L, 1);
-    auto dest = getDocumentNode(L, 2);
+    auto node = get_document_node(L, 1);
+    auto dest = get_document_node(L, 2);
     UINode::moveInto(
         node.node, std::dynamic_pointer_cast<Container>(dest.node)
     );
@@ -137,7 +130,7 @@ static int l_move_into(lua::State* L) {
 }
 
 static int l_get_line_at(lua::State* L) {
-    auto node = getDocumentNode(L, 1);
+    auto node = get_document_node(L, 1);
     auto position = lua::tointeger(L, 2);
     if (auto box = dynamic_cast<TextBox*>(node.node.get())) {
         return lua::pushinteger(L, box->getLineAt(position));
@@ -146,7 +139,7 @@ static int l_get_line_at(lua::State* L) {
 }
 
 static int l_get_line_pos(lua::State* L) {
-    auto node = getDocumentNode(L, 1);
+    auto node = get_document_node(L, 1);
     auto line = lua::tointeger(L, 2);
     if (auto box = dynamic_cast<TextBox*>(node.node.get())) {
         return lua::pushinteger(L, box->getLinePos(line));
@@ -401,6 +394,10 @@ static int p_get_line_pos(UINode*, lua::State* L) {
     return lua::pushcfunction(L, l_get_line_pos);
 }
 
+static int p_get_cursor(UINode* node, lua::State* L) {
+    return lua::pushstring(L, to_string(node->getCursor()));
+}
+
 static int l_gui_getattr(lua::State* L) {
     auto docname = lua::require_string(L, 1);
     auto element = lua::require_string(L, 2);
@@ -455,10 +452,11 @@ static int l_gui_getattr(lua::State* L) {
             {"paste", p_get_paste},
             {"inventory", p_get_inventory},
             {"focused", p_get_focused},
+            {"cursor", p_get_cursor},
         };
     auto func = getters.find(attr);
     if (func != getters.end()) {
-        auto docnode = getDocumentNode(L, docname, element);
+        auto docnode = get_document_node_impl(L, docname, element);
         auto node = docnode.node;
         return func->second(node.get(), L);
     }
@@ -616,12 +614,18 @@ static void p_set_focused(
     }
 }
 
+static void p_set_cursor(UINode* node, lua::State* L, int idx) {
+    if (auto cursor = CursorShape_from(lua::require_string(L, idx))) {
+        node->setCursor(*cursor);
+    }
+}
+
 static int l_gui_setattr(lua::State* L) {
     auto docname = lua::require_string(L, 1);
     auto element = lua::require_string(L, 2);
     auto attr = lua::require_string(L, 3);
 
-    auto docnode = getDocumentNode(L, docname, element);
+    auto docnode = get_document_node_impl(L, docname, element);
     auto node = docnode.node;
 
     static const std::unordered_map<
@@ -658,6 +662,7 @@ static int l_gui_setattr(lua::State* L) {
             {"checked", p_set_checked},
             {"page", p_set_page},
             {"inventory", p_set_inventory},
+            {"cursor", p_set_cursor},
         };
     auto func = setters.find(attr);
     if (func != setters.end()) {
@@ -747,6 +752,58 @@ static int l_gui_escape_markup(lua::State* L) {
     return lua::pushstring(L, text);
 }
 
+static int l_gui_confirm(lua::State* L) {
+    auto question = lua::require_wstring(L, 1);
+    runnable onconfirm = nullptr;
+    if (lua::gettop(L) >= 2) {
+        lua::pushvalue(L, 2);
+        onconfirm = lua::create_runnable(L);
+    }
+    runnable ondeny = nullptr;
+    if (lua::gettop(L) >= 3) {
+        lua::pushvalue(L, 3);
+        ondeny = lua::create_runnable(L);
+    }
+    std::wstring yestext = L"";
+    if (lua::gettop(L) >= 4) {
+        yestext = lua::require_wstring(L, 4);
+    }
+    std::wstring notext = L"";
+    if (lua::gettop(L) >= 5) {
+        notext = lua::require_wstring(L, 5);
+    }
+    guiutil::confirm(*engine, question, onconfirm, ondeny, yestext, notext);
+    return 0;
+}
+
+static int l_gui_alert(lua::State* L) {
+    auto message = lua::require_wstring(L, 1);
+    runnable onconfirm = nullptr;
+    if (lua::gettop(L) >= 2) {
+        lua::pushvalue(L, 2);
+        onconfirm = lua::create_runnable(L);
+    }
+    guiutil::alert(*engine, message, onconfirm);
+    return 0;
+}
+
+static int l_gui_load_document(lua::State* L) {
+    auto filename = lua::require_string(L, 1);
+    auto alias = lua::require_string(L, 2);
+    auto args = lua::tovalue(L, 3);
+    
+    auto documentPtr = UiDocument::read(
+        scripting::get_root_environment(),
+        alias,
+        engine->getPaths().resolve(filename),
+        filename  
+    );
+    auto document = documentPtr.get();
+    engine->getAssets()->store(std::move(documentPtr), alias);
+    scripting::on_ui_open(document, {args});
+    return 0;
+}
+
 const luaL_Reg guilib[] = {
     {"get_viewport", lua::wrap<l_gui_getviewport>},
     {"getattr", lua::wrap<l_gui_getattr>},
@@ -756,6 +813,9 @@ const luaL_Reg guilib[] = {
     {"get_locales_info", lua::wrap<l_gui_get_locales_info>},
     {"clear_markup", lua::wrap<l_gui_clear_markup>},
     {"escape_markup", lua::wrap<l_gui_escape_markup>},
+    {"confirm", lua::wrap<l_gui_confirm>},
+    {"alert", lua::wrap<l_gui_alert>},
+    {"load_document", lua::wrap<l_gui_load_document>},
     {"__reindex", lua::wrap<l_gui_reindex>},
     {NULL, NULL}
 };
diff --git a/src/logic/scripting/lua/libs/libgui.hpp b/src/logic/scripting/lua/libs/libgui.hpp
new file mode 100644
index 000000000..f6fa7d81d
--- /dev/null
+++ b/src/logic/scripting/lua/libs/libgui.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <memory>
+
+#include "api_lua.hpp"
+#include "frontend/UiDocument.hpp"
+#include "graphics/ui/elements/UINode.hpp"
+
+struct DocumentNode {
+    UiDocument* document;
+    std::shared_ptr<gui::UINode> node;
+};
+
+DocumentNode get_document_node(lua::State* L, int idx = 1);
diff --git a/src/logic/scripting/lua/libs/libhud.cpp b/src/logic/scripting/lua/libs/libhud.cpp
index 7f5ec46d5..642121cf2 100644
--- a/src/logic/scripting/lua/libs/libhud.cpp
+++ b/src/logic/scripting/lua/libs/libhud.cpp
@@ -3,7 +3,7 @@
 
 #include "assets/Assets.hpp"
 #include "content/Content.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "frontend/UiDocument.hpp"
 #include "frontend/hud.hpp"
 #include "graphics/ui/elements/InventoryView.hpp"
@@ -14,6 +14,7 @@
 #include "voxels/Block.hpp"
 #include "voxels/Chunks.hpp"
 #include "voxels/voxel.hpp"
+#include "voxels/blocks_agent.hpp"
 #include "world/Level.hpp"
 #include "api_lua.hpp"
 
@@ -59,7 +60,7 @@ static int l_open_block(lua::State* L) {
     auto z = lua::tointeger(L, 3);
     bool playerInventory = !lua::toboolean(L, 4);
 
-    auto vox = level->chunks->get(x, y, z);
+    auto vox = blocks_agent::get(*level->chunks, x, y, z);
     if (vox == nullptr) {
         throw std::runtime_error(
             "block does not exists at " + std::to_string(x) + " " +
diff --git a/src/logic/scripting/lua/libs/libinput.cpp b/src/logic/scripting/lua/libs/libinput.cpp
index 1866a433d..3447728ba 100644
--- a/src/logic/scripting/lua/libs/libinput.cpp
+++ b/src/logic/scripting/lua/libs/libinput.cpp
@@ -1,14 +1,15 @@
 #include <filesystem>
 
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "files/files.hpp"
 #include "frontend/hud.hpp"
 #include "frontend/screens/Screen.hpp"
 #include "graphics/ui/GUI.hpp"
+#include "graphics/ui/elements/Container.hpp"
 #include "util/stringutil.hpp"
 #include "window/Events.hpp"
 #include "window/input.hpp"
-#include "api_lua.hpp"
+#include "libgui.hpp"
 
 namespace scripting {
     extern Hud* hud;
@@ -30,24 +31,47 @@ static int l_mousecode(lua::State* L) {
 }
 
 static int l_add_callback(lua::State* L) {
-    auto bindname = lua::require_string(L, 1);
+    std::string bindname = lua::require_string(L, 1);
+    size_t pos = bindname.find(':');
+
+    lua::pushvalue(L, 2);
+    auto actual_callback = lua::create_simple_handler(L);
+    observer_handler handler;
+    
+    if (pos != std::string::npos) {
+        std::string prefix = bindname.substr(0, pos);
+        if (prefix == "key") {
+            auto key = input_util::keycode_from(bindname.substr(pos + 1));
+            handler = Events::keyCallbacks[key].add(actual_callback);
+        }
+    }
+
     const auto& bind = Events::bindings.find(bindname);
     if (bind == Events::bindings.end()) {
         throw std::runtime_error("unknown binding " + util::quote(bindname));
     }
-    lua::pushvalue(L, 2);
-    runnable actual_callback = lua::create_runnable(L);
-    runnable callback = [=]() {
+    auto callback = [=]() -> bool {
         if (!scripting::engine->getGUI()->isFocusCaught()) {
-            actual_callback();
+            return actual_callback();
         }
+        return false;
     };
+    if (handler == nullptr) {
+        handler = bind->second.onactived.add(callback);
+    }
+
     if (hud) {
-        hud->keepAlive(bind->second.onactived.add(callback));
-    } else {
-        throw std::runtime_error("on_hud_open is not called yet");
+        hud->keepAlive(handler);
+        return 0;
+    } else if (lua::gettop(L) >= 3) {
+        auto node = get_document_node(L, 3);
+        if (auto container = std::dynamic_pointer_cast<gui::Container>(node.node)) {
+            container->keepAlive(handler);
+            return 0;
+        }
+        throw std::runtime_error("owner expected to be a container");
     }
-    return 0;
+    throw std::runtime_error("on_hud_open is not called yet");
 }
 
 static int l_get_mouse_pos(lua::State* L) {
@@ -125,7 +149,7 @@ static void resetPackBindings(fs::path& packFolder) {
 }
 
 static int l_reset_bindings(lua::State*) {
-    auto resFolder = engine->getPaths()->getResourcesFolder();
+    auto resFolder = engine->getPaths().getResourcesFolder();
     resetPackBindings(resFolder);
     for (auto& pack : engine->getContentPacks()) {
         resetPackBindings(pack.folder);
diff --git a/src/logic/scripting/lua/libs/libinventory.cpp b/src/logic/scripting/lua/libs/libinventory.cpp
index 8f1f53858..65f0dd7ce 100644
--- a/src/logic/scripting/lua/libs/libinventory.cpp
+++ b/src/logic/scripting/lua/libs/libinventory.cpp
@@ -13,15 +13,15 @@ static void validate_itemid(itemid_t id) {
     }
 }
 
-static std::shared_ptr<Inventory> get_inventory(int64_t id) {
+static Inventory& get_inventory(int64_t id) {
     auto inv = level->inventories->get(id);
     if (inv == nullptr) {
         throw std::runtime_error("inventory not found: " + std::to_string(id));
     }
-    return inv;
+    return *inv;
 }
 
-static std::shared_ptr<Inventory> get_inventory(int64_t id, int arg) {
+static Inventory& get_inventory(int64_t id, int arg) {
     auto inv = level->inventories->get(id);
     if (inv == nullptr) {
         throw std::runtime_error(
@@ -29,62 +29,62 @@ static std::shared_ptr<Inventory> get_inventory(int64_t id, int arg) {
             std::to_string(arg)
         );
     }
-    return inv;
+    return *inv;
 }
 
-static void validate_slotid(int slotid, Inventory* inv) {
-    if (static_cast<size_t>(slotid) >= inv->size()) {
+static void validate_slotid(int slotid, const Inventory& inv) {
+    if (static_cast<size_t>(slotid) >= inv.size()) {
         throw std::runtime_error(
             "slot index is out of range [0..inventory.size(invid)]"
         );
     }
 }
 
-static int l_inventory_get(lua::State* L) {
+static int l_get(lua::State* L) {
     auto invid = lua::tointeger(L, 1);
     auto slotid = lua::tointeger(L, 2);
     auto inv = get_inventory(invid);
-    validate_slotid(slotid, inv.get());
-    const ItemStack& item = inv->getSlot(slotid);
+    validate_slotid(slotid, inv);
+    const ItemStack& item = inv.getSlot(slotid);
     lua::pushinteger(L, item.getItemId());
     lua::pushinteger(L, item.getCount());
     return 2;
 }
 
-static int l_inventory_set(lua::State* L) {
+static int l_set(lua::State* L) {
     auto invid = lua::tointeger(L, 1);
     auto slotid = lua::tointeger(L, 2);
     auto itemid = lua::tointeger(L, 3);
     auto count = lua::tointeger(L, 4);
     validate_itemid(itemid);
 
-    auto inv = get_inventory(invid);
+    auto& inv = get_inventory(invid);
 
-    validate_slotid(slotid, inv.get());
-    ItemStack& item = inv->getSlot(slotid);
+    validate_slotid(slotid, inv);
+    ItemStack& item = inv.getSlot(slotid);
     item.set(ItemStack(itemid, count));
     return 0;
 }
 
-static int l_inventory_size(lua::State* L) {
+static int l_size(lua::State* L) {
     auto invid = lua::tointeger(L, 1);
-    auto inv = get_inventory(invid);
-    return lua::pushinteger(L, inv->size());
+    auto& inv = get_inventory(invid);
+    return lua::pushinteger(L, inv.size());
 }
 
-static int l_inventory_add(lua::State* L) {
+static int l_add(lua::State* L) {
     auto invid = lua::tointeger(L, 1);
     auto itemid = lua::tointeger(L, 2);
     auto count = lua::tointeger(L, 3);
     validate_itemid(itemid);
 
-    auto inv = get_inventory(invid);
+    auto& inv = get_inventory(invid);
     ItemStack item(itemid, count);
-    inv->move(item, indices);
+    inv.move(item, indices);
     return lua::pushinteger(L, item.getCount());
 }
 
-static int l_inventory_get_block(lua::State* L) {
+static int l_get_block(lua::State* L) {
     auto x = lua::tointeger(L, 1);
     auto y = lua::tointeger(L, 2);
     auto z = lua::tointeger(L, 3);
@@ -92,7 +92,7 @@ static int l_inventory_get_block(lua::State* L) {
     return lua::pushinteger(L, id);
 }
 
-static int l_inventory_bind_block(lua::State* L) {
+static int l_bind_block(lua::State* L) {
     auto id = lua::tointeger(L, 1);
     auto x = lua::tointeger(L, 2);
     auto y = lua::tointeger(L, 3);
@@ -101,7 +101,7 @@ static int l_inventory_bind_block(lua::State* L) {
     return 0;
 }
 
-static int l_inventory_unbind_block(lua::State* L) {
+static int l_unbind_block(lua::State* L) {
     auto x = lua::tointeger(L, 1);
     auto y = lua::tointeger(L, 2);
     auto z = lua::tointeger(L, 3);
@@ -109,7 +109,7 @@ static int l_inventory_unbind_block(lua::State* L) {
     return 0;
 }
 
-static int l_inventory_create(lua::State* L) {
+static int l_create(lua::State* L) {
     auto invsize = lua::tointeger(L, 1);
     auto inv = level->inventories->create(invsize);
     if (inv == nullptr) {
@@ -118,18 +118,13 @@ static int l_inventory_create(lua::State* L) {
     return lua::pushinteger(L, inv->getId());
 }
 
-static int l_inventory_remove(lua::State* L) {
+static int l_remove(lua::State* L) {
     auto invid = lua::tointeger(L, 1);
-    auto inv = get_inventory(invid);
-    if (inv == nullptr) {
-        return 0;
-    }
-
     level->inventories->remove(invid);
     return 0;
 }
 
-static int l_inventory_clone(lua::State* L) {
+static int l_clone(lua::State* L) {
     auto id = lua::tointeger(L, 1);
     auto clone = level->inventories->clone(id);
     if (clone == nullptr) {
@@ -138,54 +133,69 @@ static int l_inventory_clone(lua::State* L) {
     return lua::pushinteger(L, clone->getId());
 }
 
-static int l_inventory_move(lua::State* L) {
+static int l_move(lua::State* L) {
     auto invAid = lua::tointeger(L, 1);
     auto slotAid = lua::tointeger(L, 2);
-    auto invA = get_inventory(invAid, 1);
-    validate_slotid(slotAid, invA.get());
+    auto& invA = get_inventory(invAid, 1);
+    validate_slotid(slotAid, invA);
 
     auto invBid = lua::tointeger(L, 3);
     auto slotBid = lua::isnil(L, 4) ? -1 : lua::tointeger(L, 4);
-    auto invB = get_inventory(invBid, 3);
-    auto& slot = invA->getSlot(slotAid);
+    auto& invB = get_inventory(invBid, 3);
+    auto& slot = invA.getSlot(slotAid);
     if (slotBid == -1) {
-        invB->move(slot, content->getIndices());
+        invB.move(slot, content->getIndices());
     } else {
-        invB->move(slot, content->getIndices(), slotBid, slotBid + 1);
+        invB.move(slot, content->getIndices(), slotBid, slotBid + 1);
     }
     return 0;
 }
 
-static int l_inventory_move_range(lua::State* L) {
+static int l_move_range(lua::State* L) {
     auto invAid = lua::tointeger(L, 1);
     auto slotAid = lua::tointeger(L, 2);
-    auto invA = get_inventory(invAid, 1);
-    validate_slotid(slotAid, invA.get());
+    auto& invA = get_inventory(invAid, 1);
+    validate_slotid(slotAid, invA);
 
     auto invBid = lua::tointeger(L, 3);
     auto slotBegin = lua::isnoneornil(L, 4) ? -1 : lua::tointeger(L, 4);
     auto slotEnd = lua::isnoneornil(L, 5) ? -1 : lua::tointeger(L, 5) + 1;
     auto invB = get_inventory(invBid, 3);
-    auto& slot = invA->getSlot(slotAid);
+    auto& slot = invA.getSlot(slotAid);
     if (slotBegin == -1) {
-        invB->move(slot, content->getIndices());
+        invB.move(slot, content->getIndices());
     } else {
-        invB->move(slot, content->getIndices(), slotBegin, slotEnd);
+        invB.move(slot, content->getIndices(), slotBegin, slotEnd);
     }
     return 0;
 }
 
+static int l_find_by_item(lua::State* L) {
+    auto invId = lua::tointeger(L, 1); 
+    auto& inv = get_inventory(invId, 1);
+    integer_t blockid = lua::tointeger(L, 2);
+    integer_t begin = lua::isnumber(L, 3) ? lua::tointeger(L, 3) : 0;
+    integer_t end = lua::isnumber(L, 4) ? lua::tointeger(L, 4) : -1;
+    integer_t minCount = lua::isnumber(L, 5) ? lua::tointeger(L, 5) : blockid != 0;
+    size_t index = inv.findSlotByItem(blockid, begin, end, minCount);
+    if (index == Inventory::npos) {
+        return 0;
+    }
+    return lua::pushinteger(L, index);
+}
+
 const luaL_Reg inventorylib[] = {
-    {"get", lua::wrap<l_inventory_get>},
-    {"set", lua::wrap<l_inventory_set>},
-    {"size", lua::wrap<l_inventory_size>},
-    {"add", lua::wrap<l_inventory_add>},
-    {"move", lua::wrap<l_inventory_move>},
-    {"move_range", lua::wrap<l_inventory_move_range>},
-    {"get_block", lua::wrap<l_inventory_get_block>},
-    {"bind_block", lua::wrap<l_inventory_bind_block>},
-    {"unbind_block", lua::wrap<l_inventory_unbind_block>},
-    {"create", lua::wrap<l_inventory_create>},
-    {"remove", lua::wrap<l_inventory_remove>},
-    {"clone", lua::wrap<l_inventory_clone>},
+    {"get", lua::wrap<l_get>},
+    {"set", lua::wrap<l_set>},
+    {"size", lua::wrap<l_size>},
+    {"add", lua::wrap<l_add>},
+    {"move", lua::wrap<l_move>},
+    {"move_range", lua::wrap<l_move_range>},
+    {"find_by_item", lua::wrap<l_find_by_item>},
+    {"get_block", lua::wrap<l_get_block>},
+    {"bind_block", lua::wrap<l_bind_block>},
+    {"unbind_block", lua::wrap<l_unbind_block>},
+    {"create", lua::wrap<l_create>},
+    {"remove", lua::wrap<l_remove>},
+    {"clone", lua::wrap<l_clone>},
     {NULL, NULL}};
diff --git a/src/logic/scripting/lua/libs/libnetwork.cpp b/src/logic/scripting/lua/libs/libnetwork.cpp
index dc7527104..d1edf1850 100644
--- a/src/logic/scripting/lua/libs/libnetwork.cpp
+++ b/src/logic/scripting/lua/libs/libnetwork.cpp
@@ -1,7 +1,8 @@
 #include "api_lua.hpp"
 
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "network/Network.hpp"
+#include "coders/json.hpp"
 
 using namespace scripting;
 
@@ -36,6 +37,25 @@ static int l_get_binary(lua::State* L) {
     return 0;
 }
 
+static int l_post(lua::State* L) {
+    std::string url(lua::require_lstring(L, 1));
+    auto data = lua::tovalue(L, 2);
+
+    lua::pushvalue(L, 3);
+    auto onResponse = lua::create_lambda_nothrow(L);
+
+    auto string = json::stringify(data, false);
+    engine->getNetwork().post(url, string, [onResponse](std::vector<char> bytes) {
+        auto buffer = std::make_shared<util::Buffer<ubyte>>(
+            reinterpret_cast<const ubyte*>(bytes.data()), bytes.size()
+        );
+        engine->postRunnable([=]() {
+            onResponse({std::string(bytes.data(), bytes.size())});
+        });
+    });
+    return 0;
+}
+
 static int l_connect(lua::State* L) {
     std::string address = lua::require_string(L, 1);
     int port = lua::tointeger(L, 2);
@@ -123,6 +143,14 @@ static int l_recv(lua::State* L) {
     return 1;
 }
 
+static int l_available(lua::State* L) {
+    u64id_t id = lua::tointeger(L, 1);
+    if (auto connection = engine->getNetwork().getConnection(id)) {
+        return lua::pushinteger(L, connection->available());
+    }
+    return 0;
+}
+
 static int l_open(lua::State* L) {
     int port = lua::tointeger(L, 1);
     lua::pushvalue(L, 2);
@@ -192,6 +220,7 @@ static int l_get_total_download(lua::State* L) {
 const luaL_Reg networklib[] = {
     {"get", lua::wrap<l_get>},
     {"get_binary", lua::wrap<l_get_binary>},
+    {"post", lua::wrap<l_post>},
     {"get_total_upload", lua::wrap<l_get_total_upload>},
     {"get_total_download", lua::wrap<l_get_total_download>},
     {"__open", lua::wrap<l_open>},
@@ -200,6 +229,7 @@ const luaL_Reg networklib[] = {
     {"__close", lua::wrap<l_close>},
     {"__send", lua::wrap<l_send>},
     {"__recv", lua::wrap<l_recv>},
+    {"__available", lua::wrap<l_available>},
     {"__is_alive", lua::wrap<l_is_alive>},
     {"__is_connected", lua::wrap<l_is_connected>},
     {"__get_address", lua::wrap<l_get_address>},
diff --git a/src/logic/scripting/lua/libs/libpack.cpp b/src/logic/scripting/lua/libs/libpack.cpp
index fdd9ae8a4..95bb9e995 100644
--- a/src/logic/scripting/lua/libs/libpack.cpp
+++ b/src/logic/scripting/lua/libs/libpack.cpp
@@ -2,10 +2,11 @@
 #include <filesystem>
 #include <stdexcept>
 #include <string>
+#include <set>
 
 #include "assets/AssetsLoader.hpp"
 #include "content/Content.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "files/WorldFiles.hpp"
 #include "files/engine_paths.hpp"
 #include "world/Level.hpp"
@@ -63,7 +64,7 @@ static int l_pack_get_available(lua::State* L) {
 static int l_pack_get_info(
     lua::State* L, const ContentPack& pack, const Content* content
 ) {
-    lua::createtable(L, 0, 5);
+    lua::createtable(L, 0, 6);
 
     lua::pushstring(L, pack.id);
     lua::setfield(L, "id");
@@ -80,16 +81,20 @@ static int l_pack_get_info(
     lua::pushstring(L, pack.version);
     lua::setfield(L, "version");
 
-    auto assets = engine->getAssets();
-    std::string icon = pack.id + ".icon";
-    if (!AssetsLoader::loadExternalTexture(
-            assets, icon, {pack.folder / fs::path("icon.png")}
-        )) {
-        icon = "gui/no_icon";
-    }
+    lua::pushstring(L, pack.path);
+    lua::setfield(L, "path");
 
-    lua::pushstring(L, icon);
-    lua::setfield(L, "icon");
+    if (!engine->isHeadless()) {
+        auto assets = engine->getAssets();
+        std::string icon = pack.id + ".icon";
+        if (!AssetsLoader::loadExternalTexture(
+                assets, icon, {pack.folder / fs::path("icon.png")}
+            )) {
+            icon = "gui/no_icon";
+        }
+        lua::pushstring(L, icon);
+        lua::setfield(L, "icon");
+    }
 
     if (!pack.dependencies.empty()) {
         lua::createtable(L, pack.dependencies.size(), 0);
@@ -123,6 +128,44 @@ static int l_pack_get_info(
     return 1;
 }
 
+static int pack_get_infos(lua::State* L) {
+    std::set<std::string> ids;
+    size_t len = lua::objlen(L, 1);
+    for (size_t i = 1; i <= len; i++) {
+        lua::rawgeti(L, i);
+        ids.insert(lua::require_string(L, -1));
+        lua::pop(L, 1);
+    }
+    std::unordered_map<std::string, ContentPack> packs;
+    auto content = engine->getContent();
+    const auto& loadedPacks = engine->getContentPacks();
+    for (const auto& pack : loadedPacks) {
+        if (ids.find(pack.id) != ids.end()) {
+            packs[pack.id] = pack;
+            ids.erase(pack.id);
+        }
+    }
+    if (!ids.empty()) {
+        fs::path worldFolder("");
+        if (level) {
+            worldFolder = level->getWorld()->wfile->getFolder();
+        }
+        auto manager = engine->createPacksManager(worldFolder);
+        manager.scan();
+        auto vec =
+            manager.getAll(std::vector<std::string>(ids.begin(), ids.end()));
+        for (const auto& pack : vec) {
+            packs[pack.id] = pack;
+        }
+    }
+    lua::createtable(L, 0, packs.size());
+    for (const auto& [id, pack] : packs) {
+        l_pack_get_info(L, pack, content);
+        lua::setfield(L, id);
+    }
+    return 1;
+}
+
 /// @brief pack.get_info(packid: str) -> {
 ///     title: str,
 ///     creator: str,
@@ -131,6 +174,11 @@ static int l_pack_get_info(
 ///     [optional] has_indices: bool
 /// } or nil
 static int l_pack_get_info(lua::State* L) {
+    if (lua::istable(L, 1)) {
+        return pack_get_infos(L);
+    } else if (!lua::isstring(L, 1)) {
+        throw std::runtime_error("string or table expected");
+    }
     auto packid = lua::tostring(L, 1);
 
     auto content = engine->getContent();
@@ -140,7 +188,6 @@ static int l_pack_get_info(lua::State* L) {
             return pack.id == packid;
         });
     if (found == packs.end()) {
-        // TODO: optimize
         fs::path worldFolder("");
         if (level) {
             worldFolder = level->getWorld()->wfile->getFolder();
@@ -167,10 +214,38 @@ static int l_pack_get_base_packs(lua::State* L) {
     return 1;
 }
 
+static int l_pack_assemble(lua::State* L) {
+    if (!lua::istable(L, 1)) {
+        throw std::runtime_error("table expected");
+    }
+    std::vector<std::string> ids;
+    size_t len = lua::objlen(L, 1);
+    for (size_t i = 1; i <= len; i++) {
+        lua::rawgeti(L, i);
+        ids.push_back(lua::require_string(L, -1));
+        lua::pop(L);
+    }
+    fs::path worldFolder("");
+    if (level) {
+        worldFolder = level->getWorld()->wfile->getFolder();
+    }
+    auto manager = engine->createPacksManager(worldFolder);
+    manager.scan();
+    ids = std::move(manager.assemble(ids));
+
+    lua::createtable(L, ids.size(), 0);
+    for (size_t i = 0; i < ids.size(); i++) {
+        lua::pushstring(L, ids[i]);
+        lua::rawseti(L, i + 1);
+    }
+    return 1;
+}
+
 const luaL_Reg packlib[] = {
     {"get_folder", lua::wrap<l_pack_get_folder>},
     {"get_installed", lua::wrap<l_pack_get_installed>},
     {"get_available", lua::wrap<l_pack_get_available>},
     {"get_info", lua::wrap<l_pack_get_info>},
     {"get_base_packs", lua::wrap<l_pack_get_base_packs>},
+    {"assemble", lua::wrap<l_pack_assemble>},
     {NULL, NULL}};
diff --git a/src/logic/scripting/lua/libs/libparticles.cpp b/src/logic/scripting/lua/libs/libparticles.cpp
index ae2ed6d3f..d3bccf762 100644
--- a/src/logic/scripting/lua/libs/libparticles.cpp
+++ b/src/logic/scripting/lua/libs/libparticles.cpp
@@ -5,7 +5,7 @@
 #include "graphics/render/ParticlesRenderer.hpp"
 #include "graphics/render/Emitter.hpp"
 #include "assets/assets_util.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 
 using namespace scripting;
 
diff --git a/src/logic/scripting/lua/libs/libplayer.cpp b/src/logic/scripting/lua/libs/libplayer.cpp
index 0628c5afe..af908aea0 100644
--- a/src/logic/scripting/lua/libs/libplayer.cpp
+++ b/src/logic/scripting/lua/libs/libplayer.cpp
@@ -60,7 +60,7 @@ static int l_set_vel(lua::State* L) {
 
 static int l_get_rot(lua::State* L) {
     if (auto player = get_player(L, 1)) {
-        return lua::pushvec_stack(L, player->cam);
+        return lua::pushvec_stack(L, player->rotation);
     }
     return 0;
 }
@@ -70,17 +70,17 @@ static int l_set_rot(lua::State* L) {
     if (!player) {
         return 0;
     }
-    glm::vec3& cam = player->cam;
+    glm::vec3& rotation = player->rotation;
 
     auto x = lua::tonumber(L, 2);
     auto y = lua::tonumber(L, 3);
-    auto z = cam.z;
+    auto z = rotation.z;
     if (lua::isnumber(L, 4)) {
         z = lua::tonumber(L, 4);
     }
-    cam.x = x;
-    cam.y = y;
-    cam.z = z;
+    rotation.x = x;
+    rotation.y = y;
+    rotation.z = z;
     return 0;
 }
 
@@ -101,6 +101,13 @@ static int l_get_inv(lua::State* L) {
     return 2;
 }
 
+static int l_set_selected_slot(lua::State* L) {
+    if (auto player = get_player(L, 1)) {
+        player->setChosenSlot(lua::tointeger(L, 2) % 10);
+    }
+    return 0;
+}
+
 static int l_is_flight(lua::State* L) {
     if (auto player = get_player(L, 1)) {
         return lua::pushboolean(L, player->isFlight());
@@ -157,6 +164,20 @@ static int l_set_instant_destruction(lua::State* L) {
     return 0;
 }
 
+static int l_is_loading_chunks(lua::State* L) {
+    if (auto player = get_player(L, 1)) {
+        return lua::pushboolean(L, player->isLoadingChunks());
+    }
+    return 0;
+}
+
+static int l_set_loading_chunks(lua::State* L) {
+    if (auto player = get_player(L, 1)) {
+        player->setLoadingChunks(lua::toboolean(L, 2));
+    }
+    return 0;
+}
+
 static int l_get_selected_block(lua::State* L) {
     if (auto player = get_player(L, 1)) {
         if (player->selection.vox.id == BLOCK_VOID) {
@@ -250,6 +271,19 @@ static int l_set_name(lua::State* L) {
     return 0;
 }
 
+static int l_create(lua::State* L) {
+    auto player = level->players->create();
+    if (lua::isstring(L, 1)) {
+        player->setName(lua::require_string(L, 1));
+    }
+    return lua::pushinteger(L, player->getId());
+}
+
+static int l_delete(lua::State* L) {
+    level->players->remove(lua::tointeger(L, 1));
+    return 0;
+}
+
 const luaL_Reg playerlib[] = {
     {"get_pos", lua::wrap<l_get_pos>},
     {"set_pos", lua::wrap<l_set_pos>},
@@ -267,6 +301,9 @@ const luaL_Reg playerlib[] = {
     {"set_infinite_items", lua::wrap<l_set_infinite_items>},
     {"is_instant_destruction", lua::wrap<l_is_instant_destruction>},
     {"set_instant_destruction", lua::wrap<l_set_instant_destruction>},
+    {"is_loading_chunks", lua::wrap<l_is_loading_chunks>},
+    {"set_loading_chunks", lua::wrap<l_set_loading_chunks>},
+    {"set_selected_slot", lua::wrap<l_set_selected_slot>},
     {"get_selected_block", lua::wrap<l_get_selected_block>},
     {"get_selected_entity", lua::wrap<l_get_selected_entity>},
     {"set_spawnpoint", lua::wrap<l_set_spawnpoint>},
@@ -277,5 +314,7 @@ const luaL_Reg playerlib[] = {
     {"set_camera", lua::wrap<l_set_camera>},
     {"get_name", lua::wrap<l_get_name>},
     {"set_name", lua::wrap<l_set_name>},
+    {"create", lua::wrap<l_create>},
+    {"delete", lua::wrap<l_delete>},
     {NULL, NULL}
 };
diff --git a/src/logic/scripting/lua/libs/libtext3d.cpp b/src/logic/scripting/lua/libs/libtext3d.cpp
index 433a959e9..f334c85f4 100644
--- a/src/logic/scripting/lua/libs/libtext3d.cpp
+++ b/src/logic/scripting/lua/libs/libtext3d.cpp
@@ -4,7 +4,7 @@
 #include "graphics/render/WorldRenderer.hpp"
 #include "graphics/render/TextsRenderer.hpp"
 #include "graphics/render/TextNote.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 
 using namespace scripting;
 
diff --git a/src/logic/scripting/lua/libs/libtime.cpp b/src/logic/scripting/lua/libs/libtime.cpp
index 93708dda5..988e403af 100644
--- a/src/logic/scripting/lua/libs/libtime.cpp
+++ b/src/logic/scripting/lua/libs/libtime.cpp
@@ -1,16 +1,18 @@
-#include "engine.hpp"
-#include "window/Window.hpp"
+#include "engine/Engine.hpp"
 #include "api_lua.hpp"
 
-static int l_time_uptime(lua::State* L) {
-    return lua::pushnumber(L, Window::time());
+using namespace scripting;
+
+static int l_uptime(lua::State* L) {
+    return lua::pushnumber(L, engine->getTime().getTime());
 }
 
-static int l_time_delta(lua::State* L) {
-    return lua::pushnumber(L, scripting::engine->getDelta());
+static int l_delta(lua::State* L) {
+    return lua::pushnumber(L, engine->getTime().getDelta());
 }
 
 const luaL_Reg timelib[] = {
-    {"uptime", lua::wrap<l_time_uptime>},
-    {"delta", lua::wrap<l_time_delta>},
-    {NULL, NULL}};
+    {"uptime", lua::wrap<l_uptime>},
+    {"delta", lua::wrap<l_delta>},
+    {NULL, NULL}
+};
diff --git a/src/logic/scripting/lua/libs/libworld.cpp b/src/logic/scripting/lua/libs/libworld.cpp
index 99d2fec3b..1acc1ad7c 100644
--- a/src/logic/scripting/lua/libs/libworld.cpp
+++ b/src/logic/scripting/lua/libs/libworld.cpp
@@ -7,14 +7,17 @@
 #include "coders/compression.hpp"
 #include "coders/gzip.hpp"
 #include "coders/json.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "files/engine_paths.hpp"
 #include "files/files.hpp"
 #include "lighting/Lighting.hpp"
 #include "voxels/Chunk.hpp"
 #include "voxels/Chunks.hpp"
+#include "voxels/GlobalChunks.hpp"
 #include "world/Level.hpp"
 #include "world/World.hpp"
+#include "logic/LevelController.hpp"
+#include "logic/ChunksController.hpp"
 
 using namespace scripting;
 namespace fs = std::filesystem;
@@ -31,8 +34,8 @@ static int l_is_open(lua::State* L) {
 }
 
 static int l_get_list(lua::State* L) {
-    auto paths = engine->getPaths();
-    auto worlds = paths->scanForWorlds();
+    const auto& paths = engine->getPaths();
+    auto worlds = paths.scanForWorlds();
 
     lua::createtable(L, worlds.size(), 0);
     for (size_t i = 0; i < worlds.size(); i++) {
@@ -101,7 +104,7 @@ static int l_get_seed(lua::State* L) {
 
 static int l_exists(lua::State* L) {
     auto name = lua::require_string(L, 1);
-    auto worldsDir = engine->getPaths()->getWorldFolderByName(name);
+    auto worldsDir = engine->getPaths().getWorldFolderByName(name);
     return lua::pushboolean(L, fs::is_directory(worldsDir));
 }
 
@@ -179,7 +182,7 @@ static int l_set_chunk_data(lua::State* L) {
         is_compressed = lua::toboolean(L, 4);
     }
     auto chunk = level->chunks->getChunk(x, y);
-    if(chunk== nullptr){
+    if (chunk == nullptr) {
         return 0;
     }
     if (is_compressed) {
@@ -202,35 +205,49 @@ static int l_set_chunk_data(lua::State* L) {
     } else {
         chunk->decode(buffer->data().data());
     }
+
+    auto chunksController = controller->getChunksController();
+    if (chunksController == nullptr) {
+        return 1;
+    }
+
+    Lighting& lighting = *chunksController->lighting;
     chunk->updateHeights();
-    level->lighting->buildSkyLight(x, y);
+    lighting.buildSkyLight(x, y);
     chunk->flags.modified = true;
-    level->lighting->onChunkLoaded(x, y, true);
+    lighting.onChunkLoaded(x, y, true);
 
     chunk = level->chunks->getChunk(x - 1, y);
     if (chunk != nullptr) {
         chunk->flags.modified = true;
-        level->lighting->onChunkLoaded(x - 1, y, true);
+        lighting.onChunkLoaded(x - 1, y, true);
     }
     chunk = level->chunks->getChunk(x + 1, y);
     if (chunk != nullptr) {
         chunk->flags.modified = true;
-        level->lighting->onChunkLoaded(x + 1, y, true);
+        lighting.onChunkLoaded(x + 1, y, true);
     }
     chunk = level->chunks->getChunk(x, y - 1);
     if (chunk != nullptr) {
         chunk->flags.modified = true;
-        level->lighting->onChunkLoaded(x, y - 1, true);
+        lighting.onChunkLoaded(x, y - 1, true);
     }
     chunk = level->chunks->getChunk(x, y + 1);
     if (chunk != nullptr) {
         chunk->flags.modified = true;
-        level->lighting->onChunkLoaded(x, y + 1, true);
+        lighting.onChunkLoaded(x, y + 1, true);
     }
 
     return 1;
 }
 
+static int l_count_chunks(lua::State* L) {
+    if (level == nullptr) {
+        return 0;
+    }
+    return lua::pushinteger(L, level->chunks->size());
+}
+
 const luaL_Reg worldlib[] = {
     {"is_open", lua::wrap<l_is_open>},
     {"get_list", lua::wrap<l_get_list>},
@@ -246,5 +263,6 @@ const luaL_Reg worldlib[] = {
     {"exists", lua::wrap<l_exists>},
     {"get_chunk_data", lua::wrap<l_get_chunk_data>},
     {"set_chunk_data", lua::wrap<l_set_chunk_data>},
+    {"count_chunks", lua::wrap<l_count_chunks>},
     {NULL, NULL}
 };
diff --git a/src/logic/scripting/lua/lua_commons.hpp b/src/logic/scripting/lua/lua_commons.hpp
index ff94ade7c..f272dbf03 100644
--- a/src/logic/scripting/lua/lua_commons.hpp
+++ b/src/logic/scripting/lua/lua_commons.hpp
@@ -3,9 +3,8 @@
 #include "delegates.hpp"
 #include "logic/scripting/scripting.hpp"
 
-#ifdef __linux__
+#if (defined __linux__) || (defined __MINGW32__)
 #include <luajit-2.1/luaconf.h>
-
 #include <luajit-2.1/lua.hpp>
 #else
 #include <lua.hpp>
diff --git a/src/logic/scripting/lua/lua_engine.cpp b/src/logic/scripting/lua/lua_engine.cpp
index 8f4777108..39cb1b8f0 100644
--- a/src/logic/scripting/lua/lua_engine.cpp
+++ b/src/logic/scripting/lua/lua_engine.cpp
@@ -9,6 +9,7 @@
 #include "util/stringutil.hpp"
 #include "libs/api_lua.hpp"
 #include "lua_custom_types.hpp"
+#include "engine/Engine.hpp"
 
 static debug::Logger logger("lua-state");
 static lua::State* main_thread = nullptr;
@@ -42,7 +43,7 @@ static void create_libs(State* L, StateType stateType) {
     openlib(L, "base64", base64lib);
     openlib(L, "bjson", bjsonlib);
     openlib(L, "block", blocklib);
-    openlib(L, "core", corelib);
+    openlib(L, "byteutil", byteutillib);
     openlib(L, "file", filelib);
     openlib(L, "generation", generationlib);
     openlib(L, "item", itemlib);
@@ -50,22 +51,28 @@ static void create_libs(State* L, StateType stateType) {
     openlib(L, "mat4", mat4lib);
     openlib(L, "pack", packlib);
     openlib(L, "quat", quatlib);
-    openlib(L, "time", timelib);
     openlib(L, "toml", tomllib);
     openlib(L, "utf8", utf8lib);
     openlib(L, "vec2", vec2lib);
     openlib(L, "vec3", vec3lib);
     openlib(L, "vec4", vec4lib);
 
-    if (stateType == StateType::BASE) {
+    if (stateType == StateType::SCRIPT) {
+        openlib(L, "app", applib);
+    } else if (stateType == StateType::BASE) {
+        openlib(L, "__vc_app", applib);
+    }
+    if (stateType == StateType::BASE || stateType == StateType::SCRIPT) {
+        openlib(L, "audio", audiolib);
+        openlib(L, "console", consolelib);
+        openlib(L, "core", corelib);
         openlib(L, "gui", guilib);
         openlib(L, "input", inputlib);
         openlib(L, "inventory", inventorylib);
-        openlib(L, "world", worldlib);
-        openlib(L, "audio", audiolib);
-        openlib(L, "console", consolelib);
-        openlib(L, "player", playerlib);
         openlib(L, "network", networklib);
+        openlib(L, "player", playerlib);
+        openlib(L, "time", timelib);
+        openlib(L, "world", worldlib);
 
         openlib(L, "entities", entitylib);
         openlib(L, "cameras", cameralib);
@@ -110,11 +117,15 @@ void lua::init_state(State* L, StateType stateType) {
     newusertype<LuaVoxelFragment>(L);
 }
 
-void lua::initialize(const EnginePaths& paths) {
+void lua::initialize(const EnginePaths& paths, const CoreParameters& params) {
     logger.info() << LUA_VERSION;
     logger.info() << LUAJIT_VERSION;
 
-    main_thread = create_state(paths, StateType::BASE);
+    main_thread = create_state(
+        paths, params.headless ? StateType::SCRIPT : StateType::BASE
+    );
+    lua::pushstring(main_thread, params.scriptFile.stem().u8string());
+    lua::setglobal(main_thread, "__VC_SCRIPT_NAME");
 }
 
 void lua::finalize() {
@@ -127,10 +138,13 @@ bool lua::emit_event(
     getglobal(L, "events");
     getfield(L, "emit");
     pushstring(L, name);
-    call_nothrow(L, args(L) + 1);
-    bool result = toboolean(L, -1);
-    pop(L, 2);
-    return result;
+    if (call_nothrow(L, args(L) + 1)) {
+        bool result = toboolean(L, -1);
+        pop(L, 2);
+        return result;
+    }
+    pop(L, 1);
+    return false;
 }
 
 State* lua::get_main_state() {
diff --git a/src/logic/scripting/lua/lua_engine.hpp b/src/logic/scripting/lua/lua_engine.hpp
index dd1e794d4..aee930352 100644
--- a/src/logic/scripting/lua/lua_engine.hpp
+++ b/src/logic/scripting/lua/lua_engine.hpp
@@ -8,14 +8,16 @@
 #include "lua_util.hpp"
 
 class EnginePaths;
+struct CoreParameters;
 
 namespace lua {
     enum class StateType {
         BASE,
+        SCRIPT,
         GENERATOR,
     };
 
-    void initialize(const EnginePaths& paths);
+    void initialize(const EnginePaths& paths, const CoreParameters& params);
     void finalize();
 
     bool emit_event(
diff --git a/src/logic/scripting/lua/lua_util.cpp b/src/logic/scripting/lua/lua_util.cpp
index 091418cd4..8c3adaeab 100644
--- a/src/logic/scripting/lua/lua_util.cpp
+++ b/src/logic/scripting/lua/lua_util.cpp
@@ -219,7 +219,7 @@ void lua::dump_stack(State* L) {
 static std::shared_ptr<std::string> create_lambda_handler(State* L) {
     auto ptr = reinterpret_cast<ptrdiff_t>(topointer(L, -1));
     auto name = util::mangleid(ptr);
-    getglobal(L, LAMBDAS_TABLE);
+    requireglobal(L, LAMBDAS_TABLE);
     pushvalue(L, -2);
     setfield(L, name);
     pop(L, 2);
@@ -227,7 +227,7 @@ static std::shared_ptr<std::string> create_lambda_handler(State* L) {
     return std::shared_ptr<std::string>(
         new std::string(name),
         [=](std::string* name) {
-            getglobal(L, LAMBDAS_TABLE);
+            requireglobal(L, LAMBDAS_TABLE);
             pushnil(L);
             setfield(L, *name);
             pop(L);
@@ -239,26 +239,50 @@ static std::shared_ptr<std::string> create_lambda_handler(State* L) {
 runnable lua::create_runnable(State* L) {
     auto funcptr = create_lambda_handler(L);
     return [=]() {
-        getglobal(L, LAMBDAS_TABLE);
-        getfield(L, *funcptr);
-        call_nothrow(L, 0);
+        if (!get_from(L, LAMBDAS_TABLE, *funcptr, false))
+            return;
+        call_nothrow(L, 0, 0);
         pop(L);
     };
 }
 
+KeyCallback lua::create_simple_handler(State* L) {
+    auto funcptr = create_lambda_handler(L);
+    return [=]() -> bool {
+        if (!get_from(L, LAMBDAS_TABLE, *funcptr, false))
+            return false;
+        int top = gettop(L) - 1;
+        if (call_nothrow(L, 0)) {
+            int nres = gettop(L) - top;
+            if (nres) {
+                bool result = toboolean(L, -1);
+                pop(L, 1 + nres);
+                return result;
+            }
+        }
+        pop(L);
+        return false;
+    };
+}
+
 scripting::common_func lua::create_lambda(State* L) {
     auto funcptr = create_lambda_handler(L);
     return [=](const std::vector<dv::value>& args) -> dv::value {
-        getglobal(L, LAMBDAS_TABLE);
-        getfield(L, *funcptr);
+        int top = gettop(L) + 1;
+        if (!get_from(L, LAMBDAS_TABLE, *funcptr, false))
+            return nullptr;
         for (const auto& arg : args) {
             pushvalue(L, arg);
         }
         if (call(L, args.size(), 1)) {
-            auto result = tovalue(L, -1);
-            pop(L);
-            return result;
+            int nres = gettop(L) - top;
+            if (nres) {
+                auto result = tovalue(L, -1);
+                pop(L, 1 + nres);
+                return result;
+            }
         }
+        pop(L);
         return nullptr;
     };
 }
@@ -266,16 +290,21 @@ scripting::common_func lua::create_lambda(State* L) {
 scripting::common_func lua::create_lambda_nothrow(State* L) {
     auto funcptr = create_lambda_handler(L);
     return [=](const std::vector<dv::value>& args) -> dv::value {
-        getglobal(L, LAMBDAS_TABLE);
-        getfield(L, *funcptr);
+        int top = gettop(L) - 1;
+        if (!get_from(L, LAMBDAS_TABLE, *funcptr, false))
+            return nullptr;
         for (const auto& arg : args) {
             pushvalue(L, arg);
         }
         if (call_nothrow(L, args.size(), 1)) {
-            auto result = tovalue(L, -1);
-            pop(L);
-            return result;
+            int nres = gettop(L) - top;
+            if (nres) {
+                auto result = tovalue(L, -1);
+                pop(L, 1 + nres);
+                return result;
+            }
         }
+        pop(L);
         return nullptr;
     };
 }
diff --git a/src/logic/scripting/lua/lua_util.hpp b/src/logic/scripting/lua/lua_util.hpp
index f9da3b219..9f3ac4146 100644
--- a/src/logic/scripting/lua/lua_util.hpp
+++ b/src/logic/scripting/lua/lua_util.hpp
@@ -539,10 +539,12 @@ namespace lua {
             if (getfield(L, name)) {
                 return 1;
             } else if (required) {
+                pop(L);
                 throw std::runtime_error(
                     "table " + tableName + " has no member " + name
                 );
             }
+            pop(L);
             return 0;
         } else {
             throw std::runtime_error("table " + tableName + " not found");
@@ -574,6 +576,7 @@ namespace lua {
     }
 
     runnable create_runnable(lua::State*);
+    KeyCallback create_simple_handler(lua::State*);
     scripting::common_func create_lambda(lua::State*);
     scripting::common_func create_lambda_nothrow(lua::State*);
 
@@ -720,4 +723,15 @@ namespace lua {
             }
         }
     }
+
+    inline std::vector<ubyte> require_bytearray(lua::State* L, int idx) {
+        if (auto* bytearray = lua::touserdata<LuaBytearray>(L, idx)) {
+            return bytearray->data();
+        } else if (lua::istable(L, idx)) {
+            std::vector<ubyte> bytes;
+            read_bytes_from_table(L, idx, bytes);
+            return bytes;
+        }
+        throw std::runtime_error("bytearray expected");
+    }
 }
diff --git a/src/logic/scripting/lua/usertypes/lua_type_heightmap.cpp b/src/logic/scripting/lua/usertypes/lua_type_heightmap.cpp
index a59986ac8..0db89634e 100644
--- a/src/logic/scripting/lua/usertypes/lua_type_heightmap.cpp
+++ b/src/logic/scripting/lua/usertypes/lua_type_heightmap.cpp
@@ -12,7 +12,7 @@
 #include "files/util.hpp"
 #include "graphics/core/ImageData.hpp"
 #include "maths/Heightmap.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "../lua_util.hpp"
 
 using namespace lua;
@@ -50,9 +50,9 @@ const float* LuaHeightmap::getValues() const {
 }
 
 static int l_dump(lua::State* L) {
-    auto paths = scripting::engine->getPaths();
+    const auto& paths = scripting::engine->getPaths();
     if (auto heightmap = touserdata<LuaHeightmap>(L, 1)) {
-        auto file = paths->resolve(require_string(L, 2));
+        auto file = paths.resolve(require_string(L, 2));
         uint w = heightmap->getWidth();
         uint h = heightmap->getHeight();
         ImageData image(ImageFormat::rgb888, w, h);
diff --git a/src/logic/scripting/scripting.cpp b/src/logic/scripting/scripting.cpp
index a8b5f070d..b8f00d3f8 100644
--- a/src/logic/scripting/scripting.cpp
+++ b/src/logic/scripting/scripting.cpp
@@ -7,7 +7,7 @@
 #include "content/Content.hpp"
 #include "content/ContentPack.hpp"
 #include "debug/Logger.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "files/engine_paths.hpp"
 #include "files/files.hpp"
 #include "frontend/UiDocument.hpp"
@@ -25,6 +25,7 @@
 #include "util/timeutil.hpp"
 #include "voxels/Block.hpp"
 #include "world/Level.hpp"
+#include "interfaces/Process.hpp"
 
 using namespace scripting;
 
@@ -40,8 +41,8 @@ BlocksController* scripting::blocks = nullptr;
 LevelController* scripting::controller = nullptr;
 
 void scripting::load_script(const fs::path& name, bool throwable) {
-    auto paths = scripting::engine->getPaths();
-    fs::path file = paths->getResourcesFolder() / fs::path("scripts") / name;
+    const auto& paths = scripting::engine->getPaths();
+    fs::path file = paths.getResourcesFolder() / fs::path("scripts") / name;
     std::string src = files::read_string(file);
     auto L = lua::get_main_state();
     lua::loadbuffer(L, 0, src, "core:scripts/"+name.u8string());
@@ -65,12 +66,65 @@ int scripting::load_script(
 
 void scripting::initialize(Engine* engine) {
     scripting::engine = engine;
-    lua::initialize(*engine->getPaths());
+    lua::initialize(engine->getPaths(), engine->getCoreParameters());
 
     load_script(fs::path("stdlib.lua"), true);
     load_script(fs::path("classes.lua"), true);
 }
 
+class LuaCoroutine : public Process {
+    lua::State* L;
+    int id;
+    bool alive = true;
+public:
+    LuaCoroutine(lua::State* L, int id) : L(L), id(id) {
+    }
+
+    bool isActive() const override {
+        return alive;
+    }
+    
+    void update() override {
+        if (lua::getglobal(L, "__vc_resume_coroutine")) {
+            lua::pushinteger(L, id);
+            if (lua::call(L, 1)) {
+                alive = lua::toboolean(L, -1);
+                lua::pop(L);
+            }
+        }
+    }
+
+    void waitForEnd() override {
+        while (isActive()) {
+            update();
+        }
+    }
+    
+    void terminate() override {
+        if (lua::getglobal(L, "__vc_stop_coroutine")) {
+            lua::pushinteger(L, id);
+            lua::pop(L, lua::call(L, 1));
+        }
+    }
+};
+
+std::unique_ptr<Process> scripting::start_coroutine(
+    const std::filesystem::path& script
+) {
+    auto L = lua::get_main_state();
+    if (lua::getglobal(L, "__vc_start_coroutine")) {
+        auto source = files::read_string(script);
+        lua::loadbuffer(L, 0, source, script.filename().u8string());
+        if (lua::call(L, 1)) {
+            int id = lua::tointeger(L, -1);
+            lua::pop(L, 2);
+            return std::make_unique<LuaCoroutine>(L, id);
+        }
+        lua::pop(L);
+    }
+    return nullptr;
+}
+
 [[nodiscard]] scriptenv scripting::get_root_environment() {
     return std::make_shared<int>(0);
 }
@@ -248,9 +302,9 @@ void scripting::on_world_quit() {
 
 void scripting::cleanup() {
     auto L = lua::get_main_state();
-    lua::getglobal(L, "pack");
+    lua::requireglobal(L, "pack");
     for (auto& pack : scripting::engine->getAllContentPacks()) {
-        lua::getfield(L, "unload");
+        lua::requirefield(L, "unload");
         lua::pushstring(L, pack.id);
         lua::call_nothrow(L, 1);
     }
@@ -282,16 +336,24 @@ void scripting::random_update_block(const Block& block, const glm::ivec3& pos) {
     });
 }
 
-void scripting::on_block_placed(
-    Player* player, const Block& block, const glm::ivec3& pos
+/// TODO: replace template with index
+template<bool WorldFuncsSet::*worldfunc>
+static bool on_block_common(
+    const std::string& suffix,
+    bool blockfunc,
+    Player* player,
+    const Block& block,
+    const glm::ivec3& pos
 ) {
-    if (block.rt.funcsset.onplaced) {
-        std::string name = block.name + ".placed";
-        lua::emit_event(lua::get_main_state(), name, [pos, player](auto L) {
-            lua::pushivec_stack(L, pos);
-            lua::pushinteger(L, player ? player->getId() : -1);
-            return 4;
-        });
+    bool result = false;
+    if (blockfunc) {
+        std::string name = block.name + "." + suffix;
+        result =
+            lua::emit_event(lua::get_main_state(), name, [pos, player](auto L) {
+                lua::pushivec_stack(L, pos);
+                lua::pushinteger(L, player ? player->getId() : -1);
+                return 4;
+            });
     }
     auto args = [&](lua::State* L) {
         lua::pushinteger(L, block.rt.id);
@@ -300,92 +362,53 @@ void scripting::on_block_placed(
         return 5;
     };
     for (auto& [packid, pack] : content->getPacks()) {
-        if (pack->worldfuncsset.onblockplaced) {
+        if (pack->worldfuncsset.*worldfunc) {
             lua::emit_event(
-                lua::get_main_state(), packid + ":.blockplaced", args
+                lua::get_main_state(), packid + ":.block" + suffix, args
             );
         }
     }
+    return result;
+}
+
+void scripting::on_block_placed(
+    Player* player, const Block& block, const glm::ivec3& pos
+) {
+    on_block_common<&WorldFuncsSet::onblockplaced>(
+        "placed", block.rt.funcsset.onplaced, player, block, pos
+    );
 }
 
 void scripting::on_block_replaced(
     Player* player, const Block& block, const glm::ivec3& pos
 ) {
-    if (block.rt.funcsset.onreplaced) {
-        std::string name = block.name + ".replaced";
-        lua::emit_event(lua::get_main_state(), name, [pos, player](auto L) {
-            lua::pushivec_stack(L, pos);
-            lua::pushinteger(L, player ? player->getId() : -1);
-            return 4;
-        });
-    }
-    auto args = [&](lua::State* L) {
-        lua::pushinteger(L, block.rt.id);
-        lua::pushivec_stack(L, pos);
-        lua::pushinteger(L, player ? player->getId() : -1);
-        return 5;
-    };
-    for (auto& [packid, pack] : content->getPacks()) {
-        if (pack->worldfuncsset.onblockreplaced) {
-            lua::emit_event(
-                lua::get_main_state(), packid + ":.blockreplaced", args
-            );
-        }
-    }
+    on_block_common<&WorldFuncsSet::onblockreplaced>(
+        "replaced", block.rt.funcsset.onreplaced, player, block, pos
+    );
+}
+
+void scripting::on_block_breaking(
+    Player* player, const Block& block, const glm::ivec3& pos
+) {
+    on_block_common<&WorldFuncsSet::onblockbreaking>(
+        "breaking", block.rt.funcsset.onbreaking, player, block, pos
+    );
 }
 
 void scripting::on_block_broken(
     Player* player, const Block& block, const glm::ivec3& pos
 ) {
-    if (block.rt.funcsset.onbroken) {
-        std::string name = block.name + ".broken";
-        lua::emit_event(
-            lua::get_main_state(),
-            name,
-            [pos, player](auto L) {
-                lua::pushivec_stack(L, pos);
-                lua::pushinteger(L, player ? player->getId() : -1);
-                return 4;
-            }
-        );
-    }
-    auto args = [&](lua::State* L) {
-        lua::pushinteger(L, block.rt.id);
-        lua::pushivec_stack(L, pos);
-        lua::pushinteger(L, player ? player->getId() : -1);
-        return 5;
-    };
-    for (auto& [packid, pack] : content->getPacks()) {
-        if (pack->worldfuncsset.onblockbroken) {
-            lua::emit_event(
-                lua::get_main_state(), packid + ":.blockbroken", args
-            );
-        }
-    }
+    on_block_common<&WorldFuncsSet::onblockbroken>(
+        "broken", block.rt.funcsset.onbroken, player, block, pos
+    );
 }
 
 bool scripting::on_block_interact(
     Player* player, const Block& block, const glm::ivec3& pos
 ) {
-    std::string name = block.name + ".interact";
-    return lua::emit_event(lua::get_main_state(), name, [pos, player](auto L) {
-        lua::pushivec_stack(L, pos);
-        lua::pushinteger(L, player->getId());
-        return 4;
-    });
-    auto args = [&](lua::State* L) {
-        lua::pushinteger(L, block.rt.id);
-        lua::pushivec_stack(L, pos);
-        lua::pushinteger(L, player ? player->getId() : -1);
-        return 5;
-    };
-    for (auto& [packid, pack] : content->getPacks()) {
-        if (pack->worldfuncsset.onblockinteract) {
-            lua::emit_event(
-                lua::get_main_state(), packid + ":.blockinteract", args
-            );
-        }
-    }
+    return on_block_common<&WorldFuncsSet::onblockinteract>(
+        "interact", block.rt.funcsset.oninteract, player, block, pos
+    );
 }
 
 void scripting::on_player_tick(Player* player, int tps) {
@@ -544,7 +567,7 @@ static void process_entity_callback(
 static void process_entity_callback(
     const Entity& entity,
     const std::string& name,
-    bool entity_funcs_set::*flag,
+    bool EntityFuncsSet::*flag,
     std::function<int(lua::State*)> args
 ) {
     const auto& script = entity.getScripting();
@@ -557,7 +580,7 @@ static void process_entity_callback(
 
 void scripting::on_entity_despawn(const Entity& entity) {
     process_entity_callback(
-        entity, "on_despawn", &entity_funcs_set::on_despawn, nullptr
+        entity, "on_despawn", &EntityFuncsSet::on_despawn, nullptr
     );
     auto L = lua::get_main_state();
     lua::get_from(L, "stdcomp", "remove_Entity", true);
@@ -569,20 +592,20 @@ void scripting::on_entity_grounded(const Entity& entity, float force) {
     process_entity_callback(
         entity,
         "on_grounded",
-        &entity_funcs_set::on_grounded,
+        &EntityFuncsSet::on_grounded,
         [force](auto L) { return lua::pushnumber(L, force); }
     );
 }
 
 void scripting::on_entity_fall(const Entity& entity) {
     process_entity_callback(
-        entity, "on_fall", &entity_funcs_set::on_fall, nullptr
+        entity, "on_fall", &EntityFuncsSet::on_fall, nullptr
     );
 }
 
 void scripting::on_entity_save(const Entity& entity) {
     process_entity_callback(
-        entity, "on_save", &entity_funcs_set::on_save, nullptr
+        entity, "on_save", &EntityFuncsSet::on_save, nullptr
     );
 }
 
@@ -592,7 +615,7 @@ void scripting::on_sensor_enter(
     process_entity_callback(
         entity,
         "on_sensor_enter",
-        &entity_funcs_set::on_sensor_enter,
+        &EntityFuncsSet::on_sensor_enter,
         [index, oid](auto L) {
             lua::pushinteger(L, index);
             lua::pushinteger(L, oid);
@@ -607,7 +630,7 @@ void scripting::on_sensor_exit(
     process_entity_callback(
         entity,
         "on_sensor_exit",
-        &entity_funcs_set::on_sensor_exit,
+        &EntityFuncsSet::on_sensor_exit,
         [index, oid](auto L) {
             lua::pushinteger(L, index);
             lua::pushinteger(L, oid);
@@ -620,7 +643,7 @@ void scripting::on_aim_on(const Entity& entity, Player* player) {
     process_entity_callback(
         entity,
         "on_aim_on",
-        &entity_funcs_set::on_aim_on,
+        &EntityFuncsSet::on_aim_on,
         [player](auto L) { return lua::pushinteger(L, player->getId()); }
     );
 }
@@ -629,7 +652,7 @@ void scripting::on_aim_off(const Entity& entity, Player* player) {
     process_entity_callback(
         entity,
         "on_aim_off",
-        &entity_funcs_set::on_aim_off,
+        &EntityFuncsSet::on_aim_off,
         [player](auto L) { return lua::pushinteger(L, player->getId()); }
     );
 }
@@ -640,7 +663,7 @@ void scripting::on_attacked(
     process_entity_callback(
         entity,
         "on_attacked",
-        &entity_funcs_set::on_attacked,
+        &EntityFuncsSet::on_attacked,
         [player, attacker](auto L) {
             lua::pushinteger(L, attacker);
             lua::pushinteger(L, player->getId());
@@ -653,7 +676,7 @@ void scripting::on_entity_used(const Entity& entity, Player* player) {
     process_entity_callback(
         entity,
         "on_used",
-        &entity_funcs_set::on_used,
+        &EntityFuncsSet::on_used,
         [player](auto L) { return lua::pushinteger(L, player->getId()); }
     );
 }
@@ -741,7 +764,7 @@ void scripting::load_content_script(
     const std::string& prefix,
     const fs::path& file,
     const std::string& fileName,
-    block_funcs_set& funcsset
+    BlockFuncsSet& funcsset
 ) {
     int env = *senv;
     lua::pop(lua::get_main_state(), load_script(env, "block", file, fileName));
@@ -749,6 +772,8 @@ void scripting::load_content_script(
     funcsset.update = register_event(env, "on_update", prefix + ".update");
     funcsset.randupdate =
         register_event(env, "on_random_update", prefix + ".randupdate");
+    funcsset.onbreaking =
+        register_event(env, "on_breaking", prefix + ".breaking");
     funcsset.onbroken = register_event(env, "on_broken", prefix + ".broken");
     funcsset.onplaced = register_event(env, "on_placed", prefix + ".placed");
     funcsset.onreplaced =
@@ -764,7 +789,7 @@ void scripting::load_content_script(
     const std::string& prefix,
     const fs::path& file,
     const std::string& fileName,
-    item_funcs_set& funcsset
+    ItemFuncsSet& funcsset
 ) {
     int env = *senv;
     lua::pop(lua::get_main_state(), load_script(env, "item", file, fileName));
@@ -791,7 +816,7 @@ void scripting::load_world_script(
     const std::string& prefix,
     const fs::path& file,
     const std::string& fileName,
-    world_funcs_set& funcsset
+    WorldFuncsSet& funcsset
 ) {
     int env = *senv;
     lua::pop(lua::get_main_state(), load_script(env, "world", file, fileName));
@@ -802,6 +827,8 @@ void scripting::load_world_script(
     register_event(env, "on_world_quit", prefix + ":.worldquit");
     funcsset.onblockplaced =
         register_event(env, "on_block_placed", prefix + ":.blockplaced");
+    funcsset.onblockbreaking =
+        register_event(env, "on_block_breaking", prefix + ":.blockbreaking");
     funcsset.onblockbroken =
         register_event(env, "on_block_broken", prefix + ":.blockbroken");
     funcsset.onblockreplaced =
diff --git a/src/logic/scripting/scripting.hpp b/src/logic/scripting/scripting.hpp
index 0ab3c0351..fb552f669 100644
--- a/src/logic/scripting/scripting.hpp
+++ b/src/logic/scripting/scripting.hpp
@@ -11,8 +11,6 @@
 #include "typedefs.hpp"
 #include "scripting_functional.hpp"
 
-namespace fs = std::filesystem;
-
 class Engine;
 class Content;
 struct ContentPack;
@@ -23,9 +21,9 @@ class Player;
 struct ItemDef;
 class Inventory;
 class UiDocument;
-struct block_funcs_set;
-struct item_funcs_set;
-struct world_funcs_set;
+struct BlockFuncsSet;
+struct ItemFuncsSet;
+struct WorldFuncsSet;
 struct UserComponent;
 struct uidocscript;
 class BlocksController;
@@ -34,6 +32,7 @@ class Entity;
 struct EntityDef;
 class GeneratorScript;
 struct GeneratorDef;
+class Process;
 
 namespace scripting {
     extern Engine* engine;
@@ -60,6 +59,10 @@ namespace scripting {
 
     void process_post_runnables();
 
+    std::unique_ptr<Process> start_coroutine(
+        const std::filesystem::path& script
+    );
+
     void on_world_load(LevelController* controller);
     void on_world_tick();
     void on_world_save();
@@ -74,6 +77,9 @@ namespace scripting {
     void on_block_replaced(
         Player* player, const Block& block, const glm::ivec3& pos
     );
+    void on_block_breaking(
+        Player* player, const Block& block, const glm::ivec3& pos
+    );
     void on_block_broken(
         Player* player, const Block& block, const glm::ivec3& pos
     );
@@ -136,9 +142,9 @@ namespace scripting {
     void load_content_script(
         const scriptenv& env,
         const std::string& prefix,
-        const fs::path& file,
+        const std::filesystem::path& file,
         const std::string& fileName,
-        block_funcs_set& funcsset
+        BlockFuncsSet& funcsset
     );
 
     /// @brief Load script associated with an Item
@@ -150,9 +156,9 @@ namespace scripting {
     void load_content_script(
         const scriptenv& env,
         const std::string& prefix,
-        const fs::path& file,
+        const std::filesystem::path& file,
         const std::string& fileName,
-        item_funcs_set& funcsset
+        ItemFuncsSet& funcsset
     );
 
     /// @brief Load component script
@@ -161,13 +167,13 @@ namespace scripting {
     /// @param fileName script file path using the engine format
     void load_entity_component(
         const std::string& name,
-        const fs::path& file,
+        const std::filesystem::path& file,
         const std::string& fileName
     );
 
     std::unique_ptr<GeneratorScript> load_generator(
         const GeneratorDef& def,
-        const fs::path& file,
+        const std::filesystem::path& file,
         const std::string& dirPath
     );
 
@@ -179,9 +185,9 @@ namespace scripting {
     void load_world_script(
         const scriptenv& env,
         const std::string& packid,
-        const fs::path& file,
+        const std::filesystem::path& file,
         const std::string& fileName,
-        world_funcs_set& funcsset
+        WorldFuncsSet& funcsset
     );
 
     /// @brief Load script associated with an UiDocument
@@ -193,7 +199,7 @@ namespace scripting {
     void load_layout_script(
         const scriptenv& env,
         const std::string& prefix,
-        const fs::path& file,
+        const std::filesystem::path& file,
         const std::string& fileName,
         uidocscript& script
     );
diff --git a/src/logic/scripting/scripting_hud.cpp b/src/logic/scripting/scripting_hud.cpp
index 355c53350..c13a00105 100644
--- a/src/logic/scripting/scripting_hud.cpp
+++ b/src/logic/scripting/scripting_hud.cpp
@@ -1,9 +1,10 @@
 #include "scripting_hud.hpp"
 
 #include "debug/Logger.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "files/files.hpp"
 #include "frontend/hud.hpp"
+#include "frontend/UiDocument.hpp"
 #include "graphics/render/WorldRenderer.hpp"
 #include "objects/Player.hpp"
 #include "lua/libs/api_lua.hpp"
@@ -18,7 +19,7 @@ Hud* scripting::hud = nullptr;
 WorldRenderer* scripting::renderer = nullptr;
 
 static void load_script(const std::string& name) {
-    auto file = engine->getPaths()->getResourcesFolder() / "scripts" / name;
+    auto file = engine->getPaths().getResourcesFolder() / "scripts" / name;
     std::string src = files::read_string(file);
     logger.info() << "loading script " << file.u8string();
 
@@ -93,3 +94,15 @@ void scripting::load_hud_script(
     register_event(env, "on_hud_render", packid + ":.hudrender");
     register_event(env, "on_hud_close", packid + ":.hudclose");
 }
+
+gui::PageLoaderFunc scripting::create_page_loader() {
+    auto L = lua::get_main_state();
+    if (lua::getglobal(L, "__vc_page_loader")) {
+        auto func = lua::create_lambda(L);
+        return [func](const std::string& name) -> std::shared_ptr<gui::UINode> {
+            auto docname = func({name}).asString();
+            return engine->getAssets()->require<UiDocument>(docname).getRoot();
+        };
+    }
+    return nullptr;
+}
diff --git a/src/logic/scripting/scripting_hud.hpp b/src/logic/scripting/scripting_hud.hpp
index 7eed738cb..f6829976f 100644
--- a/src/logic/scripting/scripting_hud.hpp
+++ b/src/logic/scripting/scripting_hud.hpp
@@ -1,6 +1,8 @@
 #pragma once
 
 #include <filesystem>
+#include <functional>
+#include <memory>
 #include <string>
 
 #include "typedefs.hpp"
@@ -10,6 +12,11 @@ namespace fs = std::filesystem;
 class Hud;
 class WorldRenderer;
 
+namespace gui {
+    class UINode;
+    using PageLoaderFunc = std::function<std::shared_ptr<UINode>(const std::string&)>;
+}
+
 namespace scripting {
     extern Hud *hud;
     extern WorldRenderer* renderer;
@@ -29,4 +36,6 @@ namespace scripting {
         const fs::path& file,
         const std::string& fileName
     );
+
+    gui::PageLoaderFunc create_page_loader(); 
 }
diff --git a/src/logic/scripting/scripting_world_generation.cpp b/src/logic/scripting/scripting_world_generation.cpp
index 0973671ba..1169b64f2 100644
--- a/src/logic/scripting/scripting_world_generation.cpp
+++ b/src/logic/scripting/scripting_world_generation.cpp
@@ -14,7 +14,7 @@
 #include "world/generator/GeneratorDef.hpp"
 #include "util/timeutil.hpp"
 #include "files/files.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "debug/Logger.hpp"
 
 using namespace lua;
@@ -255,7 +255,7 @@ std::unique_ptr<GeneratorScript> scripting::load_generator(
     const fs::path& file,
     const std::string& dirPath
 ) {
-    auto L = create_state(*engine->getPaths(), StateType::GENERATOR);
+    auto L = create_state(engine->getPaths(), StateType::GENERATOR);
 
     return std::make_unique<LuaGeneratorScript>(L, def, file, dirPath);
 }
diff --git a/src/main.cpp b/src/main.cpp
new file mode 100644
index 000000000..b36232587
--- /dev/null
+++ b/src/main.cpp
@@ -0,0 +1,37 @@
+#include "engine/Engine.hpp"
+#include "util/platform.hpp"
+#include "util/command_line.hpp"
+#include "debug/Logger.hpp"
+
+#include <iostream>
+#include <stdexcept>
+
+static debug::Logger logger("main");
+
+int main(int argc, char** argv) {
+    CoreParameters coreParameters;
+    try {
+        if (!parse_cmdline(argc, argv, coreParameters)) {
+            return EXIT_SUCCESS;
+        }
+    } catch (const std::runtime_error& err) {
+        std::cerr << err.what() << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    debug::Logger::init(coreParameters.userFolder.string()+"/latest.log");
+    platform::configure_encoding();
+    try {
+        Engine(std::move(coreParameters)).run();
+    } catch (const initialize_error& err) {
+        logger.error() << "could not to initialize engine\n" << err.what();
+    }
+#if defined(NDEBUG) and defined(_WIN32)
+    catch (const std::exception& err) {
+        logger.error() << "uncaught exception: " << err.what();
+        debug::Logger::flush();
+        throw;
+    }
+#endif
+    return EXIT_SUCCESS;
+}
diff --git a/src/maths/voxmaths.hpp b/src/maths/voxmaths.hpp
index 07b42e221..feeb9c8f3 100644
--- a/src/maths/voxmaths.hpp
+++ b/src/maths/voxmaths.hpp
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "typedefs.hpp"
-
 inline constexpr int floordiv(int a, int b) {
     if (a < 0 && a % b) {
         return (a / b) - 1;
@@ -9,6 +7,23 @@ inline constexpr int floordiv(int a, int b) {
     return a / b;
 }
 
+inline constexpr bool is_pot(int a) {
+    return (a > 0) && ((a & (a - 1)) == 0);
+}
+
+inline constexpr unsigned floorlog2(unsigned x) {
+    return x == 1 ? 0 : 1 + floorlog2(x >> 1);
+}
+
+template<int b>
+inline constexpr int floordiv(int a) {
+    if constexpr (is_pot(b)) {
+        return a >> floorlog2(b);
+    } else {
+        return floordiv(a, b);
+    }
+}
+
 inline constexpr int ceildiv(int a, int b) {
     if (a > 0 && a % b) {
         return a / b + 1;
diff --git a/src/network/Network.cpp b/src/network/Network.cpp
index 57fcab40b..7a99b0c54 100644
--- a/src/network/Network.cpp
+++ b/src/network/Network.cpp
@@ -42,12 +42,18 @@ static size_t write_callback(
     return size * nmemb;
 }
 
+enum class RequestType {
+    GET, POST
+};
+
 struct Request {
+    RequestType type;
     std::string url;
     OnResponse onResponse;
     OnReject onReject;
     long maxSize;
     bool followLocation = false;
+    std::string data;
 };
 
 class CurlRequests : public Requests {
@@ -73,22 +79,33 @@ class CurlRequests : public Requests {
         curl_easy_cleanup(curl);
         curl_multi_cleanup(multiHandle);
     }
-
     void get(
         const std::string& url,
         OnResponse onResponse,
         OnReject onReject,
         long maxSize
     ) override {
-        Request request {url, onResponse, onReject, maxSize};
-        if (url.empty()) {
-            processRequest(request);
-        } else {
-            requests.push(request);
-        }
+        Request request {RequestType::GET, url, onResponse, onReject, maxSize};
+        processRequest(std::move(request));
+    }
+
+    void post(
+        const std::string& url,
+        const std::string& data,
+        OnResponse onResponse,
+        OnReject onReject=nullptr,
+        long maxSize=0
+    ) override {
+        Request request {RequestType::POST, url, onResponse, onReject, maxSize};
+        request.data = data;
+        processRequest(std::move(request));
     }
 
-    void processRequest(const Request& request) {
+    void processRequest(Request request) {
+        if (!url.empty()) {
+            requests.push(request);
+            return;
+        }
         onResponse = request.onResponse;
         onReject = request.onReject;
         url = request.url;
@@ -96,9 +113,25 @@ class CurlRequests : public Requests {
         buffer.clear();
 
         curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
+        curl_easy_setopt(curl, CURLOPT_POST, request.type == RequestType::POST);
+        
+        curl_slist* hs = NULL;
+
+        switch (request.type) {
+            case RequestType::GET:
+                break;
+            case RequestType::POST: 
+                hs = curl_slist_append(hs, "Content-Type: application/json");
+                curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, request.data.length());
+                curl_easy_setopt(curl, CURLOPT_COPYPOSTFIELDS, request.data.c_str());
+                break;
+            default:
+                throw std::runtime_error("not implemented");
+        }
+        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, hs);
+        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, request.followLocation);
         curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
         curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buffer);
-        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, request.followLocation);
         curl_easy_setopt(curl, CURLOPT_USERAGENT, "curl/7.81.0");
         if (request.maxSize == 0) {
             curl_easy_setopt(
@@ -164,7 +197,7 @@ class CurlRequests : public Requests {
         if (url.empty() && !requests.empty()) {
             auto request = std::move(requests.front());
             requests.pop();
-            processRequest(request);
+            processRequest(std::move(request));
         }
     }
 
@@ -562,6 +595,16 @@ void Network::get(
     requests->get(url, onResponse, onReject, maxSize);
 }
 
+void Network::post(
+    const std::string& url,
+    const std::string& fieldsData,
+    OnResponse onResponse,
+    OnReject onReject,
+    long maxSize
+) {
+    requests->post(url, fieldsData, onResponse, onReject, maxSize);
+}
+
 Connection* Network::getConnection(u64id_t id) {
     std::lock_guard lock(connectionsMutex);
 
diff --git a/src/network/Network.hpp b/src/network/Network.hpp
index c6170f39e..0cc0803c3 100644
--- a/src/network/Network.hpp
+++ b/src/network/Network.hpp
@@ -23,6 +23,15 @@ namespace network {
             OnReject onReject=nullptr,
             long maxSize=0
         ) = 0;
+
+        virtual void post(
+            const std::string& url,
+            const std::string& data,
+            OnResponse onResponse,
+            OnReject onReject=nullptr,
+            long maxSize=0
+        ) = 0;
+
         virtual size_t getTotalUpload() const = 0;
         virtual size_t getTotalDownload() const = 0;
 
@@ -84,6 +93,14 @@ namespace network {
             long maxSize=0
         );
 
+        void post(
+            const std::string& url,
+            const std::string& fieldsData,
+            OnResponse onResponse,
+            OnReject onReject = nullptr,
+            long maxSize=0
+        );
+
         [[nodiscard]] Connection* getConnection(u64id_t id);
         [[nodiscard]] TcpServer* getServer(u64id_t id) const;
 
diff --git a/src/objects/Entities.cpp b/src/objects/Entities.cpp
index 614adf417..07b765853 100644
--- a/src/objects/Entities.cpp
+++ b/src/objects/Entities.cpp
@@ -7,7 +7,7 @@
 #include "content/Content.hpp"
 #include "data/dv_util.hpp"
 #include "debug/Logger.hpp"
-#include "engine.hpp"
+#include "engine/Engine.hpp"
 #include "graphics/core/DrawContext.hpp"
 #include "graphics/core/LineBatch.hpp"
 #include "graphics/commons/Model.hpp"
@@ -59,7 +59,7 @@ void Entity::setRig(const rigging::SkeletonConfig* rigConfig) {
     );
 }
 
-Entities::Entities(Level* level)
+Entities::Entities(Level& level)
     : level(level), sensorsTickClock(20, 3), updateTickClock(20, 3) {
 }
 
@@ -117,7 +117,7 @@ entityid_t Entities::spawn(
     dv::value saved,
     entityid_t uid
 ) {
-    auto skeleton = level->content->getSkeleton(def.skeletonName);
+    auto skeleton = level.content.getSkeleton(def.skeletonName);
     if (skeleton == nullptr) {
         throw std::runtime_error("skeleton " + def.skeletonName + " not found");
     }
@@ -162,7 +162,7 @@ entityid_t Entities::spawn(
 
     for (auto& componentName : def.components) {
         auto component = std::make_unique<UserComponent>(
-            componentName, entity_funcs_set {}, nullptr
+            componentName, EntityFuncsSet {}, nullptr
         );
         scripting.components.emplace_back(std::move(component));
     }
@@ -190,7 +190,7 @@ void Entities::despawn(entityid_t id) {
 void Entities::loadEntity(const dv::value& map) {
     entityid_t uid = map["uid"].asInteger();
     std::string defname = map["def"].asString();
-    auto& def = level->content->entities.require(defname);
+    auto& def = level.content.entities.require(defname);
     spawn(def, {}, nullptr, map, uid);
 }
 
@@ -219,7 +219,7 @@ void Entities::loadEntity(const dv::value& map, Entity entity) {
     std::string skeletonName = skeleton.config->getName();
     map.at("skeleton").get(skeletonName);
     if (skeletonName != skeleton.config->getName()) {
-        skeleton.config = level->content->getSkeleton(skeletonName);
+        skeleton.config = level.content.getSkeleton(skeletonName);
     }
     if (auto found = map.at(COMP_SKELETON)) {
         auto& skeletonmap = *found;
@@ -361,8 +361,8 @@ dv::value Entities::serialize(const std::vector<Entity>& entities) {
         if (!entity.getDef().save.enabled) {
             continue;
         }
-        level->entities->onSave(entity);
-        list.add(level->entities->serialize(entity));
+        level.entities->onSave(entity);
+        list.add(level.entities->serialize(entity));
     }
     return list;
 }
@@ -380,7 +380,7 @@ void Entities::clean() {
         } else {
             auto& rigidbody = registry.get<Rigidbody>(it->second);
             // todo: refactor
-            auto physics = level->physics.get();
+            auto physics = level.physics.get();
             for (auto& sensor : rigidbody.sensors) {
                 physics->removeSensor(&sensor);
             }
@@ -428,7 +428,7 @@ void Entities::preparePhysics(float delta) {
         auto parts = sensorsTickClock.getParts();
 
         auto view = registry.view<EntityId, Transform, Rigidbody>();
-        auto physics = level->physics.get();
+        auto physics = level.physics.get();
         std::vector<Sensor*> sensors;
         for (auto [entity, eid, transform, rigidbody] : view.each()) {
             if (!rigidbody.enabled) {
@@ -447,7 +447,7 @@ void Entities::updatePhysics(float delta) {
     preparePhysics(delta);
 
     auto view = registry.view<EntityId, Transform, Rigidbody>();
-    auto physics = level->physics.get();
+    auto physics = level.physics.get();
     for (auto [entity, eid, transform, rigidbody] : view.each()) {
         if (!rigidbody.enabled || rigidbody.hitbox.type == BodyType::STATIC) {
             continue;
@@ -459,7 +459,7 @@ void Entities::updatePhysics(float delta) {
         float vel = glm::length(prevVel);
         int substeps = static_cast<int>(delta * vel * 20);
         substeps = std::min(100, std::max(2, substeps));
-        physics->step(level->chunks.get(), &hitbox, delta, substeps, eid.uid);
+        physics->step(*level.chunks, hitbox, delta, substeps, eid.uid);
         hitbox.linearDamping = hitbox.grounded * 24;
         transform.setPos(hitbox.position);
         if (hitbox.grounded && !grounded) {
@@ -556,10 +556,6 @@ void Entities::render(
     float delta,
     bool pause
 ) {
-    if (!pause) {
-        scripting::on_entities_render(delta);
-    }
-
     auto view = registry.view<Transform, rigging::Skeleton>();
     for (auto [entity, transform, skeleton] : view.each()) {
         if (transform.dirty) {
diff --git a/src/objects/Entities.hpp b/src/objects/Entities.hpp
index 0026d15e9..001b3dd9d 100644
--- a/src/objects/Entities.hpp
+++ b/src/objects/Entities.hpp
@@ -14,7 +14,7 @@
 #include <glm/gtx/norm.hpp>
 #include <unordered_map>
 
-struct entity_funcs_set {
+struct EntityFuncsSet {
     bool init;
     bool on_despawn;
     bool on_grounded;
@@ -77,11 +77,11 @@ struct Rigidbody {
 
 struct UserComponent {
     std::string name;
-    entity_funcs_set funcsset;
+    EntityFuncsSet funcsset;
     scriptenv env;
 
     UserComponent(
-        const std::string& name, entity_funcs_set funcsset, scriptenv env
+        const std::string& name, EntityFuncsSet funcsset, scriptenv env
     )
         : name(name), funcsset(funcsset), env(env) {
     }
@@ -166,7 +166,7 @@ class Entity {
 
 class Entities {
     entt::registry registry;
-    Level* level;
+    Level& level;
     std::unordered_map<entityid_t, entt::entity> entities;
     std::unordered_map<entt::entity, entityid_t> uids;
     entityid_t nextID = 1;
@@ -184,7 +184,7 @@ class Entities {
         float distance;
     };
 
-    Entities(Level* level);
+    Entities(Level& level);
 
     void clean();
     void updatePhysics(float delta);
diff --git a/src/objects/Player.cpp b/src/objects/Player.cpp
index 000d2c041..f80fffa74 100644
--- a/src/objects/Player.cpp
+++ b/src/objects/Player.cpp
@@ -17,6 +17,9 @@
 #include "window/Events.hpp"
 #include "world/Level.hpp"
 #include "data/dv_util.hpp"
+#include "debug/Logger.hpp"
+
+static debug::Logger logger("player");
 
 constexpr float CROUCH_SPEED_MUL = 0.35f;
 constexpr float RUN_SPEED_MUL = 1.5f;
@@ -28,7 +31,7 @@ constexpr float JUMP_FORCE = 8.0f;
 constexpr int SPAWN_ATTEMPTS_PER_UPDATE = 64;
 
 Player::Player(
-    Level* level,
+    Level& level,
     int64_t id,
     const std::string& name,
     glm::vec3 position,
@@ -44,9 +47,12 @@ Player::Player(
       position(position),
       inventory(std::move(inv)),
       eid(eid),
-      fpCamera(level->getCamera("core:first-person")),
-      spCamera(level->getCamera("core:third-person-front")),
-      tpCamera(level->getCamera("core:third-person-back")),
+      chunks(std::make_unique<Chunks>(
+          3, 3, 0, 0, level.events.get(), *level.content.getIndices()
+      )),
+      fpCamera(level.getCamera("core:first-person")),
+      spCamera(level.getCamera("core:third-person-front")),
+      tpCamera(level.getCamera("core:third-person-back")),
       currentCamera(fpCamera) {
     fpCamera->setFov(glm::radians(90.0f));
     spCamera->setFov(glm::radians(90.0f));
@@ -57,17 +63,19 @@ Player::~Player() = default;
 
 void Player::updateEntity() {
     if (eid == 0) {
-        auto& def = level->content->entities.require("base:player");
-        eid = level->entities->spawn(def, getPosition());
-    } else if (auto entity = level->entities->get(eid)) {
+        auto& def = level.content.entities.require("base:player");
+        eid = level.entities->spawn(def, getPosition());
+    } else if (auto entity = level.entities->get(eid)) {
         position = entity->getTransform().pos;
-    } else {
-        // TODO: check if chunk loaded
+    } else if (chunks->getChunkByVoxel(position)) {
+        logger.error() << "player entity despawned or deleted; "
+                          "will be respawned";
+        eid = 0;
     }
 }
 
 Hitbox* Player::getHitbox() {
-    if (auto entity = level->entities->get(eid)) {
+    if (auto entity = level.entities->get(eid)) {
         return &entity->getRigidbody().hitbox;
     }
     return nullptr;
@@ -132,18 +140,7 @@ void Player::updateInput(PlayerInput& input, float delta) {
         hitbox->velocity.y = JUMP_FORCE;
     }
 
-    if ((input.flight && !noclip) || (input.noclip && flight == noclip)) {
-        flight = !flight;
-        if (flight) {
-            hitbox->velocity.y += 1.0f;
-        }
-    }
     hitbox->type = noclip ? BodyType::KINEMATIC : BodyType::DYNAMIC;
-    if (input.noclip) {
-        noclip = !noclip;
-    }
-    input.noclip = false;
-    input.flight = false;
 }
 
 void Player::updateSelectedEntity() {
@@ -151,7 +148,7 @@ void Player::updateSelectedEntity() {
 }
 
 void Player::postUpdate() {
-    auto entity = level->entities->get(eid);
+    auto entity = level.entities->get(eid);
     if (!entity.has_value()) {
         return;
     }
@@ -176,12 +173,12 @@ void Player::postUpdate() {
 
     if (body) {
         skeleton.pose.matrices[body->getIndex()] = glm::rotate(
-            glm::mat4(1.0f), glm::radians(cam.x), glm::vec3(0, 1, 0)
+            glm::mat4(1.0f), glm::radians(rotation.x), glm::vec3(0, 1, 0)
         );
     }
     if (head) {
         skeleton.pose.matrices[head->getIndex()] = glm::rotate(
-            glm::mat4(1.0f), glm::radians(cam.y), glm::vec3(1, 0, 0)
+            glm::mat4(1.0f), glm::radians(rotation.y), glm::vec3(1, 0, 0)
         );
     }
 }
@@ -189,7 +186,7 @@ void Player::postUpdate() {
 void Player::teleport(glm::vec3 position) {
     this->position = position;
 
-    if (auto entity = level->entities->get(eid)) {
+    if (auto entity = level.entities->get(eid)) {
         entity->getRigidbody().hitbox.position = position;
         entity->getTransform().setPos(position);
     }
@@ -202,12 +199,12 @@ void Player::attemptToFindSpawnpoint() {
         position.z + (rand() % 200 - 100)
     );
     while (newpos.y > 0 &&
-           !level->chunks->isObstacleBlock(newpos.x, newpos.y - 2, newpos.z)) {
+           !chunks->isObstacleBlock(newpos.x, newpos.y - 2, newpos.z)) {
         newpos.y--;
     }
 
-    voxel* headvox = level->chunks->get(newpos.x, newpos.y + 1, newpos.z);
-    if (level->chunks->isObstacleBlock(newpos.x, newpos.y, newpos.z) ||
+    voxel* headvox = chunks->get(newpos.x, newpos.y + 1, newpos.z);
+    if (chunks->isObstacleBlock(newpos.x, newpos.y, newpos.z) ||
         headvox == nullptr || headvox->id != 0) {
         return;
     }
@@ -259,6 +256,14 @@ void Player::setInstantDestruction(bool flag) {
     instantDestruction = flag;
 }
 
+bool Player::isLoadingChunks() const {
+    return loadingChunks;
+}
+
+void Player::setLoadingChunks(bool flag) {
+    loadingChunks = flag;
+}
+
 entityid_t Player::getEntity() const {
     return eid;
 }
@@ -298,21 +303,22 @@ dv::value Player::serialize() const {
     root["name"] = name;
 
     root["position"] = dv::to_value(position);
-    root["rotation"] = dv::to_value(cam);
+    root["rotation"] = dv::to_value(rotation);
     root["spawnpoint"] = dv::to_value(spawnpoint);
 
     root["flight"] = flight;
     root["noclip"] = noclip;
     root["infinite-items"] = infiniteItems;
     root["instant-destruction"] = instantDestruction;
+    root["loading-chunks"] = loadingChunks;
     root["chosen-slot"] = chosenSlot;
     root["entity"] = eid;
     root["inventory"] = inventory->serialize();
     auto found =
-        std::find(level->cameras.begin(), level->cameras.end(), currentCamera);
-    if (found != level->cameras.end()) {
-        root["camera"] = level->content->getIndices(ResourceType::CAMERA)
-                .getName(found - level->cameras.begin());
+        std::find(level.cameras.begin(), level.cameras.end(), currentCamera);
+    if (found != level.cameras.end()) {
+        root["camera"] = level.content.getIndices(ResourceType::CAMERA)
+                .getName(found - level.cameras.begin());
     }
     return root;
 }
@@ -327,7 +333,7 @@ void Player::deserialize(const dv::value& src) {
     fpCamera->position = position;
 
     const auto& rotarr = src["rotation"];
-    dv::get_vec(rotarr, cam);
+    dv::get_vec(rotarr, rotation);
 
     const auto& sparr = src["spawnpoint"];
     setSpawnPoint(glm::vec3(
@@ -337,7 +343,8 @@ void Player::deserialize(const dv::value& src) {
     noclip = src["noclip"].asBoolean();
     src.at("infinite-items").get(infiniteItems);
     src.at("instant-destruction").get(instantDestruction);
-    
+    src.at("loading-chunks").get(loadingChunks);
+
     setChosenSlot(src["chosen-slot"].asInteger());
     eid = src["entity"].asNumber();
 
@@ -347,7 +354,7 @@ void Player::deserialize(const dv::value& src) {
 
     if (src.has("camera")) {
         std::string name = src["camera"].asString();
-        if (auto camera = level->getCamera(name)) {
+        if (auto camera = level.getCamera(name)) {
             currentCamera = camera;
         }
     }
diff --git a/src/objects/Player.hpp b/src/objects/Player.hpp
index 920e06e43..1e87e2a77 100644
--- a/src/objects/Player.hpp
+++ b/src/objects/Player.hpp
@@ -8,6 +8,7 @@
 #include "settings.hpp"
 #include "voxels/voxel.hpp"
 
+class Chunks;
 class Camera;
 class Inventory;
 class ContentReport;
@@ -26,8 +27,6 @@ struct PlayerInput {
     bool shift : 1;
     bool cheat : 1;
     bool jump : 1;
-    bool noclip : 1;
-    bool flight : 1;
 };
 
 struct CursorSelection {
@@ -40,7 +39,7 @@ struct CursorSelection {
 };
 
 class Player : public Serializable {
-    Level* level;
+    Level& level;
     int64_t id;
     std::string name;
     float speed;
@@ -52,17 +51,18 @@ class Player : public Serializable {
     bool noclip = false;
     bool infiniteItems = true;
     bool instantDestruction = true;
+    bool loadingChunks = true;
     entityid_t eid;
     entityid_t selectedEid = 0;
 public:
+    std::unique_ptr<Chunks> chunks;
     std::shared_ptr<Camera> fpCamera, spCamera, tpCamera;
     std::shared_ptr<Camera> currentCamera;
-    bool debug = false;
-    glm::vec3 cam {};
+    glm::vec3 rotation {};
     CursorSelection selection {};
 
     Player(
-        Level* level,
+        Level& level,
         int64_t id,
         const std::string& name,
         glm::vec3 position,
@@ -97,6 +97,9 @@ class Player : public Serializable {
     bool isInstantDestruction() const;
     void setInstantDestruction(bool flag);
 
+    bool isLoadingChunks() const;
+    void setLoadingChunks(bool flag);
+
     entityid_t getEntity() const;
     void setEntity(entityid_t eid);
 
diff --git a/src/objects/Players.cpp b/src/objects/Players.cpp
index 900319917..1a683a343 100644
--- a/src/objects/Players.cpp
+++ b/src/objects/Players.cpp
@@ -5,9 +5,9 @@
 #include "world/Level.hpp"
 #include "world/World.hpp"
 
-Players::Players(Level* level) : level(level) {}
+Players::Players(Level& level) : level(level) {}
 
-void Players::addPlayer(std::unique_ptr<Player> player) {
+void Players::add(std::unique_ptr<Player> player) {
     players[player->getId()] = std::move(player);
 }
 
@@ -22,20 +22,24 @@ Player* Players::get(int64_t id) const {
 Player* Players::create() {
     auto playerPtr = std::make_unique<Player>(
         level,
-        level->getWorld()->getInfo().nextPlayerId++,
+        level.getWorld()->getInfo().nextPlayerId++,
         "",
         glm::vec3(0, DEF_PLAYER_Y, 0),
         DEF_PLAYER_SPEED,
-        level->inventories->create(DEF_PLAYER_INVENTORY_SIZE),
+        level.inventories->create(DEF_PLAYER_INVENTORY_SIZE),
         0
     );
     auto player = playerPtr.get();
-    addPlayer(std::move(playerPtr));
+    add(std::move(playerPtr));
 
-    level->inventories->store(player->getInventory());
+    level.inventories->store(player->getInventory());
     return player;
 }
 
+void Players::remove(int64_t id) {
+    players.erase(id);
+}
+
 dv::value Players::serialize() const {
     auto root = dv::object();
     auto& list = root.list("players");
@@ -57,17 +61,17 @@ void Players::deserialize(const dv::value& src) {
             "",
             glm::vec3(0, DEF_PLAYER_Y, 0),
             DEF_PLAYER_SPEED,
-            level->inventories->create(DEF_PLAYER_INVENTORY_SIZE),
+            level.inventories->create(DEF_PLAYER_INVENTORY_SIZE),
             0
         );
         auto player = playerPtr.get();
         player->deserialize(playerMap);
-        addPlayer(std::move(playerPtr));
+        add(std::move(playerPtr));
         auto& inventory = player->getInventory();
         // invalid inventory id pre 0.25
         if (inventory->getId() == 0) {
-            inventory->setId(level->getWorld()->getNextInventoryId());
+            inventory->setId(level.getWorld()->getNextInventoryId());
         }
-        level->inventories->store(player->getInventory());
+        level.inventories->store(player->getInventory());
     }
 }
diff --git a/src/objects/Players.hpp b/src/objects/Players.hpp
index f66d181f9..74f5c5651 100644
--- a/src/objects/Players.hpp
+++ b/src/objects/Players.hpp
@@ -14,17 +14,19 @@ class Level;
 class Player;
 
 class Players : public Serializable {
-    Level* level;
+    Level& level;
     std::unordered_map<int64_t, std::unique_ptr<Player>> players;
 
-    void addPlayer(std::unique_ptr<Player> player);
+    void add(std::unique_ptr<Player> player);
 public:
-    Players(Level* level);
+    Players(Level& level);
 
     Player* get(int64_t id) const;
 
     Player* create();
 
+    void remove(int64_t id);
+
     dv::value serialize() const override;
 
     void deserialize(const dv::value& src) override;
@@ -36,4 +38,8 @@ class Players : public Serializable {
     auto end() const {
         return players.end();
     }
+
+    size_t size() const {
+        return players.size();
+    }
 };
diff --git a/src/physics/PhysicsSolver.cpp b/src/physics/PhysicsSolver.cpp
index 959543809..62a6abd6a 100644
--- a/src/physics/PhysicsSolver.cpp
+++ b/src/physics/PhysicsSolver.cpp
@@ -3,7 +3,7 @@
 
 #include "maths/aabb.hpp"
 #include "voxels/Block.hpp"
-#include "voxels/Chunks.hpp"
+#include "voxels/GlobalChunks.hpp"
 #include "voxels/voxel.hpp"
 
 #include <iostream>
@@ -18,80 +18,80 @@ PhysicsSolver::PhysicsSolver(glm::vec3 gravity) : gravity(gravity) {
 }
 
 void PhysicsSolver::step(
-    Chunks* chunks, 
-    Hitbox* hitbox, 
+    const GlobalChunks& chunks, 
+    Hitbox& hitbox, 
     float delta, 
     uint substeps, 
     entityid_t entity
 ) {
     float dt = delta / static_cast<float>(substeps);
-    float linearDamping = hitbox->linearDamping;
+    float linearDamping = hitbox.linearDamping;
     float s = 2.0f/BLOCK_AABB_GRID;
 
-    const glm::vec3& half = hitbox->halfsize;
-    glm::vec3& pos = hitbox->position;
-    glm::vec3& vel = hitbox->velocity;
-    float gravityScale = hitbox->gravityScale;
+    const glm::vec3& half = hitbox.halfsize;
+    glm::vec3& pos = hitbox.position;
+    glm::vec3& vel = hitbox.velocity;
+    float gravityScale = hitbox.gravityScale;
     
-    bool prevGrounded = hitbox->grounded;
-    hitbox->grounded = false;
+    bool prevGrounded = hitbox.grounded;
+    hitbox.grounded = false;
     for (uint i = 0; i < substeps; i++) {
         float px = pos.x;
         float py = pos.y;
         float pz = pos.z;
         
         vel += gravity * dt * gravityScale;
-        if (hitbox->type == BodyType::DYNAMIC) {
+        if (hitbox.type == BodyType::DYNAMIC) {
             colisionCalc(chunks, hitbox, vel, pos, half, 
                          (prevGrounded && gravityScale > 0.0f) ? 0.5f : 0.0f);
         }
         vel.x *= glm::max(0.0f, 1.0f - dt * linearDamping);
-        if (hitbox->verticalDamping) {
+        if (hitbox.verticalDamping) {
             vel.y *= glm::max(0.0f, 1.0f - dt * linearDamping);
         }
         vel.z *= glm::max(0.0f, 1.0f - dt * linearDamping);
 
         pos += vel * dt + gravity * gravityScale * dt * dt * 0.5f;
-        if (hitbox->grounded && pos.y < py) {
+        if (hitbox.grounded && pos.y < py) {
             pos.y = py;
         }
 
-        if (hitbox->crouching && hitbox->grounded){
+        if (hitbox.crouching && hitbox.grounded){
             float y = (pos.y-half.y-E);
-            hitbox->grounded = false;
+            hitbox.grounded = false;
             for (int ix = 0; ix <= (half.x-E)*2/s; ix++) {
                 float x = (px-half.x+E) + ix * s;
                 for (int iz = 0; iz <= (half.z-E)*2/s; iz++){
                     float z = (pos.z-half.z+E) + iz * s;
-                    if (chunks->isObstacleAt(x,y,z)){
-                        hitbox->grounded = true;
+                    if (chunks.isObstacleAt(x,y,z)){
+                        hitbox.grounded = true;
                         break;
                     }
                 }
             }
-            if (!hitbox->grounded) {
+            if (!hitbox.grounded) {
                 pos.z = pz;
             }
-            hitbox->grounded = false;
+            hitbox.grounded = false;
             for (int ix = 0; ix <= (half.x-E)*2/s; ix++) {
                 float x = (pos.x-half.x+E) + ix * s;
                 for (int iz = 0; iz <= (half.z-E)*2/s; iz++){
                     float z = (pz-half.z+E) + iz * s;
-                    if (chunks->isObstacleAt(x,y,z)){
-                        hitbox->grounded = true;
+                    if (chunks.isObstacleAt(x,y,z)){
+                        hitbox.grounded = true;
                         break;
                     }
                 }
             }
-            if (!hitbox->grounded) {
+            if (!hitbox.grounded) {
                 pos.x = px;
             }
-            hitbox->grounded = true;
+            hitbox.grounded = true;
         }
     }
     AABB aabb;
-    aabb.a = hitbox->position - hitbox->halfsize;
-    aabb.b = hitbox->position + hitbox->halfsize;
+    aabb.a = hitbox.position - hitbox.halfsize;
+    aabb.b = hitbox.position + hitbox.halfsize;
     for (size_t i = 0; i < sensors.size(); i++) {
         auto& sensor = *sensors[i];
         if (sensor.entity == entity) {
@@ -105,7 +105,7 @@ void PhysicsSolver::step(
                 break;
             case SensorType::RADIUS:
                 triggered = glm::distance2(
-                    hitbox->position, glm::vec3(sensor.calculated.radial))
+                    hitbox.position, glm::vec3(sensor.calculated.radial))
                      < sensor.calculated.radial.w;
                 break;
         }
@@ -119,8 +119,8 @@ void PhysicsSolver::step(
 }
 
 static float calc_step_height(
-    Chunks* chunks, 
-    glm::vec3& pos, 
+    const GlobalChunks& chunks, 
+    const glm::vec3& pos, 
     const glm::vec3& half,
     float stepHeight,
     float s
@@ -130,7 +130,7 @@ static float calc_step_height(
             float x = (pos.x-half.x+E) + ix * s;
             for (int iz = 0; iz <= (half.z-E)*2/s; iz++) {
                 float z = (pos.z-half.z+E) + iz * s;
-                if (chunks->isObstacleAt(x, pos.y+half.y+stepHeight, z)) {
+                if (chunks.isObstacleAt(x, pos.y+half.y+stepHeight, z)) {
                     return 0.0f;
                 }
             }
@@ -141,7 +141,7 @@ static float calc_step_height(
 
 template <int nx, int ny, int nz>
 static bool calc_collision_neg(
-    Chunks* chunks,
+    const GlobalChunks& chunks,
     glm::vec3& pos,
     glm::vec3& vel,
     const glm::vec3& half,
@@ -159,7 +159,7 @@ static bool calc_collision_neg(
             coord[nz] = (pos[nz]-half[nz]+E) + iz * s;
             coord[nx] = (pos[nx]-half[nx]-E);
 
-            if (const auto aabb = chunks->isObstacleAt(coord.x, coord.y, coord.z)) {
+            if (const auto aabb = chunks.isObstacleAt(coord.x, coord.y, coord.z)) {
                 vel[nx] = 0.0f;
                 float newx = std::floor(coord[nx]) + aabb->max()[nx] + half[nx] + E;
                 if (std::abs(newx-pos[nx]) <= MAX_FIX) {
@@ -174,7 +174,7 @@ static bool calc_collision_neg(
 
 template <int nx, int ny, int nz>
 static void calc_collision_pos(
-    Chunks* chunks,
+    const GlobalChunks& chunks,
     glm::vec3& pos,
     glm::vec3& vel,
     const glm::vec3& half,
@@ -191,7 +191,7 @@ static void calc_collision_pos(
         for (int iz = 0; iz <= (half[nz]-E)*2/s; iz++) {
             coord[nz] = (pos[nz]-half[nz]+E) + iz * s;
             coord[nx] = (pos[nx]+half[nx]+E);
-            if (const auto aabb = chunks->isObstacleAt(coord.x, coord.y, coord.z)) {
+            if (const auto aabb = chunks.isObstacleAt(coord.x, coord.y, coord.z)) {
                 vel[nx] = 0.0f;
                 float newx = std::floor(coord[nx]) - half[nx] + aabb->min()[nx] - E;
                 if (std::abs(newx-pos[nx]) <= MAX_FIX) {
@@ -204,8 +204,8 @@ static void calc_collision_pos(
 }
 
 void PhysicsSolver::colisionCalc(
-    Chunks* chunks, 
-    Hitbox* hitbox, 
+    const GlobalChunks& chunks, 
+    Hitbox& hitbox, 
     glm::vec3& vel, 
     glm::vec3& pos, 
     const glm::vec3 half,
@@ -225,7 +225,7 @@ void PhysicsSolver::colisionCalc(
     calc_collision_pos<2, 1, 0>(chunks, pos, vel, half, stepHeight, s);
 
     if (calc_collision_neg<1, 0, 2>(chunks, pos, vel, half, stepHeight, s)) {
-        hitbox->grounded = true;
+        hitbox.grounded = true;
     }
 
     if (stepHeight > 0.0 && vel.y <= 0.0f){
@@ -234,7 +234,7 @@ void PhysicsSolver::colisionCalc(
             for (int iz = 0; iz <= (half.z-E)*2/s; iz++) {
                 float z = (pos.z-half.z+E) + iz * s;
                 float y = (pos.y-half.y+E);
-                if ((aabb = chunks->isObstacleAt(x,y,z))){
+                if ((aabb = chunks.isObstacleAt(x,y,z))){
                     vel.y = 0.0f;
                     float newy = std::floor(y) + aabb->max().y + half.y;
                     if (std::abs(newy-pos.y) <= MAX_FIX+stepHeight) {
@@ -251,7 +251,7 @@ void PhysicsSolver::colisionCalc(
             for (int iz = 0; iz <= (half.z-E)*2/s; iz++) {
                 float z = (pos.z-half.z+E) + iz * s;
                 float y = (pos.y+half.y+E);
-                if ((aabb = chunks->isObstacleAt(x,y,z))){
+                if ((aabb = chunks.isObstacleAt(x,y,z))){
                     vel.y = 0.0f;
                     float newy = std::floor(y) - half.y + aabb->min().y - E;
                     if (std::abs(newy-pos.y) <= MAX_FIX) {
@@ -273,7 +273,7 @@ bool PhysicsSolver::isBlockInside(int x, int y, int z, Hitbox* hitbox) {
 }
 
 bool PhysicsSolver::isBlockInside(int x, int y, int z, Block* def, blockstate state, Hitbox* hitbox) {
-    const float E = 0.001f; // inaccuracy
+    const float e = 0.001f; // inaccuracy
     const glm::vec3& pos = hitbox->position;
     const glm::vec3& half = hitbox->halfsize;
     const auto& boxes = def->rotatable 
@@ -282,9 +282,9 @@ bool PhysicsSolver::isBlockInside(int x, int y, int z, Block* def, blockstate st
     for (const auto& block_hitbox : boxes) {
         glm::vec3 min = block_hitbox.min();
         glm::vec3 max = block_hitbox.max();
-        if (min.x < pos.x+half.x-x-E && max.x > pos.x-half.x-x+E &&
-            min.z < pos.z+half.z-z-E && max.z > pos.z-half.z-z+E &&
-            min.y < pos.y+half.y-y-E && max.y > pos.y-half.y-y+E)
+        if (min.x < pos.x+half.x-x-e && max.x > pos.x-half.x-x+e &&
+            min.z < pos.z+half.z-z-e && max.z > pos.z-half.z-z+e &&
+            min.y < pos.y+half.y-y-e && max.y > pos.y-half.y-y+e)
             return true;
     }
     return false;
diff --git a/src/physics/PhysicsSolver.hpp b/src/physics/PhysicsSolver.hpp
index 35f8158e4..b7810cefd 100644
--- a/src/physics/PhysicsSolver.hpp
+++ b/src/physics/PhysicsSolver.hpp
@@ -9,7 +9,7 @@
 #include <glm/glm.hpp>
 
 class Block;
-class Chunks;
+class GlobalChunks;
 struct Sensor;
 
 class PhysicsSolver {
@@ -18,15 +18,15 @@ class PhysicsSolver {
 public:
     PhysicsSolver(glm::vec3 gravity);
     void step(
-        Chunks* chunks,
-        Hitbox* hitbox,
+        const GlobalChunks& chunks,
+        Hitbox& hitbox,
         float delta,
         uint substeps,
         entityid_t entity
     );
     void colisionCalc(
-        Chunks* chunks,
-        Hitbox* hitbox,
+        const GlobalChunks& chunks,
+        Hitbox& hitbox,
         glm::vec3& vel,
         glm::vec3& pos,
         const glm::vec3 half,
diff --git a/src/settings.hpp b/src/settings.hpp
index 48d72b272..53ebf5f9e 100644
--- a/src/settings.hpp
+++ b/src/settings.hpp
@@ -71,6 +71,8 @@ struct GraphicsSettings {
     IntegerSetting skyboxResolution {64 + 32, 64, 128};
     /// @brief Chunk renderer vertices buffer capacity
     IntegerSetting chunkMaxVertices {200'000, 0, 4'000'000};
+    /// @brief Chunk renderer vertices buffer capacity in dense render mode
+    IntegerSetting chunkMaxVerticesDense {800'000, 0, 8'000'000};
     /// @brief Limit of chunk renderers count
     IntegerSetting chunkMaxRenderers {6, -4, 32};
 };
diff --git a/src/util/AreaMap2D.hpp b/src/util/AreaMap2D.hpp
index 1a6c97ceb..b7eda1fb7 100644
--- a/src/util/AreaMap2D.hpp
+++ b/src/util/AreaMap2D.hpp
@@ -27,7 +27,7 @@ namespace util {
             std::fill(secondBuffer.begin(), secondBuffer.end(), T{});
             for (TCoord y = 0; y < sizeY; y++) {
                 for (TCoord x = 0; x < sizeX; x++) {
-                    auto& value = firstBuffer[y * sizeX + x];
+                    auto value = std::move(firstBuffer[y * sizeX + x]);
                     auto nx = x - dx;
                     auto ny = y - dy;
                     if (value == T{}) {
@@ -40,7 +40,7 @@ namespace util {
                         valuesCount--;
                         continue;
                     }
-                    secondBuffer[ny * sizeX + nx] = value;
+                    secondBuffer[ny * sizeX + nx] = std::move(value);
                 }
             }
             std::swap(firstBuffer, secondBuffer);
diff --git a/src/util/ArgsReader.hpp b/src/util/ArgsReader.hpp
new file mode 100644
index 000000000..90d159f50
--- /dev/null
+++ b/src/util/ArgsReader.hpp
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <string>
+#include <stdexcept>
+#include <cstring>
+
+namespace util {
+    class ArgsReader {
+        const char* last = "";
+        char** argv;
+        int argc;
+        int pos = 0;
+    public:
+        ArgsReader(int argc, char** argv) : argv(argv), argc(argc) {
+        }
+
+        void skip() {
+            pos++;
+        }
+
+        bool hasNext() const {
+            return pos < argc && std::strlen(argv[pos]);
+        }
+
+        bool isKeywordArg() const {
+            return last[0] == '-';
+        }
+
+        std::string next() {
+            if (pos >= argc) {
+                throw std::runtime_error("unexpected end");
+            }
+            last = argv[pos];
+            return argv[pos++];
+        }
+    };
+}
diff --git a/src/util/HandlersList.hpp b/src/util/HandlersList.hpp
new file mode 100644
index 000000000..5af5250db
--- /dev/null
+++ b/src/util/HandlersList.hpp
@@ -0,0 +1,57 @@
+#pragma once
+
+#include <mutex>
+#include <iostream>
+
+#include "typedefs.hpp"
+#include "delegates.hpp"
+
+namespace util {
+    template<class...Types>
+    class HandlersList {
+        int nextid = 1;
+        std::unordered_map<int, std::function<bool(Types...)>> handlers;
+        std::vector<int> order;
+        std::recursive_mutex mutex;
+    public:
+        HandlersList() = default;
+
+        HandlersList(HandlersList&& o) {
+            handlers = std::move(o.handlers);
+            order = std::move(o.order);
+            nextid = o.nextid;
+        }
+
+        void operator=(HandlersList&& o) {
+            handlers = std::move(o.handlers);
+            order = std::move(o.order);
+            nextid = o.nextid;
+        }
+
+        observer_handler add(std::function<bool(Types...)> handler) {
+            std::lock_guard lock(mutex);
+            int id = nextid++;
+            handlers[id] = std::move(handler);
+            order.push_back(id);
+            return observer_handler(new int(id), [this](int* id) { //-V508
+                std::lock_guard lock(mutex);
+                handlers.erase(*id);
+                order.erase(
+                    std::remove(order.begin(), order.end(), *id), order.end()
+                );
+                delete id;
+            });
+        }
+
+        void notify(Types...args) {
+            std::lock_guard lock(mutex);
+            
+            auto orderCopy = order;
+            for (auto it = orderCopy.rbegin(); it != orderCopy.rend(); ++it) {
+                if (handlers.at(*it)(args...)) {
+                    break;
+                }
+            }
+        }
+    };
+}
diff --git a/src/util/ObjectsKeeper.hpp b/src/util/ObjectsKeeper.hpp
index 000c4fc10..74a5a36b4 100644
--- a/src/util/ObjectsKeeper.hpp
+++ b/src/util/ObjectsKeeper.hpp
@@ -14,5 +14,9 @@ namespace util {
         virtual void keepAlive(std::shared_ptr<void> ptr) {
             ptrs.push_back(ptr);
         }
+
+        virtual void clearKeepedObjects() {
+            ptrs.clear();
+        }
     };
 }
diff --git a/src/util/RunnablesList.hpp b/src/util/RunnablesList.hpp
index e655b42c5..c9771de39 100644
--- a/src/util/RunnablesList.hpp
+++ b/src/util/RunnablesList.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <mutex>
 #include <memory>
 #include <unordered_map>
 #include <utility>
@@ -11,17 +12,33 @@ namespace util {
     class RunnablesList {
         int nextid = 1;
         std::unordered_map<int, runnable> runnables;
+        std::mutex mutex;
     public:
+        RunnablesList() = default;
+
+        RunnablesList(RunnablesList&& o) {
+            runnables = std::move(o.runnables);
+            nextid = o.nextid;
+        }
+
+        void operator=(RunnablesList&& o) {
+            runnables = std::move(o.runnables);
+            nextid = o.nextid;
+        }
+
         observer_handler add(runnable callback) {
+            std::lock_guard lock(mutex);
             int id = nextid++;
             runnables[id] = std::move(callback);
             return observer_handler(new int(id), [this](int* id) { //-V508
+                std::lock_guard lock(mutex);
                 runnables.erase(*id);
                 delete id;
             });
         }
 
         void notify() {
+            std::lock_guard lock(mutex);
             for (auto& entry : runnables) {
                 entry.second();
             }
diff --git a/src/util/command_line.cpp b/src/util/command_line.cpp
index 99501c12f..483b0f8b9 100644
--- a/src/util/command_line.cpp
+++ b/src/util/command_line.cpp
@@ -1,81 +1,61 @@
 #include "command_line.hpp"
 
-#include <cstring>
 #include <filesystem>
 #include <iostream>
-#include <stdexcept>
-#include <string>
 
 #include "files/engine_paths.hpp"
+#include "util/ArgsReader.hpp"
+#include "engine/Engine.hpp"
 
 namespace fs = std::filesystem;
 
-class ArgsReader {
-    const char* last = "";
-    char** argv;
-    int argc;
-    int pos = 0;
-public:
-    ArgsReader(int argc, char** argv) : argv(argv), argc(argc) {
-    }
-
-    void skip() {
-        pos++;
-    }
-
-    bool hasNext() const {
-        return pos < argc && strlen(argv[pos]);
-    }
-
-    bool isKeywordArg() const {
-        return last[0] == '-';
-    }
-
-    std::string next() {
-        if (pos >= argc) {
-            throw std::runtime_error("unexpected end");
-        }
-        last = argv[pos];
-        return argv[pos++];
-    }
-};
-
-bool perform_keyword(
-    ArgsReader& reader, const std::string& keyword, EnginePaths& paths
+static bool perform_keyword(
+    util::ArgsReader& reader, const std::string& keyword, CoreParameters& params
 ) {
     if (keyword == "--res") {
         auto token = reader.next();
-        if (!fs::is_directory(fs::path(token))) {
-            throw std::runtime_error(token + " is not a directory");
-        }
-        paths.setResourcesFolder(fs::path(token));
-        std::cout << "resources folder: " << token << std::endl;
+        params.resFolder = fs::u8path(token);
     } else if (keyword == "--dir") {
         auto token = reader.next();
-        if (!fs::is_directory(fs::path(token))) {
-            fs::create_directories(fs::path(token));
-        }
-        paths.setUserFilesFolder(fs::path(token));
-        std::cout << "userfiles folder: " << token << std::endl;
+        params.userFolder = fs::u8path(token);
     } else if (keyword == "--help" || keyword == "-h") {
-        std::cout << "VoxelEngine command-line arguments:" << std::endl;
-        std::cout << " --res [path] - set resources directory" << std::endl;
-        std::cout << " --dir [path] - set userfiles directory" << std::endl;
+        std::cout << "VoxelCore v" << ENGINE_VERSION_STRING << "\n\n";
+        std::cout << "command-line arguments:\n";
+        std::cout << " --help - show help\n";
+        std::cout << " --version - print engine version\n";
+        std::cout << " --res <path> - set resources directory\n";
+        std::cout << " --dir <path> - set userfiles directory\n";
+        std::cout << " --headless - run in headless mode\n";
+        std::cout << " --test <path> - test script file\n";
+        std::cout << " --script <path> - main script file\n";
+        std::cout << std::endl;
         return false;
-    } else {
-        std::cerr << "unknown argument " << keyword << std::endl;
+    } else if (keyword == "--version") {
+        std::cout << ENGINE_VERSION_STRING << std::endl;
         return false;
+    } else if (keyword == "--headless") {
+        params.headless = true;
+    } else if (keyword == "--test") {
+        auto token = reader.next();
+        params.testMode = true;
+        params.scriptFile = fs::u8path(token);
+    } else if (keyword == "--script") {
+        auto token = reader.next();
+        params.testMode = false;
+        params.scriptFile = fs::u8path(token);
+    } else {
+        throw std::runtime_error("unknown argument " + keyword);
     }
     return true;
 }
 
-bool parse_cmdline(int argc, char** argv, EnginePaths& paths) {
-    ArgsReader reader(argc, argv);
+bool parse_cmdline(int argc, char** argv, CoreParameters& params) {
+    util::ArgsReader reader(argc, argv);
     reader.skip();
     while (reader.hasNext()) {
         std::string token = reader.next();
         if (reader.isKeywordArg()) {
-            if (!perform_keyword(reader, token, paths)) {
+            if (!perform_keyword(reader, token, params)) {
                 return false;
             }
         } else {
diff --git a/src/util/command_line.hpp b/src/util/command_line.hpp
index 9715c52df..ebb6741d8 100644
--- a/src/util/command_line.hpp
+++ b/src/util/command_line.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-class EnginePaths;
+struct CoreParameters;
 
 /// @return false if engine start can
-bool parse_cmdline(int argc, char** argv, EnginePaths& paths);
+bool parse_cmdline(int argc, char** argv, CoreParameters& params);
diff --git a/src/util/platform.cpp b/src/util/platform.cpp
index d4d399250..061c78e28 100644
--- a/src/util/platform.cpp
+++ b/src/util/platform.cpp
@@ -57,7 +57,14 @@ void platform::sleep(size_t millis) {
     // Reset the timer resolution back to the system default
     timeEndPeriod(periodMin);
 }
-#else
+
+int platform::get_process_id() {
+    return GetCurrentProcessId(); 
+}
+
+#else // _WIN32
+
+#include <unistd.h>
 
 void platform::configure_encoding() {
 }
@@ -74,7 +81,11 @@ std::string platform::detect_locale() {
 void platform::sleep(size_t millis) {
     std::this_thread::sleep_for(std::chrono::milliseconds(millis));
 }
-#endif
+
+int platform::get_process_id() {
+    return getpid();
+}
+#endif // _WIN32
 
 void platform::open_folder(const std::filesystem::path& folder) {
     if (!std::filesystem::is_directory(folder)) {
diff --git a/src/util/platform.hpp b/src/util/platform.hpp
index 1283bcfea..6793411ed 100644
--- a/src/util/platform.hpp
+++ b/src/util/platform.hpp
@@ -12,4 +12,5 @@ namespace platform {
     void open_folder(const std::filesystem::path& folder);
     /// Makes the current thread sleep for the specified amount of milliseconds.
     void sleep(size_t millis);
+    int get_process_id();
 }
diff --git a/src/util/stringutil.cpp b/src/util/stringutil.cpp
index ac80d134b..5242e01ad 100644
--- a/src/util/stringutil.cpp
+++ b/src/util/stringutil.cpp
@@ -382,7 +382,6 @@ int util::replaceAll(
         str.replace(start_pos, from.length(), to);
         offset = start_pos + to.length();
         count++;
-        break;
     }
     return count;
 }
diff --git a/src/voxel_engine.cpp b/src/voxel_engine.cpp
deleted file mode 100644
index c6a2ec7ed..000000000
--- a/src/voxel_engine.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#include "engine.hpp"
-#include "settings.hpp"
-#include "files/settings_io.hpp"
-#include "files/engine_paths.hpp"
-#include "util/platform.hpp"
-#include "util/command_line.hpp"
-#include "debug/Logger.hpp"
-
-#include <stdexcept>
-
-static debug::Logger logger("main");
-
-int main(int argc, char** argv) {
-    debug::Logger::init("latest.log");
-
-    EnginePaths paths;
-    if (!parse_cmdline(argc, argv, paths))
-        return EXIT_SUCCESS;
-
-    platform::configure_encoding();
-    try {
-        EngineSettings settings;
-        SettingsHandler handler(settings);
-        
-        Engine engine(settings, handler, &paths);
-
-        engine.mainloop();
-    }
-    catch (const initialize_error& err) {
-        logger.error() << "could not to initialize engine\n" << err.what();
-    }
-#ifdef NDEBUG
-    catch (const std::exception& err) {
-        logger.error() << "uncaught exception: " << err.what();
-        debug::Logger::flush();
-        throw;
-    }
-#endif
-    return EXIT_SUCCESS;
-}
diff --git a/src/voxels/Block.cpp b/src/voxels/Block.cpp
index 96bca2458..300eb250d 100644
--- a/src/voxels/Block.cpp
+++ b/src/voxels/Block.cpp
@@ -74,7 +74,7 @@ std::optional<CullingMode> CullingMode_from(std::string_view str) {
 }
 
 CoordSystem::CoordSystem(glm::ivec3 axisX, glm::ivec3 axisY, glm::ivec3 axisZ)
-    : axisX(axisX), axisY(axisY), axisZ(axisZ) {
+    : axes({axisX, axisY, axisZ}) {
     fix = glm::ivec3(0);
     if (isVectorHasNegatives(axisX)) fix -= axisX;
     if (isVectorHasNegatives(axisY)) fix -= axisY;
@@ -82,9 +82,9 @@ CoordSystem::CoordSystem(glm::ivec3 axisX, glm::ivec3 axisY, glm::ivec3 axisZ)
 }
 
 void CoordSystem::transform(AABB& aabb) const {
-    glm::vec3 X(axisX);
-    glm::vec3 Y(axisY);
-    glm::vec3 Z(axisZ);
+    glm::vec3 X(axes[0]);
+    glm::vec3 Y(axes[1]);
+    glm::vec3 Z(axes[2]);
     aabb.a = X * aabb.a.x + Y * aabb.a.y + Z * aabb.a.z;
     aabb.b = X * aabb.b.x + Y * aabb.b.y + Z * aabb.b.z;
     aabb.a += fix;
diff --git a/src/voxels/Block.hpp b/src/voxels/Block.hpp
index eb232e8d8..f3fa2a0f4 100644
--- a/src/voxels/Block.hpp
+++ b/src/voxels/Block.hpp
@@ -34,10 +34,11 @@ inline constexpr size_t MAX_USER_BLOCK_FIELDS_SIZE = 240;
 
 inline std::string DEFAULT_MATERIAL = "base:stone";
 
-struct block_funcs_set {
+struct BlockFuncsSet {
     bool init : 1;
     bool update : 1;
     bool onplaced : 1;
+    bool onbreaking : 1;
     bool onbroken : 1;
     bool onreplaced : 1;
     bool oninteract : 1;
@@ -46,10 +47,7 @@ struct block_funcs_set {
 };
 
 struct CoordSystem {
-    glm::ivec3 axisX;
-    glm::ivec3 axisY;
-    glm::ivec3 axisZ;
-
+    std::array<glm::ivec3, 3> axes;
     /// @brief Grid 3d position fix offset (for negative vectors)
     glm::ivec3 fix;
 
@@ -241,7 +239,7 @@ class Block {
         std::vector<AABB> hitboxes[BlockRotProfile::MAX_COUNT];
 
         /// @brief set of block callbacks flags
-        block_funcs_set funcsset {};
+        BlockFuncsSet funcsset {};
 
         /// @brief picking item integer id
         itemid_t pickingItem = 0;
@@ -260,5 +258,5 @@ class Block {
 };
 
 inline glm::ivec3 get_ground_direction(const Block& def, int rotation) {
-    return -def.rotations.variants[rotation].axisY;
+    return -def.rotations.variants[rotation].axes[1];
 }
diff --git a/src/voxels/Chunk.hpp b/src/voxels/Chunk.hpp
index 94011d408..55cdac215 100644
--- a/src/voxels/Chunk.hpp
+++ b/src/voxels/Chunk.hpp
@@ -8,6 +8,7 @@
 #include "constants.hpp"
 #include "lighting/Lightmap.hpp"
 #include "util/SmallHeap.hpp"
+#include "maths/aabb.hpp"
 #include "voxel.hpp"
 
 inline constexpr int CHUNK_DATA_LEN = CHUNK_VOL * 4;
@@ -75,4 +76,11 @@ class Chunk {
     bool decode(const ubyte* data);
 
     static void convert(ubyte* data, const ContentReport* report);
+
+    AABB getAABB() const {
+        return AABB(
+            glm::vec3(x * CHUNK_W, -INFINITY, z * CHUNK_D),
+            glm::vec3((x + 1) * CHUNK_W, INFINITY, (z + 1) * CHUNK_D)
+        );
+    }
 };
diff --git a/src/voxels/Chunks.cpp b/src/voxels/Chunks.cpp
index 943249647..f65c1863f 100644
--- a/src/voxels/Chunks.cpp
+++ b/src/voxels/Chunks.cpp
@@ -1,6 +1,5 @@
 #include "Chunks.hpp"
 
-#include <limits.h>
 #include <math.h>
 
 #include <algorithm>
@@ -9,7 +8,6 @@
 
 #include "data/StructLayout.hpp"
 #include "coders/byte_utils.hpp"
-#include "coders/json.hpp"
 #include "content/Content.hpp"
 #include "files/WorldFiles.hpp"
 #include "graphics/core/Mesh.hpp"
@@ -21,54 +19,39 @@
 #include "world/Level.hpp"
 #include "world/LevelEvents.hpp"
 #include "VoxelsVolume.hpp"
-#include "Block.hpp"
-#include "Chunk.hpp"
-#include "voxel.hpp"
+#include "blocks_agent.hpp"
 
 Chunks::Chunks(
     int32_t w,
     int32_t d,
     int32_t ox,
     int32_t oz,
-    WorldFiles* wfile,
-    Level* level
+    LevelEvents* events,
+    const ContentIndices& indices
 )
-    : level(level),
-      indices(level->content->getIndices()),
-      areaMap(w, d),
-      worldFiles(wfile) {
+    : events(events),
+      indices(indices),
+      areaMap(w, d) {
     areaMap.setCenter(ox-w/2, oz-d/2);
     areaMap.setOutCallback([this](int, int, const auto& chunk) {
-        save(chunk.get());
-        this->level->events->trigger(EVT_CHUNK_HIDDEN, chunk.get());
+        this->events->trigger(EVT_CHUNK_HIDDEN, chunk.get());
     });
 }
 
-voxel* Chunks::get(int32_t x, int32_t y, int32_t z) const {
-    if (y < 0 || y >= CHUNK_H) {
-        return nullptr;
-    }
-    int cx = floordiv(x, CHUNK_W);
-    int cz = floordiv(z, CHUNK_D);
-    auto ptr = areaMap.getIf(cx, cz);
-    if (ptr == nullptr) {
-        return nullptr;
-    }
-    Chunk* chunk = ptr->get();  // not thread safe
-    if (chunk == nullptr) {
-        return nullptr;
+void Chunks::configure(int32_t x, int32_t z, uint32_t radius) {
+    setCenter(x, z);
+    uint32_t diameter = radius * 2LL;
+    if (getWidth() != diameter) {
+        resize(diameter, diameter);
     }
-    int lx = x - cx * CHUNK_W;
-    int lz = z - cz * CHUNK_D;
-    return &chunk->voxels[(y * CHUNK_D + lz) * CHUNK_W + lx];
+}
+
+voxel* Chunks::get(int32_t x, int32_t y, int32_t z) const {
+    return blocks_agent::get(*this, x, y, z);
 }
 
 voxel& Chunks::require(int32_t x, int32_t y, int32_t z) const {
-    auto voxel = get(x, y, z);
-    if (voxel == nullptr) {
-        throw std::runtime_error("voxel does not exist");
-    }
-    return *voxel;
+    return blocks_agent::require(*this, x, y, z);
 }
 
 const AABB* Chunks::isObstacleAt(float x, float y, float z) const {
@@ -84,7 +67,7 @@ const AABB* Chunks::isObstacleAt(float x, float y, float z) const {
             return &empty;
         }
     }
-    const auto& def = indices->blocks.require(v->id);
+    const auto& def = indices.blocks.require(v->id);
     if (def.obstacle) {
         glm::ivec3 offset {};
         if (v->state.segment) {
@@ -105,29 +88,25 @@ const AABB* Chunks::isObstacleAt(float x, float y, float z) const {
 }
 
 bool Chunks::isSolidBlock(int32_t x, int32_t y, int32_t z) {
-    voxel* v = get(x, y, z);
-    if (v == nullptr) return false;
-    return indices->blocks.get(v->id)->rt.solid;  //-V522
+    return blocks_agent::is_solid_at(*this, x, y, z);
 }
 
 bool Chunks::isReplaceableBlock(int32_t x, int32_t y, int32_t z) {
-    voxel* v = get(x, y, z);
-    if (v == nullptr) return false;
-    return indices->blocks.get(v->id)->replaceable;  //-V522
+    return blocks_agent::is_replaceable_at(*this, x, y, z);
 }
 
 bool Chunks::isObstacleBlock(int32_t x, int32_t y, int32_t z) {
     voxel* v = get(x, y, z);
     if (v == nullptr) return false;
-    return indices->blocks.get(v->id)->obstacle;  //-V522
+    return indices.blocks.require(v->id).obstacle;
 }
 
 ubyte Chunks::getLight(int32_t x, int32_t y, int32_t z, int channel) const {
     if (y < 0 || y >= CHUNK_H) {
         return 0;
     }
-    int cx = floordiv(x, CHUNK_W);
-    int cz = floordiv(z, CHUNK_D);
+    int cx = floordiv<CHUNK_W>(x);
+    int cz = floordiv<CHUNK_D>(z);
 
     auto ptr = areaMap.getIf(cx, cz);
     if (ptr == nullptr) {
@@ -146,8 +125,8 @@ light_t Chunks::getLight(int32_t x, int32_t y, int32_t z) const {
     if (y < 0 || y >= CHUNK_H) {
         return 0;
     }
-    int cx = floordiv(x, CHUNK_W);
-    int cz = floordiv(z, CHUNK_D);
+    int cx = floordiv<CHUNK_W>(x);
+    int cz = floordiv<CHUNK_D>(z);
 
     auto ptr = areaMap.getIf(cx, cz);
     if (ptr == nullptr) {
@@ -166,8 +145,8 @@ Chunk* Chunks::getChunkByVoxel(int32_t x, int32_t y, int32_t z) const {
     if (y < 0 || y >= CHUNK_H) {
         return nullptr;
     }
-    int cx = floordiv(x, CHUNK_W);
-    int cz = floordiv(z, CHUNK_D);
+    int cx = floordiv<CHUNK_W>(x);
+    int cz = floordiv<CHUNK_D>(z);
     if (auto ptr = areaMap.getIf(cx, cz)) {
         return ptr->get();
     }
@@ -184,72 +163,19 @@ Chunk* Chunks::getChunk(int x, int z) const {
 glm::ivec3 Chunks::seekOrigin(
     const glm::ivec3& srcpos, const Block& def, blockstate state
 ) const {
-    auto pos = srcpos;
-    const auto& rotation = def.rotations.variants[state.rotation];
-    auto segment = state.segment;
-    while (true) {
-        if (!segment) {
-            return pos;
-        }
-        if (segment & 1) pos -= rotation.axisX;
-        if (segment & 2) pos -= rotation.axisY;
-        if (segment & 4) pos -= rotation.axisZ;
-
-        if (auto* voxel = get(pos.x, pos.y, pos.z)) {
-            segment = voxel->state.segment;
-        } else {
-            return pos;
-        }
-    }
+    return blocks_agent::seek_origin(*this, srcpos, def, state);
 }
 
 void Chunks::eraseSegments(
     const Block& def, blockstate state, int x, int y, int z
 ) {
-    const auto& rotation = def.rotations.variants[state.rotation];
-    for (int sy = 0; sy < def.size.y; sy++) {
-        for (int sz = 0; sz < def.size.z; sz++) {
-            for (int sx = 0; sx < def.size.x; sx++) {
-                if ((sx | sy | sz) == 0) {
-                    continue;
-                }
-                glm::ivec3 pos(x, y, z);
-                pos += rotation.axisX * sx;
-                pos += rotation.axisY * sy;
-                pos += rotation.axisZ * sz;
-                set(pos.x, pos.y, pos.z, 0, {});
-            }
-        }
-    }
-}
-
-static constexpr uint8_t segment_to_int(int sx, int sy, int sz) {
-    return ((sx > 0) | ((sy > 0) << 1) | ((sz > 0) << 2));
+    blocks_agent::erase_segments(*this, def, state, x, y, z);
 }
 
 void Chunks::repairSegments(
     const Block& def, blockstate state, int x, int y, int z
 ) {
-    const auto& rotation = def.rotations.variants[state.rotation];
-    const auto id = def.rt.id;
-    const auto size = def.size;
-    for (int sy = 0; sy < size.y; sy++) {
-        for (int sz = 0; sz < size.z; sz++) {
-            for (int sx = 0; sx < size.x; sx++) {
-                if ((sx | sy | sz) == 0) {
-                    continue;
-                }
-                blockstate segState = state;
-                segState.segment = segment_to_int(sx, sy, sz);
-
-                glm::ivec3 pos(x, y, z);
-                pos += rotation.axisX * sx;
-                pos += rotation.axisY * sy;
-                pos += rotation.axisZ * sz;
-                set(pos.x, pos.y, pos.z, id, segState);
-            }
-        }
-    }
+    blocks_agent::repair_segments(*this, def, state, x, y, z);
 }
 
 bool Chunks::checkReplaceability(
@@ -258,176 +184,23 @@ bool Chunks::checkReplaceability(
     const glm::ivec3& origin,
     blockid_t ignore
 ) {
-    const auto& rotation = def.rotations.variants[state.rotation];
-    const auto size = def.size;
-    for (int sy = 0; sy < size.y; sy++) {
-        for (int sz = 0; sz < size.z; sz++) {
-            for (int sx = 0; sx < size.x; sx++) {
-                auto pos = origin;
-                pos += rotation.axisX * sx;
-                pos += rotation.axisY * sy;
-                pos += rotation.axisZ * sz;
-                if (auto vox = get(pos.x, pos.y, pos.z)) {
-                    auto& target = indices->blocks.require(vox->id);
-                    if (!target.replaceable && vox->id != ignore) {
-                        return false;
-                    }
-                } else {
-                    return false;
-                }
-            }
-        }
-    }
-    return true;
+    return blocks_agent::check_replaceability(*this, def, state, origin, ignore);
 }
 
 void Chunks::setRotationExtended(
     const Block& def, blockstate state, const glm::ivec3& origin, uint8_t index
 ) {
-    auto newstate = state;
-    newstate.rotation = index;
-
-    // unable to rotate block (cause: obstacles)
-    if (!checkReplaceability(def, newstate, origin, def.rt.id)) {
-        return;
-    }
-
-    const auto& rotation = def.rotations.variants[index];
-    const auto size = def.size;
-    std::vector<glm::ivec3> segmentBlocks;
-
-    for (int sy = 0; sy < size.y; sy++) {
-        for (int sz = 0; sz < size.z; sz++) {
-            for (int sx = 0; sx < size.x; sx++) {
-                auto pos = origin;
-                pos += rotation.axisX * sx;
-                pos += rotation.axisY * sy;
-                pos += rotation.axisZ * sz;
-
-                blockstate segState = newstate;
-                segState.segment = segment_to_int(sx, sy, sz);
-
-                auto vox = get(pos);
-                // checked for nullptr by checkReplaceability
-                if (vox->id != def.rt.id) {
-                    set(pos.x, pos.y, pos.z, def.rt.id, segState);
-                } else {
-                    vox->state = segState;
-                    auto chunk = getChunkByVoxel(pos.x, pos.y, pos.z);
-                    assert(chunk != nullptr);
-                    chunk->setModifiedAndUnsaved();
-                    segmentBlocks.emplace_back(pos);
-                }
-            }
-        }
-    }
-    const auto& prevRotation = def.rotations.variants[state.rotation];
-    for (int sy = 0; sy < size.y; sy++) {
-        for (int sz = 0; sz < size.z; sz++) {
-            for (int sx = 0; sx < size.x; sx++) {
-                auto pos = origin;
-                pos += prevRotation.axisX * sx;
-                pos += prevRotation.axisY * sy;
-                pos += prevRotation.axisZ * sz;
-                if (std::find(
-                        segmentBlocks.begin(), segmentBlocks.end(), pos
-                    ) == segmentBlocks.end()) {
-                    set(pos.x, pos.y, pos.z, 0, {});
-                }
-            }
-        }
-    }
+    blocks_agent::set_rotation_extended(*this, def, state, origin, index);
 }
 
 void Chunks::setRotation(int32_t x, int32_t y, int32_t z, uint8_t index) {
-    if (index >= BlockRotProfile::MAX_COUNT) {
-        return;
-    }
-    auto vox = get(x, y, z);
-    if (vox == nullptr) {
-        return;
-    }
-    auto& def = indices->blocks.require(vox->id);
-    if (!def.rotatable || vox->state.rotation == index) {
-        return;
-    }
-    if (def.rt.extended) {
-        auto origin = seekOrigin({x, y, z}, def, vox->state);
-        vox = get(origin);
-        setRotationExtended(def, vox->state, origin, index);
-    } else {
-        vox->state.rotation = index;
-        auto chunk = getChunkByVoxel(x, y, z);
-        assert(chunk != nullptr);
-        chunk->setModifiedAndUnsaved();
-    }
+    return blocks_agent::set_rotation(*this, x, y, z, index);
 }
 
 void Chunks::set(
     int32_t x, int32_t y, int32_t z, uint32_t id, blockstate state
 ) {
-    if (y < 0 || y >= CHUNK_H) {
-        return;
-    }
-    int cx = floordiv(x, CHUNK_W);
-    int cz = floordiv(z, CHUNK_D);
-    auto ptr = areaMap.getIf(cx, cz);
-    if (ptr == nullptr) {
-        return;
-    }
-    Chunk* chunk = ptr->get();
-    if (chunk == nullptr) {
-        return;
-    }
-    int lx = x - cx * CHUNK_W;
-    int lz = z - cz * CHUNK_D;
-    size_t index = vox_index(lx, y, lz);
-
-    // block finalization
-    voxel& vox = chunk->voxels[(y * CHUNK_D + lz) * CHUNK_W + lx];
-    const auto& prevdef = indices->blocks.require(vox.id);
-    if (prevdef.inventorySize != 0) {
-        chunk->removeBlockInventory(lx, y, lz);
-    }
-    if (prevdef.rt.extended && !vox.state.segment) {
-        eraseSegments(prevdef, vox.state, x, y, z);
-    }
-    if (prevdef.dataStruct) {
-        if (auto found = chunk->blocksMetadata.find(index)) {
-            chunk->blocksMetadata.free(found);
-            chunk->flags.unsaved = true;
-            chunk->flags.blocksData = true;
-        }
-    }
-
-    // block initialization
-    const auto& newdef = indices->blocks.require(id);
-    vox.id = id;
-    vox.state = state;
-    chunk->setModifiedAndUnsaved();
-    if (!state.segment && newdef.rt.extended) {
-        repairSegments(newdef, state, x, y, z);
-    }
-
-    if (y < chunk->bottom)
-        chunk->bottom = y;
-    else if (y + 1 > chunk->top)
-        chunk->top = y + 1;
-    else if (id == 0)
-        chunk->updateHeights();
-
-    if (lx == 0 && (chunk = getChunk(cx - 1, cz))) {
-        chunk->flags.modified = true;
-    }
-    if (lz == 0 && (chunk = getChunk(cx, cz - 1))) {
-        chunk->flags.modified = true;
-    }
-    if (lx == CHUNK_W - 1 && (chunk = getChunk(cx + 1, cz))) {
-        chunk->flags.modified = true;
-    }
-    if (lz == CHUNK_D - 1 && (chunk = getChunk(cx, cz + 1))) {
-        chunk->flags.modified = true;
-    }
+    blocks_agent::set(*this, x, y, z, id, state);
 }
 
 voxel* Chunks::rayCast(
@@ -439,134 +212,9 @@ voxel* Chunks::rayCast(
     glm::ivec3& iend,
     std::set<blockid_t> filter
 ) const {
-    float px = start.x;
-    float py = start.y;
-    float pz = start.z;
-
-    float dx = dir.x;
-    float dy = dir.y;
-    float dz = dir.z;
-
-    float t = 0.0f;
-    int ix = std::floor(px);
-    int iy = std::floor(py);
-    int iz = std::floor(pz);
-
-    int stepx = (dx > 0.0f) ? 1 : -1;
-    int stepy = (dy > 0.0f) ? 1 : -1;
-    int stepz = (dz > 0.0f) ? 1 : -1;
-
-    constexpr float infinity = std::numeric_limits<float>::infinity();
-    constexpr float epsilon = 1e-6f;  // 0.000001
-    float txDelta = (std::fabs(dx) < epsilon) ? infinity : std::fabs(1.0f / dx);
-    float tyDelta = (std::fabs(dy) < epsilon) ? infinity : std::fabs(1.0f / dy);
-    float tzDelta = (std::fabs(dz) < epsilon) ? infinity : std::fabs(1.0f / dz);
-
-    float xdist = (stepx > 0) ? (ix + 1 - px) : (px - ix);
-    float ydist = (stepy > 0) ? (iy + 1 - py) : (py - iy);
-    float zdist = (stepz > 0) ? (iz + 1 - pz) : (pz - iz);
-
-    float txMax = (txDelta < infinity) ? txDelta * xdist : infinity;
-    float tyMax = (tyDelta < infinity) ? tyDelta * ydist : infinity;
-    float tzMax = (tzDelta < infinity) ? tzDelta * zdist : infinity;
-
-    int steppedIndex = -1;
-
-    while (t <= maxDist) {
-        voxel* voxel = get(ix, iy, iz);
-        if (voxel == nullptr) {
-            return nullptr;
-        }
-
-        const auto& def = indices->blocks.require(voxel->id);
-        if ((filter.empty() && def.selectable) ||
-            (!filter.empty() && filter.find(def.rt.id) == filter.end())) {
-            end.x = px + t * dx;
-            end.y = py + t * dy;
-            end.z = pz + t * dz;
-            iend.x = ix;
-            iend.y = iy;
-            iend.z = iz;
-
-            if (!def.rt.solid) {
-                const std::vector<AABB>& hitboxes =
-                    def.rotatable ? def.rt.hitboxes[voxel->state.rotation]
-                                  : def.hitboxes;
-
-                scalar_t distance = maxDist;
-                Ray ray(start, dir);
-
-                bool hit = false;
-
-                glm::vec3 offset {};
-                if (voxel->state.segment) {
-                    offset = seekOrigin(iend, def, voxel->state) - iend;
-                }
-
-                for (auto box : hitboxes) {
-                    box.a += offset;
-                    box.b += offset;
-                    scalar_t boxDistance;
-                    glm::ivec3 boxNorm;
-                    if (ray.intersectAABB(
-                            iend, box, maxDist, boxNorm, boxDistance
-                        ) > RayRelation::None &&
-                        boxDistance < distance) {
-                        hit = true;
-                        distance = boxDistance;
-                        norm = boxNorm;
-                        end = start + (dir * glm::vec3(distance));
-                    }
-                }
-
-                if (hit) return voxel;
-            } else {
-                iend.x = ix;
-                iend.y = iy;
-                iend.z = iz;
-
-                norm.x = norm.y = norm.z = 0;
-                if (steppedIndex == 0) norm.x = -stepx;
-                if (steppedIndex == 1) norm.y = -stepy;
-                if (steppedIndex == 2) norm.z = -stepz;
-                return voxel;
-            }
-        }
-        if (txMax < tyMax) {
-            if (txMax < tzMax) {
-                ix += stepx;
-                t = txMax;
-                txMax += txDelta;
-                steppedIndex = 0;
-            } else {
-                iz += stepz;
-                t = tzMax;
-                tzMax += tzDelta;
-                steppedIndex = 2;
-            }
-        } else {
-            if (tyMax < tzMax) {
-                iy += stepy;
-                t = tyMax;
-                tyMax += tyDelta;
-                steppedIndex = 1;
-            } else {
-                iz += stepz;
-                t = tzMax;
-                tzMax += tzDelta;
-                steppedIndex = 2;
-            }
-        }
-    }
-    iend.x = ix;
-    iend.y = iy;
-    iend.z = iz;
-
-    end.x = px + t * dx;
-    end.y = py + t * dy;
-    end.z = pz + t * dz;
-    norm.x = norm.y = norm.z = 0;
-    return nullptr;
+    return blocks_agent::raycast(
+        *this, start, dir, maxDist, end, norm, iend, std::move(filter)
+    );
 }
 
 glm::vec3 Chunks::rayCastToObstacle(
@@ -606,7 +254,7 @@ glm::vec3 Chunks::rayCastToObstacle(
     while (t <= maxDist) {
         voxel* voxel = get(ix, iy, iz);
         if (voxel) {
-            const auto& def = indices->blocks.require(voxel->id);
+            const auto& def = indices.blocks.require(voxel->id);
             if (def.obstacle) {
                 if (!def.rt.solid) {
                     const std::vector<AABB>& hitboxes =
@@ -673,30 +321,34 @@ void Chunks::resize(uint32_t newW, uint32_t newD) {
 }
 
 bool Chunks::putChunk(const std::shared_ptr<Chunk>& chunk) {
-    return areaMap.set(chunk->x, chunk->z, chunk);
+    if (areaMap.set(chunk->x, chunk->z, chunk)) {
+        if (events) {
+            events->trigger(LevelEventType::EVT_CHUNK_SHOWN, chunk.get());
+        }
+        return true;
+    }
+    return false;
 }
 
 // reduce nesting on next modification
 // 25.06.2024: not now
 // 11.11.2024: not now
-void Chunks::getVoxels(VoxelsVolume* volume, bool backlight) const {
-    const Content* content = level->content;
-    auto indices = content->getIndices();
-    voxel* voxels = volume->getVoxels();
-    light_t* lights = volume->getLights();
-    int x = volume->getX();
-    int y = volume->getY();
-    int z = volume->getZ();
+void Chunks::getVoxels(VoxelsVolume& volume, bool backlight) const {
+    voxel* voxels = volume.getVoxels();
+    light_t* lights = volume.getLights();
+    int x = volume.getX();
+    int y = volume.getY();
+    int z = volume.getZ();
 
-    int w = volume->getW();
-    int h = volume->getH();
-    int d = volume->getD();
+    int w = volume.getW();
+    int h = volume.getH();
+    int d = volume.getD();
 
-    int scx = floordiv(x, CHUNK_W);
-    int scz = floordiv(z, CHUNK_D);
+    int scx = floordiv<CHUNK_W>(x);
+    int scz = floordiv<CHUNK_D>(z);
 
-    int ecx = floordiv(x + w, CHUNK_W);
-    int ecz = floordiv(z + d, CHUNK_D);
+    int ecx = floordiv<CHUNK_W>(x + w);
+    int ecz = floordiv<CHUNK_D>(z + d);
 
     int cw = ecx - scx + 1;
     int cd = ecz - scz + 1;
@@ -742,7 +394,7 @@ void Chunks::getVoxels(VoxelsVolume* volume, bool backlight) const {
                             light_t light = clights[cidx];
                             if (backlight) {
                                 const auto block =
-                                    indices->blocks.get(voxels[vidx].id);
+                                    indices.blocks.get(voxels[vidx].id);
                                 if (block && block->lightPassing) {
                                     light = Lightmap::combine(
                                         std::min(15,
@@ -768,35 +420,3 @@ void Chunks::getVoxels(VoxelsVolume* volume, bool backlight) const {
 void Chunks::saveAndClear() {
     areaMap.clear();
 }
-
-void Chunks::save(Chunk* chunk) {
-    if (chunk != nullptr) {
-        AABB aabb(
-            glm::vec3(chunk->x * CHUNK_W, -INFINITY, chunk->z * CHUNK_D),
-            glm::vec3(
-                (chunk->x + 1) * CHUNK_W, INFINITY, (chunk->z + 1) * CHUNK_D
-            )
-        );
-        auto entities = level->entities->getAllInside(aabb);
-        auto root = dv::object();
-        root["data"] = level->entities->serialize(entities);
-        if (!entities.empty()) {
-            level->entities->despawn(std::move(entities));
-            chunk->flags.entities = true;
-        }
-        worldFiles->getRegions().put(
-            chunk,
-            chunk->flags.entities ? json::to_binary(root, true)
-                                  : std::vector<ubyte>()
-        );
-    }
-}
-
-void Chunks::saveAll() {
-    const auto& chunks = areaMap.getBuffer();
-    for (size_t i = 0; i < areaMap.area(); i++) {
-        if (auto& chunk = chunks[i]) {
-            save(chunk.get());
-        }
-    }
-}
diff --git a/src/voxels/Chunks.hpp b/src/voxels/Chunks.hpp
index 01648301a..172cc3299 100644
--- a/src/voxels/Chunks.hpp
+++ b/src/voxels/Chunks.hpp
@@ -20,13 +20,12 @@ class Chunk;
 class WorldFiles;
 class LevelEvents;
 class Block;
-class Level;
 class VoxelsVolume;
 
 /// Player-centred chunks matrix
 class Chunks {
-    Level* level;
-    const ContentIndices* const indices;
+    LevelEvents* events;
+    const ContentIndices& indices;
 
     void eraseSegments(const Block& def, blockstate state, int x, int y, int z);
     void repairSegments(
@@ -40,22 +39,31 @@ class Chunks {
     );
 
     util::AreaMap2D<std::shared_ptr<Chunk>, int32_t> areaMap;
-    WorldFiles* worldFiles;
 public:
     Chunks(
         int32_t w,
         int32_t d,
         int32_t ox,
         int32_t oz,
-        WorldFiles* worldFiles,
-        Level* level
+        LevelEvents* events,
+        const ContentIndices& indices
     );
     ~Chunks() = default;
 
+    void configure(int32_t x, int32_t z, uint32_t radius);
+
     bool putChunk(const std::shared_ptr<Chunk>& chunk);
 
     Chunk* getChunk(int32_t x, int32_t z) const;
     Chunk* getChunkByVoxel(int32_t x, int32_t y, int32_t z) const;
+
+    template <typename T>
+    Chunk* getChunkByVoxel(const glm::vec<3, T>& pos) const {
+        return getChunkByVoxel(
+            glm::floor(pos.x), glm::floor(pos.y), glm::floor(pos.z)
+        );
+    }
+
     voxel* get(int32_t x, int32_t y, int32_t z) const;
     voxel& require(int32_t x, int32_t y, int32_t z) const;
 
@@ -118,14 +126,12 @@ class Chunks {
     bool isReplaceableBlock(int32_t x, int32_t y, int32_t z);
     bool isObstacleBlock(int32_t x, int32_t y, int32_t z);
 
-    void getVoxels(VoxelsVolume* volume, bool backlight = false) const;
+    void getVoxels(VoxelsVolume& volume, bool backlight = false) const;
 
     void setCenter(int32_t x, int32_t z);
     void resize(uint32_t newW, uint32_t newD);
 
     void saveAndClear();
-    void save(Chunk* chunk);
-    void saveAll();
 
     const std::vector<std::shared_ptr<Chunk>>& getChunks() const {
         return areaMap.getBuffer();
@@ -154,4 +160,12 @@ class Chunks {
     size_t getVolume() const {
         return areaMap.area();
     }
+
+    const ContentIndices& getContentIndices() const {
+        return indices;
+    }
+
+    static inline constexpr unsigned matrixSize(int loadDistance, int padding) {
+        return (loadDistance + padding) * 2;
+    }
 };
diff --git a/src/voxels/ChunksStorage.cpp b/src/voxels/ChunksStorage.cpp
deleted file mode 100644
index 272332fb3..000000000
--- a/src/voxels/ChunksStorage.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-#include "ChunksStorage.hpp"
-
-#include <algorithm>
-
-#include "content/Content.hpp"
-#include "debug/Logger.hpp"
-#include "files/WorldFiles.hpp"
-#include "items/Inventories.hpp"
-#include "lighting/Lightmap.hpp"
-#include "maths/voxmaths.hpp"
-#include "objects/Entities.hpp"
-#include "typedefs.hpp"
-#include "world/Level.hpp"
-#include "world/World.hpp"
-#include "Block.hpp"
-#include "Chunk.hpp"
-
-static debug::Logger logger("chunks-storage");
-
-ChunksStorage::ChunksStorage(Level* level) : level(level) {
-}
-
-void ChunksStorage::store(const std::shared_ptr<Chunk>& chunk) {
-    chunksMap[glm::ivec2(chunk->x, chunk->z)] = chunk;
-}
-
-std::shared_ptr<Chunk> ChunksStorage::get(int x, int z) const {
-    auto found = chunksMap.find(glm::ivec2(x, z));
-    if (found == chunksMap.end()) {
-        return nullptr;
-    }
-    return found->second;
-}
-
-void ChunksStorage::remove(int x, int z) {
-    auto found = chunksMap.find(glm::ivec2(x, z));
-    if (found != chunksMap.end()) {
-        chunksMap.erase(found->first);
-    }
-}
-
-static void check_voxels(const ContentIndices& indices, Chunk* chunk) {
-    for (size_t i = 0; i < CHUNK_VOL; i++) {
-        blockid_t id = chunk->voxels[i].id;
-        if (indices.blocks.get(id) == nullptr) {
-            auto logline = logger.error();
-            logline << "corruped block detected at " << i << " of chunk ";
-            logline << chunk->x << "x" << chunk->z;
-            logline << " -> " << id;
-            chunk->voxels[i].id = BLOCK_AIR;
-        }
-    }
-}
-
-std::shared_ptr<Chunk> ChunksStorage::create(int x, int z) {
-    World* world = level->getWorld();
-    auto& regions = world->wfile.get()->getRegions();
-
-    auto chunk = std::make_shared<Chunk>(x, z);
-    store(chunk);
-    if (auto data = regions.getVoxels(chunk->x, chunk->z)) {
-        const auto& indices = *level->content->getIndices();
-
-        chunk->decode(data.get());
-        check_voxels(indices, chunk.get());
-
-        auto invs = regions.fetchInventories(chunk->x, chunk->z);
-        auto iterator = invs.begin();
-        while (iterator != invs.end()) {
-            uint index = iterator->first;
-            const auto& def = indices.blocks.require(chunk->voxels[index].id);
-            if (def.inventorySize == 0) {
-                iterator = invs.erase(iterator);
-                continue;
-            }
-            auto& inventory = iterator->second;
-            if (def.inventorySize != inventory->size()) {
-                inventory->resize(def.inventorySize);
-            }
-            ++iterator;
-        }
-        chunk->setBlockInventories(std::move(invs));
-
-        auto entitiesData = regions.fetchEntities(chunk->x, chunk->z);
-        if (entitiesData.getType() == dv::value_type::object) {
-            level->entities->loadEntities(std::move(entitiesData));
-            chunk->flags.entities = true;
-        }
-
-        chunk->flags.loaded = true;
-        for (auto& entry : chunk->inventories) {
-            level->inventories->store(entry.second);
-        }
-    }
-    if (auto lights = regions.getLights(chunk->x, chunk->z)) {
-        chunk->lightmap.set(lights.get());
-        chunk->flags.loadedLights = true;
-    }
-    chunk->blocksMetadata = regions.getBlocksData(chunk->x, chunk->z);
-    return chunk;
-}
diff --git a/src/voxels/ChunksStorage.hpp b/src/voxels/ChunksStorage.hpp
deleted file mode 100644
index 35fff6c1d..000000000
--- a/src/voxels/ChunksStorage.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <unordered_map>
-
-#include "typedefs.hpp"
-#include "voxel.hpp"
-
-#define GLM_ENABLE_EXPERIMENTAL
-#include <glm/gtx/hash.hpp>
-
-class Chunk;
-class Level;
-
-class ChunksStorage {
-    Level* level;
-    std::unordered_map<glm::ivec2, std::shared_ptr<Chunk>> chunksMap;
-public:
-    ChunksStorage(Level* level);
-    ~ChunksStorage() = default;
-
-    std::shared_ptr<Chunk> get(int x, int z) const;
-    void store(const std::shared_ptr<Chunk>& chunk);
-    void remove(int x, int y);
-    std::shared_ptr<Chunk> create(int x, int z);
-};
diff --git a/src/voxels/GlobalChunks.cpp b/src/voxels/GlobalChunks.cpp
new file mode 100644
index 000000000..8f8e05bb1
--- /dev/null
+++ b/src/voxels/GlobalChunks.cpp
@@ -0,0 +1,206 @@
+#include "GlobalChunks.hpp"
+
+#include <algorithm>
+
+#include "content/Content.hpp"
+#include "coders/json.hpp"
+#include "debug/Logger.hpp"
+#include "files/WorldFiles.hpp"
+#include "items/Inventories.hpp"
+#include "lighting/Lightmap.hpp"
+#include "maths/voxmaths.hpp"
+#include "objects/Entities.hpp"
+#include "voxels/blocks_agent.hpp"
+#include "typedefs.hpp"
+#include "world/Level.hpp"
+#include "world/World.hpp"
+#include "Block.hpp"
+#include "Chunk.hpp"
+
+static debug::Logger logger("chunks-storage");
+
+GlobalChunks::GlobalChunks(Level& level)
+    : level(level), indices(*level.content.getIndices()) {
+    chunksMap.max_load_factor(CHUNKS_MAP_MAX_LOAD_FACTOR);
+}
+
+void GlobalChunks::setOnUnload(consumer<Chunk&> onUnload) {
+    this->onUnload = std::move(onUnload);
+}
+
+std::shared_ptr<Chunk> GlobalChunks::fetch(int x, int z) {
+    const auto& found = chunksMap.find(keyfrom(x, z));
+    if (found == chunksMap.end()) {
+        return nullptr;
+    }
+    return found->second;
+}
+
+static void check_voxels(const ContentIndices& indices, Chunk& chunk) {
+    bool corrupted = false;
+    blockid_t defsCount = indices.blocks.count();
+    for (size_t i = 0; i < CHUNK_VOL; i++) {
+        blockid_t id = chunk.voxels[i].id;
+        if (id >= defsCount) {
+            if (!corrupted) {
+#ifdef NDEBUG
+                // release
+                auto logline = logger.error();
+                logline << "corruped blocks detected at " << i << " of chunk ";
+                logline << chunk.x << "x" << chunk.z;
+                logline << " -> " << id;
+                corrupted = true;
+#else
+                // debug
+                abort();
+#endif
+            }
+            chunk.voxels[i].id = BLOCK_AIR;
+        }
+    }
+}
+
+void GlobalChunks::erase(int x, int z) {
+    chunksMap.erase(keyfrom(x, z));
+}
+
+static inline auto load_inventories(
+    WorldRegions& regions,
+    const Chunk& chunk,
+    const ContentUnitIndices<Block>& defs
+) {
+    auto invs = regions.fetchInventories(chunk.x, chunk.z);
+    auto iterator = invs.begin();
+    while (iterator != invs.end()) {
+        uint index = iterator->first;
+        const auto& def = defs.require(chunk.voxels[index].id);
+        if (def.inventorySize == 0) {
+            iterator = invs.erase(iterator);
+            continue;
+        }
+        auto& inventory = iterator->second;
+        if (def.inventorySize != inventory->size()) {
+            inventory->resize(def.inventorySize);
+        }
+        ++iterator;
+    }
+    return invs;
+}
+
+std::shared_ptr<Chunk> GlobalChunks::create(int x, int z) {
+    const auto& found = chunksMap.find(keyfrom(x, z));
+    if (found != chunksMap.end()) {
+        return found->second;
+    }
+
+    auto chunk = std::make_shared<Chunk>(x, z);
+    chunksMap[keyfrom(x, z)] = chunk;
+
+    World& world = *level.getWorld();
+    auto& regions = world.wfile.get()->getRegions();
+
+    if (auto data = regions.getVoxels(chunk->x, chunk->z)) {
+        const auto& indices = *level.content.getIndices();
+
+        chunk->decode(data.get());
+        check_voxels(indices, *chunk);
+
+        chunk->setBlockInventories(
+            load_inventories(regions, *chunk, indices.blocks)
+        );
+
+        auto entitiesData = regions.fetchEntities(chunk->x, chunk->z);
+        if (entitiesData.getType() == dv::value_type::object) {
+            level.entities->loadEntities(std::move(entitiesData));
+            chunk->flags.entities = true;
+        }
+
+        chunk->flags.loaded = true;
+        for (auto& entry : chunk->inventories) {
+            level.inventories->store(entry.second);
+        }
+    }
+    if (auto lights = regions.getLights(chunk->x, chunk->z)) {
+        chunk->lightmap.set(lights.get());
+        chunk->flags.loadedLights = true;
+    }
+    chunk->blocksMetadata = regions.getBlocksData(chunk->x, chunk->z);
+    return chunk;
+}
+
+void GlobalChunks::pinChunk(std::shared_ptr<Chunk> chunk) {
+    pinnedChunks[{chunk->x, chunk->z}] = std::move(chunk);
+}
+
+void GlobalChunks::unpinChunk(int x, int z) {
+    pinnedChunks.erase({x, z});
+}
+
+size_t GlobalChunks::size() const {
+    return chunksMap.size();
+}
+
+void GlobalChunks::incref(Chunk* chunk) {
+    auto key = reinterpret_cast<ptrdiff_t>(chunk);
+    const auto& found = refCounters.find(key);
+    if (found == refCounters.end()) {
+        refCounters[key] = 1;
+        return;
+    }
+    found->second++;
+}
+
+void GlobalChunks::decref(Chunk* chunk) {
+    auto key = reinterpret_cast<ptrdiff_t>(chunk);
+    const auto& found = refCounters.find(key);
+    if (found == refCounters.end()) {
+        abort();
+    }
+    if (--found->second == 0) {
+        union {
+            int pos[2];
+            long long key;
+        } ekey;
+        ekey.pos[0] = chunk->x;
+        ekey.pos[1] = chunk->z;
+
+        if (onUnload) {
+            onUnload(*chunk);
+        }
+        save(chunk);
+        chunksMap.erase(ekey.key);
+        refCounters.erase(found);
+    }
+}
+
+void GlobalChunks::save(Chunk* chunk) {
+    if (chunk == nullptr) {
+        return;
+    }
+    AABB aabb = chunk->getAABB();
+    auto entities = level.entities->getAllInside(aabb);
+    auto root = dv::object();
+    root["data"] = level.entities->serialize(entities);
+    if (!entities.empty()) {
+        chunk->flags.entities = true;
+    }
+    level.getWorld()->wfile->getRegions().put(
+        chunk,
+        chunk->flags.entities ? json::to_binary(root, true)
+                                : std::vector<ubyte>()
+    );
+}
+
+void GlobalChunks::saveAll() {
+    for (const auto& [_, chunk] : chunksMap) {
+        save(chunk.get());
+    }
+}
+
+void GlobalChunks::putChunk(std::shared_ptr<Chunk> chunk) {
+    chunksMap[keyfrom(chunk->x, chunk->z)] = std::move(chunk);
+}
+
+const AABB* GlobalChunks::isObstacleAt(float x, float y, float z) const {
+    return blocks_agent::is_obstacle_at(*this, x, y, z);
+}
diff --git a/src/voxels/GlobalChunks.hpp b/src/voxels/GlobalChunks.hpp
new file mode 100644
index 000000000..1a554dfd5
--- /dev/null
+++ b/src/voxels/GlobalChunks.hpp
@@ -0,0 +1,73 @@
+#pragma once
+
+#include <memory>
+#include <unordered_map>
+
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/glm.hpp>
+#include <glm/gtx/hash.hpp>
+
+#include "voxel.hpp"
+#include "delegates.hpp"
+
+class Chunk;
+class Level;
+struct AABB;
+class ContentIndices;
+
+class GlobalChunks {
+    static inline uint64_t keyfrom(int32_t x, int32_t z) {
+        union {
+            int32_t pos[2];
+            uint64_t key;
+        } ekey;
+        ekey.pos[0] = x;
+        ekey.pos[1] = z;
+        return ekey.key;
+    }
+
+    Level& level;
+    const ContentIndices& indices;
+    std::unordered_map<uint64_t, std::shared_ptr<Chunk>> chunksMap;
+    std::unordered_map<glm::ivec2, std::shared_ptr<Chunk>> pinnedChunks;
+    std::unordered_map<ptrdiff_t, int> refCounters;
+
+    consumer<Chunk&> onUnload;
+public:
+    GlobalChunks(Level& level);
+    ~GlobalChunks() = default;
+
+    void setOnUnload(consumer<Chunk&> onUnload);
+
+    std::shared_ptr<Chunk> fetch(int x, int z);
+    std::shared_ptr<Chunk> create(int x, int z);
+
+    void pinChunk(std::shared_ptr<Chunk> chunk);
+    void unpinChunk(int x, int z);
+
+    size_t size() const;
+
+    void incref(Chunk* chunk);
+    void decref(Chunk* chunk);
+
+    void erase(int x, int z);
+
+    void save(Chunk* chunk);
+    void saveAll();
+
+    void putChunk(std::shared_ptr<Chunk> chunk);
+
+    const AABB* isObstacleAt(float x, float y, float z) const;
+
+    inline Chunk* getChunk(int cx, int cz) const {
+        const auto& found = chunksMap.find(keyfrom(cx, cz));
+        if (found == chunksMap.end()) {
+            return nullptr;
+        }
+        return found->second.get();
+    }
+
+    const ContentIndices& getContentIndices() const {
+        return indices;
+    }
+};
diff --git a/src/voxels/blocks_agent.cpp b/src/voxels/blocks_agent.cpp
new file mode 100644
index 000000000..a23fa9efe
--- /dev/null
+++ b/src/voxels/blocks_agent.cpp
@@ -0,0 +1,369 @@
+#include "blocks_agent.hpp"
+
+#include "maths/rays.hpp"
+
+#include <limits>
+
+using namespace blocks_agent;
+
+template <class Storage>
+static inline void set_block(
+    Storage& chunks,
+    int32_t x,
+    int32_t y,
+    int32_t z,
+    uint32_t id,
+    blockstate state
+) {
+    if (y < 0 || y >= CHUNK_H) {
+        return;
+    }
+    const auto& indices = chunks.getContentIndices();
+    int cx = floordiv<CHUNK_W>(x);
+    int cz = floordiv<CHUNK_D>(z);
+    Chunk* chunk = get_chunk(chunks, cx, cz);
+    if (chunk == nullptr) {
+        return;
+    }
+    int lx = x - cx * CHUNK_W;
+    int lz = z - cz * CHUNK_D;
+    size_t index = vox_index(lx, y, lz);
+
+    // block finalization
+    voxel& vox = chunk->voxels[(y * CHUNK_D + lz) * CHUNK_W + lx];
+    const auto& prevdef = indices.blocks.require(vox.id);
+    if (prevdef.inventorySize != 0) {
+        chunk->removeBlockInventory(lx, y, lz);
+    }
+    if (prevdef.rt.extended && !vox.state.segment) {
+        erase_segments(chunks, prevdef, vox.state, x, y, z);
+    }
+    if (prevdef.dataStruct) {
+        if (auto found = chunk->blocksMetadata.find(index)) {
+            chunk->blocksMetadata.free(found);
+            chunk->flags.unsaved = true;
+            chunk->flags.blocksData = true;
+        }
+    }
+
+    // block initialization
+    const auto& newdef = indices.blocks.require(id);
+    vox.id = id;
+    vox.state = state;
+    chunk->setModifiedAndUnsaved();
+    if (!state.segment && newdef.rt.extended) {
+        repair_segments(chunks, newdef, state, x, y, z);
+    }
+
+    if (y < chunk->bottom)
+        chunk->bottom = y;
+    else if (y + 1 > chunk->top)
+        chunk->top = y + 1;
+    else if (id == 0)
+        chunk->updateHeights();
+
+    if (lx == 0 && (chunk = get_chunk(chunks, cx - 1, cz))) {
+        chunk->flags.modified = true;
+    }
+    if (lz == 0 && (chunk = get_chunk(chunks, cx, cz - 1))) {
+        chunk->flags.modified = true;
+    }
+    if (lx == CHUNK_W - 1 && (chunk = get_chunk(chunks, cx + 1, cz))) {
+        chunk->flags.modified = true;
+    }
+    if (lz == CHUNK_D - 1 && (chunk = get_chunk(chunks, cx, cz + 1))) {
+        chunk->flags.modified = true;
+    }
+}
+
+void blocks_agent::set(
+    Chunks& chunks,
+    int32_t x,
+    int32_t y,
+    int32_t z,
+    uint32_t id,
+    blockstate state
+) {
+    set_block(chunks, x, y, z, id, state);
+}
+
+void blocks_agent::set(
+    GlobalChunks& chunks,
+    int32_t x,
+    int32_t y,
+    int32_t z,
+    uint32_t id,
+    blockstate state
+) {
+    set_block(chunks, x, y, z, id, state);
+}
+
+template <class Storage>
+static inline voxel* raycast_blocks(
+    const Storage& chunks,
+    const glm::vec3& start,
+    const glm::vec3& dir,
+    float maxDist,
+    glm::vec3& end,
+    glm::ivec3& norm,
+    glm::ivec3& iend,
+    std::set<blockid_t> filter
+) {
+    const auto& blocks = chunks.getContentIndices().blocks;
+    float px = start.x;
+    float py = start.y;
+    float pz = start.z;
+
+    float dx = dir.x;
+    float dy = dir.y;
+    float dz = dir.z;
+
+    float t = 0.0f;
+    int ix = std::floor(px);
+    int iy = std::floor(py);
+    int iz = std::floor(pz);
+
+    int stepx = (dx > 0.0f) ? 1 : -1;
+    int stepy = (dy > 0.0f) ? 1 : -1;
+    int stepz = (dz > 0.0f) ? 1 : -1;
+
+    constexpr float infinity = std::numeric_limits<float>::infinity();
+    constexpr float epsilon = 1e-6f;  // 0.000001
+    float txDelta = (std::fabs(dx) < epsilon) ? infinity : std::fabs(1.0f / dx);
+    float tyDelta = (std::fabs(dy) < epsilon) ? infinity : std::fabs(1.0f / dy);
+    float tzDelta = (std::fabs(dz) < epsilon) ? infinity : std::fabs(1.0f / dz);
+
+    float xdist = (stepx > 0) ? (ix + 1 - px) : (px - ix);
+    float ydist = (stepy > 0) ? (iy + 1 - py) : (py - iy);
+    float zdist = (stepz > 0) ? (iz + 1 - pz) : (pz - iz);
+
+    float txMax = (txDelta < infinity) ? txDelta * xdist : infinity;
+    float tyMax = (tyDelta < infinity) ? tyDelta * ydist : infinity;
+    float tzMax = (tzDelta < infinity) ? tzDelta * zdist : infinity;
+
+    int steppedIndex = -1;
+
+    while (t <= maxDist) {
+        voxel* voxel = get(chunks, ix, iy, iz);
+        if (voxel == nullptr) {
+            return nullptr;
+        }
+
+        const auto& def = blocks.require(voxel->id);
+        if ((filter.empty() && def.selectable) ||
+            (!filter.empty() && filter.find(def.rt.id) == filter.end())) {
+            end.x = px + t * dx;
+            end.y = py + t * dy;
+            end.z = pz + t * dz;
+            iend.x = ix;
+            iend.y = iy;
+            iend.z = iz;
+
+            if (!def.rt.solid) {
+                const std::vector<AABB>& hitboxes =
+                    def.rotatable ? def.rt.hitboxes[voxel->state.rotation]
+                                  : def.hitboxes;
+
+                scalar_t distance = maxDist;
+                Ray ray(start, dir);
+
+                bool hit = false;
+
+                glm::vec3 offset {};
+                if (voxel->state.segment) {
+                    offset = seek_origin(chunks, iend, def, voxel->state) - iend;
+                }
+
+                for (auto box : hitboxes) {
+                    box.a += offset;
+                    box.b += offset;
+                    scalar_t boxDistance;
+                    glm::ivec3 boxNorm;
+                    if (ray.intersectAABB(
+                            iend, box, maxDist, boxNorm, boxDistance
+                        ) > RayRelation::None &&
+                        boxDistance < distance) {
+                        hit = true;
+                        distance = boxDistance;
+                        norm = boxNorm;
+                        end = start + (dir * glm::vec3(distance));
+                    }
+                }
+
+                if (hit) return voxel;
+            } else {
+                iend.x = ix;
+                iend.y = iy;
+                iend.z = iz;
+
+                norm.x = norm.y = norm.z = 0;
+                if (steppedIndex == 0) norm.x = -stepx;
+                if (steppedIndex == 1) norm.y = -stepy;
+                if (steppedIndex == 2) norm.z = -stepz;
+                return voxel;
+            }
+        }
+        if (txMax < tyMax) {
+            if (txMax < tzMax) {
+                ix += stepx;
+                t = txMax;
+                txMax += txDelta;
+                steppedIndex = 0;
+            } else {
+                iz += stepz;
+                t = tzMax;
+                tzMax += tzDelta;
+                steppedIndex = 2;
+            }
+        } else {
+            if (tyMax < tzMax) {
+                iy += stepy;
+                t = tyMax;
+                tyMax += tyDelta;
+                steppedIndex = 1;
+            } else {
+                iz += stepz;
+                t = tzMax;
+                tzMax += tzDelta;
+                steppedIndex = 2;
+            }
+        }
+    }
+    iend.x = ix;
+    iend.y = iy;
+    iend.z = iz;
+
+    end.x = px + t * dx;
+    end.y = py + t * dy;
+    end.z = pz + t * dz;
+    norm.x = norm.y = norm.z = 0;
+    return nullptr;
+}
+
+voxel* blocks_agent::raycast(
+    const Chunks& chunks,
+    const glm::vec3& start,
+    const glm::vec3& dir,
+    float maxDist,
+    glm::vec3& end,
+    glm::ivec3& norm,
+    glm::ivec3& iend,
+    std::set<blockid_t> filter
+) {
+    return raycast_blocks(chunks, start, dir, maxDist, end, norm, iend, filter);
+}
+
+voxel* blocks_agent::raycast(
+    const GlobalChunks& chunks,
+    const glm::vec3& start,
+    const glm::vec3& dir,
+    float maxDist,
+    glm::vec3& end,
+    glm::ivec3& norm,
+    glm::ivec3& iend,
+    std::set<blockid_t> filter
+) {
+    return raycast_blocks(chunks, start, dir, maxDist, end, norm, iend, filter);
+}
+
+// reduce nesting on next modification
+// 25.06.2024: not now
+// 11.11.2024: not now
+template <class Storage>
+inline void get_voxels_impl(
+    const Storage& chunks, VoxelsVolume* volume, bool backlight
+) {
+    const auto& blocks = chunks.getContentIndices().blocks;
+    voxel* voxels = volume->getVoxels();
+    light_t* lights = volume->getLights();
+    int x = volume->getX();
+    int y = volume->getY();
+    int z = volume->getZ();
+
+    int w = volume->getW();
+    int h = volume->getH();
+    int d = volume->getD();
+
+    int scx = floordiv<CHUNK_W>(x);
+    int scz = floordiv<CHUNK_D>(z);
+
+    int ecx = floordiv<CHUNK_W>(x + w);
+    int ecz = floordiv<CHUNK_D>(z + d);
+
+    int cw = ecx - scx + 1;
+    int cd = ecz - scz + 1;
+
+    // cw*cd chunks will be scanned
+    for (int cz = scz; cz < scz + cd; cz++) {
+        for (int cx = scx; cx < scx + cw; cx++) {
+            const auto chunk = get_chunk(chunks, cx, cz);
+            if (chunk == nullptr) {
+                // no chunk loaded -> filling with BLOCK_VOID
+                for (int ly = y; ly < y + h; ly++) {
+                    for (int lz = std::max(z, cz * CHUNK_D);
+                             lz < std::min(z + d, (cz + 1) * CHUNK_D);
+                             lz++) {
+                        for (int lx = std::max(x, cx * CHUNK_W);
+                                 lx < std::min(x + w, (cx + 1) * CHUNK_W);
+                                 lx++) {
+                            uint idx = vox_index(lx - x, ly - y, lz - z, w, d);
+                            voxels[idx].id = BLOCK_VOID;
+                            lights[idx] = 0;
+                        }
+                    }
+                }
+            } else {
+                const voxel* cvoxels = chunk->voxels;
+                const light_t* clights = chunk->lightmap.getLights();
+                for (int ly = y; ly < y + h; ly++) {
+                    for (int lz = std::max(z, cz * CHUNK_D);
+                             lz < std::min(z + d, (cz + 1) * CHUNK_D);
+                             lz++) {
+                        for (int lx = std::max(x, cx * CHUNK_W);
+                                 lx < std::min(x + w, (cx + 1) * CHUNK_W);
+                                 lx++) {
+                            uint vidx = vox_index(lx - x, ly - y, lz - z, w, d);
+                            uint cidx = vox_index(
+                                lx - cx * CHUNK_W,
+                                ly,
+                                lz - cz * CHUNK_D,
+                                CHUNK_W,
+                                CHUNK_D
+                            );
+                            voxels[vidx] = cvoxels[cidx];
+                            light_t light = clights[cidx];
+                            if (backlight) {
+                                const auto block = blocks.get(voxels[vidx].id);
+                                if (block && block->lightPassing) {
+                                    light = Lightmap::combine(
+                                        std::min(15,
+                                            Lightmap::extract(light, 0) + 1),
+                                        std::min(15,
+                                            Lightmap::extract(light, 1) + 1),
+                                        std::min(15,
+                                            Lightmap::extract(light, 2) + 1),
+                                        std::min(15, 
+                                            static_cast<int>(Lightmap::extract(light, 3)))
+                                    );
+                                }
+                            }
+                            lights[vidx] = light;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+void blocks_agent::get_voxels(
+    const Chunks& chunks, VoxelsVolume* volume, bool backlight
+) {
+    get_voxels_impl(chunks, volume, backlight);
+}
+
+void blocks_agent::get_voxels(
+    const GlobalChunks& chunks, VoxelsVolume* volume, bool backlight
+) {
+    get_voxels_impl(chunks, volume, backlight);
+}
diff --git a/src/voxels/blocks_agent.hpp b/src/voxels/blocks_agent.hpp
new file mode 100644
index 000000000..15813bc93
--- /dev/null
+++ b/src/voxels/blocks_agent.hpp
@@ -0,0 +1,476 @@
+#pragma once
+
+/// blocks_agent is set of templates but not a class to minimize OOP overhead.
+
+#include "voxel.hpp"
+#include "Block.hpp"
+#include "Chunk.hpp"
+#include "Chunks.hpp"
+#include "VoxelsVolume.hpp"
+#include "GlobalChunks.hpp"
+#include "constants.hpp"
+#include "typedefs.hpp"
+#include "content/Content.hpp"
+#include "maths/voxmaths.hpp"
+
+#include <set>
+#include <stdint.h>
+#include <stdexcept>
+#include <glm/glm.hpp>
+
+struct AABB;
+
+namespace blocks_agent {
+
+/// @brief Get specified chunk.
+/// @tparam Storage 
+/// @param chunks 
+/// @param cx chunk grid position X
+/// @param cz chunk grid position Z
+/// @return chunk or nullptr if does not exists
+template<class Storage>
+inline Chunk* get_chunk(const Storage& chunks, int cx, int cz) {
+    return chunks.getChunk(cx, cz);
+}
+
+/// @brief Get voxel at specified position.
+/// Returns nullptr if voxel does not exists. 
+/// @tparam Storage chunks storage class
+/// @param chunks chunks storage
+/// @param x position X
+/// @param y position Y
+/// @param z position Z
+/// @return voxel pointer or nullptr
+template<class Storage>
+inline voxel* get(const Storage& chunks, int32_t x, int32_t y, int32_t z) {
+    if (y < 0 || y >= CHUNK_H) {
+        return nullptr;
+    }
+    int cx = floordiv<CHUNK_W>(x);
+    int cz = floordiv<CHUNK_D>(z);
+    Chunk* chunk = get_chunk(chunks, cx, cz);
+    if (chunk == nullptr) {
+        return nullptr;
+    }
+    int lx = x - cx * CHUNK_W;
+    int lz = z - cz * CHUNK_D;
+    return &chunk->voxels[(y * CHUNK_D + lz) * CHUNK_W + lx];
+}
+
+/// @brief Get voxel at specified position.
+/// @throws std::runtime_error if voxel does not exists
+/// @tparam Storage chunks storage class
+/// @param chunks chunks storage
+/// @param x position X
+/// @param y position Y
+/// @param z position Z
+/// @return voxel reference
+template<class Storage>
+inline voxel& require(const Storage& chunks, int32_t x, int32_t y, int32_t z) {
+    auto vox = get(chunks, x, y, z);
+    if (vox == nullptr) {
+        throw std::runtime_error("voxel does not exist");
+    }
+    return *vox;
+}
+
+template<class Storage>
+inline const Block& get_block_def(const Storage& chunks, blockid_t id) {
+    return chunks.getContentIndices().blocks.require(id);
+}
+
+
+/// @brief Check if block at specified position is solid.
+/// @tparam Storage chunks storage class
+/// @param chunks chunks storage
+/// @param x position X
+/// @param y position Y
+/// @param z position Z
+/// @return true if block exists and solid
+template<class Storage>
+inline bool is_solid_at(const Storage& chunks, int32_t x, int32_t y, int32_t z) {
+    if (auto vox = get(chunks, x, y, z)) {
+        return get_block_def(chunks, vox->id).rt.solid;
+    }
+    return false;
+}
+
+/// @brief Check if block at specified position is replaceable.
+/// @tparam Storage chunks storage class
+/// @param chunks chunks storage
+/// @param x position X
+/// @param y position Y
+/// @param z position Z
+/// @return true if block exists and replaceable
+template<class Storage>
+inline bool is_replaceable_at(const Storage& chunks, int32_t x, int32_t y, int32_t z) {
+    if (auto vox = get(chunks, x, y, z)) {
+        return get_block_def(chunks, vox->id).replaceable;
+    }
+    return false;
+}
+
+/// @brief Set block at specified position if voxel exists.
+/// @param chunks chunks matrix
+/// @param x block position X
+/// @param y block position Y
+/// @param z block position Z
+/// @param id new block id
+/// @param state new block state
+void set(
+    Chunks& chunks,
+    int32_t x,
+    int32_t y,
+    int32_t z,
+    uint32_t id,
+    blockstate state
+);
+
+/// @brief Set block at specified position if voxel exists.
+/// @param chunks chunks storage
+/// @param x block position X
+/// @param y block position Y
+/// @param z block position Z
+/// @param id new block id
+/// @param state new block state
+void set(
+    GlobalChunks& chunks,
+    int32_t x,
+    int32_t y,
+    int32_t z,
+    uint32_t id,
+    blockstate state
+);
+
+/// @brief Erase extended block segments
+/// @tparam Storage chunks storage class
+/// @param chunks chunks storage
+/// @param def origin block definition
+/// @param state origin block state
+/// @param x origin position X
+/// @param y origin position Y
+/// @param z origin position Z
+template<class Storage>
+inline void erase_segments(
+    Storage& chunks, const Block& def, blockstate state, int x, int y, int z
+) {
+    const auto& rotation = def.rotations.variants[state.rotation];
+    for (int sy = 0; sy < def.size.y; sy++) {
+        for (int sz = 0; sz < def.size.z; sz++) {
+            for (int sx = 0; sx < def.size.x; sx++) {
+                if ((sx | sy | sz) == 0) {
+                    continue;
+                }
+                glm::ivec3 pos(x, y, z);
+                pos += rotation.axes[0] * sx;
+                pos += rotation.axes[1] * sy;
+                pos += rotation.axes[2] * sz;
+                set(chunks, pos.x, pos.y, pos.z, 0, {});
+            }
+        }
+    }
+}
+
+/// @brief Convert segment offset to segment bits
+/// @param sx segment offset X
+/// @param sy segment offset Y
+/// @param sz segment offset Z
+/// @return segment bits
+static constexpr inline uint8_t segment_to_int(int sx, int sy, int sz) {
+    return ((sx > 0) | ((sy > 0) << 1) | ((sz > 0) << 2));
+}
+
+/// @brief Restore invalid extended block segments
+/// @tparam Storage chunks storage class
+/// @param chunks chunks storage
+/// @param def origin block definition
+/// @param state origin block state
+/// @param x origin position X
+/// @param y origin position Y
+/// @param z origin position Z
+template <class Storage>
+inline void repair_segments(
+    Storage& chunks, const Block& def, blockstate state, int x, int y, int z
+) {
+    const auto& rotation = def.rotations.variants[state.rotation];
+    const auto id = def.rt.id;
+    const auto size = def.size;
+    for (int sy = 0; sy < size.y; sy++) {
+        for (int sz = 0; sz < size.z; sz++) {
+            for (int sx = 0; sx < size.x; sx++) {
+                if ((sx | sy | sz) == 0) {
+                    continue;
+                }
+                blockstate segState = state;
+                segState.segment = segment_to_int(sx, sy, sz);
+
+                glm::ivec3 pos(x, y, z);
+                pos += rotation.axes[0] * sx;
+                pos += rotation.axes[1] * sy;
+                pos += rotation.axes[2] * sz;
+                set(chunks, pos.x, pos.y, pos.z, id, segState);
+            }
+        }
+    }
+}
+
+/// @brief Get origin position for specified extended block. Returns srcpos
+/// if block is not extended.
+/// @tparam Storage chunks storage class
+/// @param chunks chunks storage
+/// @param srcpos block segment position
+/// @param def definition of the block at srcpos
+/// @param state state of the block at srcpos
+/// @return origin block position
+template <class Storage>
+inline glm::ivec3 seek_origin(
+    Storage& chunks, const glm::ivec3& srcpos, const Block& def, blockstate state
+) {
+    auto pos = srcpos;
+    const auto& rotation = def.rotations.variants[state.rotation];
+    auto segment = state.segment;
+    while (true) {
+        if (!segment) {
+            return pos;
+        }
+        if (segment & 1) pos -= rotation.axes[0];
+        if (segment & 2) pos -= rotation.axes[1];
+        if (segment & 4) pos -= rotation.axes[2];
+
+        if (auto* voxel = get(chunks, pos.x, pos.y, pos.z)) {
+            segment = voxel->state.segment;
+        } else {
+            return pos;
+        }
+    }
+}
+
+/// @brief Check blocks replaceability with specified block
+/// @tparam Storage chunks storage class
+/// @param chunks chunks storage
+/// @param def block definition
+/// @param state target block state
+/// @param origin target block origin
+/// @param ignore ignored block id
+/// @return true if specified area may be replaced with the block/extended block
+template <class Storage>
+inline bool check_replaceability(
+    const Storage& chunks,
+    const Block& def,
+    blockstate state,
+    const glm::ivec3& origin,
+    blockid_t ignore
+) {
+    const auto& blocks = chunks.getContentIndices().blocks;
+    const auto& rotation = def.rotations.variants[state.rotation];
+    const auto size = def.size;
+    for (int sy = 0; sy < size.y; sy++) {
+        for (int sz = 0; sz < size.z; sz++) {
+            for (int sx = 0; sx < size.x; sx++) {
+                auto pos = origin;
+                pos += rotation.axes[0] * sx;
+                pos += rotation.axes[1] * sy;
+                pos += rotation.axes[2] * sz;
+                if (auto vox = get(chunks, pos.x, pos.y, pos.z)) {
+                    auto& target = blocks.require(vox->id);
+                    if (!target.replaceable && vox->id != ignore) {
+                        return false;
+                    }
+                } else {
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
+}
+
+/// @brief Set rotation to an extended block
+/// @tparam Storage chunks storage class
+/// @param chunks chunks storage
+/// @param def block definition
+/// @param state current block state
+/// @param origin extended block origin
+/// @param index target rotation index
+template <class Storage>
+inline void set_rotation_extended(
+    Storage& chunks,
+    const Block& def,
+    blockstate state,
+    const glm::ivec3& origin,
+    uint8_t index
+) {
+    auto newstate = state;
+    newstate.rotation = index;
+
+    // unable to rotate block (cause: obstacles)
+    if (!check_replaceability(chunks, def, newstate, origin, def.rt.id)) {
+        return;
+    }
+
+    const auto& rotation = def.rotations.variants[index];
+    const auto size = def.size;
+    std::vector<glm::ivec3> segmentBlocks;
+
+    for (int sy = 0; sy < size.y; sy++) {
+        for (int sz = 0; sz < size.z; sz++) {
+            for (int sx = 0; sx < size.x; sx++) {
+                auto pos = origin;
+                pos += rotation.axes[0] * sx;
+                pos += rotation.axes[1] * sy;
+                pos += rotation.axes[2] * sz;
+
+                blockstate segState = newstate;
+                segState.segment = segment_to_int(sx, sy, sz);
+
+                auto vox = get(chunks, pos.x, pos.y, pos.z);
+                // checked for nullptr by checkReplaceability
+                if (vox->id != def.rt.id) {
+                    set(chunks, pos.x, pos.y, pos.z, def.rt.id, segState);
+                } else {
+                    vox->state = segState;
+                    int cx = floordiv<CHUNK_W>(pos.x);
+                    int cz = floordiv<CHUNK_D>(pos.z);
+                    auto chunk = get_chunk(chunks, cx, cz);
+                    assert(chunk != nullptr);
+                    chunk->setModifiedAndUnsaved();
+                    segmentBlocks.emplace_back(pos);
+                }
+            }
+        }
+    }
+    const auto& prevRotation = def.rotations.variants[state.rotation];
+    for (int sy = 0; sy < size.y; sy++) {
+        for (int sz = 0; sz < size.z; sz++) {
+            for (int sx = 0; sx < size.x; sx++) {
+                auto pos = origin;
+                pos += prevRotation.axes[0] * sx;
+                pos += prevRotation.axes[1] * sy;
+                pos += prevRotation.axes[2] * sz;
+                if (std::find(
+                        segmentBlocks.begin(), segmentBlocks.end(), pos
+                    ) == segmentBlocks.end()) {
+                    set(chunks, pos.x, pos.y, pos.z, 0, {});
+                }
+            }
+        }
+    }
+}
+
+/// @brief Set block rotation
+/// @tparam Storage chunks storage class
+/// @param chunks chunks storage
+/// @param x block X position
+/// @param y block Y position
+/// @param z block Z position
+/// @param index target rotation index
+template <class Storage>
+inline void set_rotation(
+    Storage& chunks, int32_t x, int32_t y, int32_t z, uint8_t index
+) {
+    if (index >= BlockRotProfile::MAX_COUNT) {
+        return;
+    }
+    auto vox = get(chunks, x, y, z);
+    if (vox == nullptr) {
+        return;
+    }
+    const auto& def = chunks.getContentIndices().blocks.require(vox->id);
+    if (!def.rotatable || vox->state.rotation == index) {
+        return;
+    }
+    if (def.rt.extended) {
+        auto origin = seek_origin(chunks, {x, y, z}, def, vox->state);
+        vox = get(chunks, origin.x, origin.y, origin.z);
+        set_rotation_extended(chunks, def, vox->state, origin, index);
+    } else {
+        vox->state.rotation = index;
+        int cx = floordiv<CHUNK_W>(x);
+        int cz = floordiv<CHUNK_D>(z);
+        auto chunk = get_chunk(chunks, cx, cz);
+        assert(chunk != nullptr);
+        chunk->setModifiedAndUnsaved();
+    }
+}
+
+/// @brief Cast ray to a selectable block with filter based on id.
+/// @param chunks chunks matrix
+/// @param start ray start position
+/// @param dir normalized ray direction vector
+/// @param maxDist maximum ray length
+/// @param end [out] ray end position
+/// @param norm [out] surface normal vector
+/// @param iend [out] ray end integer position (voxel position + normal)
+/// @param filter filtered ids
+/// @return voxel pointer or nullptr
+voxel* raycast(
+    const Chunks& chunks,
+    const glm::vec3& start,
+    const glm::vec3& dir,
+    float maxDist,
+    glm::vec3& end,
+    glm::ivec3& norm,
+    glm::ivec3& iend,
+    std::set<blockid_t> filter
+);
+
+/// @brief Cast ray to a selectable block with filter based on id.
+/// @param chunks chunks storage
+/// @param start ray start position
+/// @param dir normalized ray direction vector
+/// @param maxDist maximum ray length
+/// @param end [out] ray end position
+/// @param norm [out] surface normal vector
+/// @param iend [out] ray end integer position (voxel position + normal)
+/// @param filter filtered ids
+/// @return voxel pointer or nullptr
+voxel* raycast(
+    const GlobalChunks& chunks,
+    const glm::vec3& start,
+    const glm::vec3& dir,
+    float maxDist,
+    glm::vec3& end,
+    glm::ivec3& norm,
+    glm::ivec3& iend,
+    std::set<blockid_t> filter
+);
+
+void get_voxels(const Chunks& chunks, VoxelsVolume* volume, bool backlight=false);
+
+void get_voxels(const GlobalChunks& chunks, VoxelsVolume* volume, bool backlight=false);
+
+template <class Storage>
+inline const AABB* is_obstacle_at(const Storage& chunks, float x, float y, float z) {
+    int ix = std::floor(x);
+    int iy = std::floor(y);
+    int iz = std::floor(z);
+    voxel* v = get(chunks, ix, iy, iz);
+    if (v == nullptr) {
+        if (iy >= CHUNK_H) {
+            return nullptr;
+        } else {
+            static const AABB empty;
+            return &empty;
+        }
+    }
+    const auto& def = chunks.getContentIndices().blocks.require(v->id);
+    if (def.obstacle) {
+        glm::ivec3 offset {};
+        if (v->state.segment) {
+            glm::ivec3 point(ix, iy, iz);
+            offset = seek_origin(chunks, point, def, v->state) - point;
+        }
+        const auto& boxes =
+            def.rotatable ? def.rt.hitboxes[v->state.rotation] : def.hitboxes;
+        for (const auto& hitbox : boxes) {
+            if (hitbox.contains(
+                {x - ix - offset.x, y - iy - offset.y, z - iz - offset.z}
+            )) {
+                return &hitbox;
+            }
+        }
+    }
+    return nullptr;
+}
+
+} // blocks_agent
diff --git a/src/window/Events.cpp b/src/window/Events.cpp
index f63431cfb..1652e5954 100644
--- a/src/window/Events.cpp
+++ b/src/window/Events.cpp
@@ -23,6 +23,7 @@ bool Events::_cursor_locked = false;
 std::vector<uint> Events::codepoints;
 std::vector<keycode> Events::pressedKeys;
 std::unordered_map<std::string, Binding> Events::bindings;
+std::unordered_map<keycode, util::HandlersList<>> Events::keyCallbacks;
 
 bool Events::pressed(keycode keycode) {
     return pressed(static_cast<int>(keycode));
@@ -156,6 +157,12 @@ bool Events::jactive(const std::string& name) {
 void Events::setKey(int key, bool b) {
     Events::keys[key] = b;
     Events::frames[key] = currentFrame;
+    if (b) {
+        const auto& callbacks = keyCallbacks.find(static_cast<keycode>(key));
+        if (callbacks != keyCallbacks.end()) {
+            callbacks->second.notify();
+        }
+    }
 }
 
 void Events::setButton(int button, bool b) {
@@ -173,6 +180,10 @@ void Events::setPosition(float xpos, float ypos) {
     Events::cursor.y = ypos;
 }
 
+observer_handler Events::addKeyCallback(keycode key, KeyCallback callback) {
+    return keyCallbacks[key].add(std::move(callback));
+}
+
 #include "coders/json.hpp"
 #include "coders/toml.hpp"
 
@@ -228,7 +239,6 @@ void Events::loadBindings(
             } else if (bindType == BindType::REBIND) {
                 Events::rebind(key, type, code);
             }
-            
         }
     }
 }
diff --git a/src/window/Events.hpp b/src/window/Events.hpp
index 8155bb2b0..67ab111a3 100644
--- a/src/window/Events.hpp
+++ b/src/window/Events.hpp
@@ -4,6 +4,7 @@
 #include <unordered_map>
 #include <vector>
 
+#include "delegates.hpp"
 #include "typedefs.hpp"
 #include "input.hpp"
 
@@ -27,6 +28,7 @@ class Events {
     static std::vector<uint> codepoints;
     static std::vector<keycode> pressedKeys;
     static std::unordered_map<std::string, Binding> bindings;
+    static std::unordered_map<keycode, util::HandlersList<>> keyCallbacks;
 
     static void pollEvents();
 
@@ -50,6 +52,8 @@ class Events {
     static bool active(const std::string& name);
     static bool jactive(const std::string& name);
 
+    static observer_handler addKeyCallback(keycode key, KeyCallback callback);
+
     static void setKey(int key, bool b);
     static void setButton(int button, bool b);
 
diff --git a/src/window/Window.cpp b/src/window/Window.cpp
index 99a549cab..b4361fd06 100644
--- a/src/window/Window.cpp
+++ b/src/window/Window.cpp
@@ -29,18 +29,60 @@ int Window::posY = 0;
 int Window::framerate = -1;
 double Window::prevSwap = 0.0;
 bool Window::fullscreen = false;
+CursorShape Window::cursor = CursorShape::ARROW;
 
 static util::ObjectsKeeper observers_keeper;
 
-void cursor_position_callback(GLFWwindow*, double xpos, double ypos) {
+static const char* gl_error_name(int error) {
+    switch (error) {
+        case GL_DEBUG_TYPE_ERROR: return "ERROR";
+        case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: return "DEPRECATED_BEHAVIOR";
+        case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: return "UNDEFINED_BEHAVIOR";
+        case GL_DEBUG_TYPE_PORTABILITY: return "PORTABILITY";
+        case GL_DEBUG_TYPE_PERFORMANCE: return "PERFORMANCE";
+        case GL_DEBUG_TYPE_OTHER: return "OTHER";
+    }
+    return "UNKNOWN";
+}
+
+static const char* gl_severity_name(int severity) {
+    switch (severity) {
+        case GL_DEBUG_SEVERITY_LOW: return "LOW";
+        case GL_DEBUG_SEVERITY_MEDIUM: return "MEDIUM";
+        case GL_DEBUG_SEVERITY_HIGH: return "HIGH";
+        case GL_DEBUG_SEVERITY_NOTIFICATION: return "NOTIFICATION";
+    }
+    return "UNKNOWN";
+}
+
+static void GLAPIENTRY gl_message_callback(
+    GLenum source,
+    GLenum type,
+    GLuint id,
+    GLenum severity,
+    GLsizei length,
+    const GLchar* message,
+    const void* userParam
+) {
+    if (severity == GL_DEBUG_SEVERITY_NOTIFICATION) {
+        return;
+    }
+    if (!ENGINE_DEBUG_BUILD && severity != GL_DEBUG_SEVERITY_HIGH) {
+        return;
+    }
+    std::cerr << "GL:" << gl_error_name(type) << ":"
+              << gl_severity_name(severity) << ": " << message << std::endl;
+}
+
+static void cursor_position_callback(GLFWwindow*, double xpos, double ypos) {
     Events::setPosition(xpos, ypos);
 }
 
-void mouse_button_callback(GLFWwindow*, int button, int action, int) {
+static void mouse_button_callback(GLFWwindow*, int button, int action, int) {
     Events::setButton(button, action == GLFW_PRESS);
 }
 
-void key_callback(
+static void key_callback(
     GLFWwindow*, int key, int /*scancode*/, int action, int /*mode*/
 ) {
     if (key == GLFW_KEY_UNKNOWN) return;
@@ -54,23 +96,15 @@ void key_callback(
     }
 }
 
-void scroll_callback(GLFWwindow*, double xoffset, double yoffset) {
+static void scroll_callback(GLFWwindow*, double xoffset, double yoffset) {
     Events::scroll += yoffset;
 }
 
-bool Window::isMaximized() {
-    return glfwGetWindowAttrib(window, GLFW_MAXIMIZED);
-}
-
-bool Window::isIconified() {
-    return glfwGetWindowAttrib(window, GLFW_ICONIFIED);
-}
-
-bool Window::isFocused() {
-    return glfwGetWindowAttrib(window, GLFW_FOCUSED);
+static void character_callback(GLFWwindow*, unsigned int codepoint) {
+    Events::codepoints.push_back(codepoint);
 }
 
-void window_size_callback(GLFWwindow*, int width, int height) {
+static void window_size_callback(GLFWwindow*, int width, int height) {
     if (width && height) {
         glViewport(0, 0, width, height);
         Window::width = width;
@@ -84,11 +118,19 @@ void window_size_callback(GLFWwindow*, int width, int height) {
     Window::resetScissor();
 }
 
-void character_callback(GLFWwindow*, unsigned int codepoint) {
-    Events::codepoints.push_back(codepoint);
+bool Window::isMaximized() {
+    return glfwGetWindowAttrib(window, GLFW_MAXIMIZED);
+}
+
+bool Window::isIconified() {
+    return glfwGetWindowAttrib(window, GLFW_ICONIFIED);
 }
 
-const char* glfwErrorName(int error) {
+bool Window::isFocused() {
+    return glfwGetWindowAttrib(window, GLFW_FOCUSED);
+}
+
+static const char* glfw_error_name(int error) {
     switch (error) {
         case GLFW_NO_ERROR:
             return "no error";
@@ -117,14 +159,17 @@ const char* glfwErrorName(int error) {
     }
 }
 
-void error_callback(int error, const char* description) {
-    std::cerr << "GLFW error [0x" << std::hex << error << "]: ";
-    std::cerr << glfwErrorName(error) << std::endl;
+static void glfw_error_callback(int error, const char* description) {
+    auto logline = logger.error();
+    logline << "GLFW error [0x" << std::hex << error << " - "
+            << glfw_error_name(error) << "]";
     if (description) {
-        std::cerr << description << std::endl;
+        logline << ": " << description;
     }
 }
 
+static GLFWcursor* standard_cursors[static_cast<int>(CursorShape::LAST) + 1] = {};
+
 int Window::initialize(DisplaySettings* settings) {
     Window::settings = settings;
     Window::width = settings->width.get();
@@ -137,7 +182,7 @@ int Window::initialize(DisplaySettings* settings) {
         title += " [debug]";
     }
 
-    glfwSetErrorCallback(error_callback);
+    glfwSetErrorCallback(glfw_error_callback);
     if (glfwInit() == GLFW_FALSE) {
         logger.error() << "failed to initialize GLFW";
         return -1;
@@ -178,6 +223,9 @@ int Window::initialize(DisplaySettings* settings) {
         }
     }
 
+    glEnable(GL_DEBUG_OUTPUT);
+    glDebugMessageCallback(gl_message_callback, 0);
+
     glViewport(0, 0, width, height);
     glClearColor(0.0f, 0.0f, 0.0f, 1);
     glEnable(GL_BLEND);
@@ -199,7 +247,7 @@ int Window::initialize(DisplaySettings* settings) {
 
     observers_keeper = util::ObjectsKeeper();
     observers_keeper.keepAlive(settings->fullscreen.observe(
-        [=](bool value) {
+        [](bool value) {
             if (value != isFullscreen()) {
                 toggleFullscreen();
             }
@@ -219,6 +267,15 @@ int Window::initialize(DisplaySettings* settings) {
     logger.info() << "monitor content scale: " << scale.x << "x" << scale.y;
 
     input_util::initialize();
+
+    for (int i = 0; i <= static_cast<int>(CursorShape::LAST); i++) {
+        int cursor = GLFW_ARROW_CURSOR + i;
+        // GLFW 3.3 does not support some cursors
+        if (GLFW_VERSION_MAJOR <= 3 && GLFW_VERSION_MINOR <= 3 && cursor > GLFW_VRESIZE_CURSOR) {
+            break;
+        }
+        standard_cursors[i] = glfwCreateStandardCursor(cursor);
+    }
     return 0;
 }
 
@@ -305,6 +362,9 @@ void Window::popScissor() {
 
 void Window::terminate() {
     observers_keeper = util::ObjectsKeeper();
+    for (int i = 0; i <= static_cast<int>(CursorShape::LAST); i++) {
+        glfwDestroyCursor(standard_cursors[i]);
+    }
     glfwTerminate();
 }
 
@@ -380,6 +440,15 @@ DisplaySettings* Window::getSettings() {
     return settings;
 }
 
+void Window::setCursor(CursorShape shape) {
+    if (cursor == shape) {
+        return;
+    }
+    cursor = shape;
+    // NULL cursor is valid for GLFW
+    glfwSetCursor(window, standard_cursors[static_cast<int>(shape)]);
+}
+
 std::unique_ptr<ImageData> Window::takeScreenshot() {
     auto data = std::make_unique<ubyte[]>(width * height * 3);
     glPixelStorei(GL_PACK_ALIGNMENT, 1);
diff --git a/src/window/Window.hpp b/src/window/Window.hpp
index 78d63ebe5..77fd70761 100644
--- a/src/window/Window.hpp
+++ b/src/window/Window.hpp
@@ -5,6 +5,7 @@
 #include <stack>
 #include <vector>
 
+#include "graphics/core/commons.hpp"
 #include "typedefs.hpp"
 
 class ImageData;
@@ -20,6 +21,7 @@ class Window {
     static bool fullscreen;
     static int framerate;
     static double prevSwap;
+    static CursorShape cursor;
 
     static bool tryToMaximize(GLFWwindow* window, GLFWmonitor* monitor);
 public:
@@ -46,6 +48,8 @@ class Window {
     static void popScissor();
     static void resetScissor();
 
+    static void setCursor(CursorShape shape);
+
     static void clear();
     static void clearDepth();
     static void setBgColor(glm::vec3 color);
diff --git a/src/window/input.hpp b/src/window/input.hpp
index 06ed15112..ca532e825 100644
--- a/src/window/input.hpp
+++ b/src/window/input.hpp
@@ -2,7 +2,7 @@
 
 #include <string>
 
-#include "util/RunnablesList.hpp"
+#include "util/HandlersList.hpp"
 
 /// @brief Represents glfw3 keycode values.
 enum class keycode : int {
@@ -131,7 +131,7 @@ enum class inputtype {
 };
 
 struct Binding {
-    util::RunnablesList onactived;
+    util::HandlersList<> onactived;
 
     inputtype type;
     int code;
diff --git a/src/world/Level.cpp b/src/world/Level.cpp
index ed370d084..7ea871ee7 100644
--- a/src/world/Level.cpp
+++ b/src/world/Level.cpp
@@ -4,7 +4,6 @@
 #include "data/dv_util.hpp"
 #include "items/Inventories.hpp"
 #include "items/Inventory.hpp"
-#include "lighting/Lighting.hpp"
 #include "objects/Entities.hpp"
 #include "objects/Player.hpp"
 #include "objects/Players.hpp"
@@ -12,27 +11,26 @@
 #include "physics/PhysicsSolver.hpp"
 #include "settings.hpp"
 #include "voxels/Chunk.hpp"
-#include "voxels/Chunks.hpp"
-#include "voxels/ChunksStorage.hpp"
+#include "voxels/GlobalChunks.hpp"
 #include "window/Camera.hpp"
 #include "LevelEvents.hpp"
 #include "World.hpp"
 
 Level::Level(
     std::unique_ptr<World> worldPtr,
-    const Content* content,
+    const Content& content,
     EngineSettings& settings
 )
-    : world(std::move(worldPtr)),
+    : settings(settings),
+      world(std::move(worldPtr)),
       content(content),
-      chunksStorage(std::make_unique<ChunksStorage>(this)),
+      chunks(std::make_unique<GlobalChunks>(*this)),
       physics(std::make_unique<PhysicsSolver>(glm::vec3(0, -22.6f, 0))),
       events(std::make_unique<LevelEvents>()),
-      entities(std::make_unique<Entities>(this)),
-      players(std::make_unique<Players>(this)),
-      settings(settings) {
+      entities(std::make_unique<Entities>(*this)),
+      players(std::make_unique<Players>(*this)) {
     const auto& worldInfo = world->getInfo();
-    auto& cameraIndices = content->getIndices(ResourceType::CAMERA);
+    auto& cameraIndices = content.getIndices(ResourceType::CAMERA);
     for (size_t i = 0; i < cameraIndices.size(); i++) {
         auto camera = std::make_shared<Camera>();
         auto map = cameraIndices.getSavedData(i);
@@ -54,35 +52,21 @@ Level::Level(
         entities->setNextID(worldInfo.nextEntityId);
     }
 
-    uint matrixSize =
-        (settings.chunks.loadDistance.get() + settings.chunks.padding.get()) *
-        2;
-    chunks = std::make_unique<Chunks>(
-        matrixSize, matrixSize, 0, 0, world->wfile.get(), this
-    );
-    lighting = std::make_unique<Lighting>(content, chunks.get());
-
-    events->listen(EVT_CHUNK_HIDDEN, [this](lvl_event_type, Chunk* chunk) {
-        this->chunksStorage->remove(chunk->x, chunk->z);
+    events->listen(LevelEventType::EVT_CHUNK_SHOWN, [this](LevelEventType, Chunk* chunk) {
+        chunks->incref(chunk);
+    });
+    events->listen(LevelEventType::EVT_CHUNK_HIDDEN, [this](LevelEventType, Chunk* chunk) {
+        chunks->decref(chunk);
+    });
+    chunks->setOnUnload([this](const Chunk& chunk) {
+        AABB aabb = chunk.getAABB();
+        entities->despawn(entities->getAllInside(aabb));
     });
-
     inventories = std::make_unique<Inventories>(*this);
 }
 
 Level::~Level() = default;
 
-void Level::loadMatrix(int32_t x, int32_t z, uint32_t radius) {
-    chunks->setCenter(x, z);
-    uint32_t diameter = std::min(
-        radius * 2LL,
-        (settings.chunks.loadDistance.get() + settings.chunks.padding.get()) *
-            2LL
-    );
-    if (chunks->getWidth() != diameter) {
-        chunks->resize(diameter, diameter);
-    }
-}
-
 World* Level::getWorld() {
     return world.get();
 }
@@ -92,7 +76,7 @@ const World* Level::getWorld() const {
 }
 
 void Level::onSave() {
-    auto& cameraIndices = content->getIndices(ResourceType::CAMERA);
+    auto& cameraIndices = content.getIndices(ResourceType::CAMERA);
     for (size_t i = 0; i < cameraIndices.size(); i++) {
         auto& camera = *cameras.at(i);
         auto map = dv::object();
@@ -107,7 +91,7 @@ void Level::onSave() {
 }
 
 std::shared_ptr<Camera> Level::getCamera(const std::string& name) {
-    size_t index = content->getIndices(ResourceType::CAMERA).indexOf(name);
+    size_t index = content.getIndices(ResourceType::CAMERA).indexOf(name);
     if (index == ResourceIndices::MISSING) {
         return nullptr;
     }
diff --git a/src/world/Level.hpp b/src/world/Level.hpp
index 1f3ef183f..6e828471a 100644
--- a/src/world/Level.hpp
+++ b/src/world/Level.hpp
@@ -9,45 +9,37 @@
 
 class Content;
 class World;
-class Chunks;
 class Entities;
 class Inventories;
 class LevelEvents;
-class Lighting;
 class PhysicsSolver;
-class ChunksStorage;
+class GlobalChunks;
 class Camera;
 class Players;
 struct EngineSettings;
 
 /// @brief A level, contains chunks and objects
 class Level {
+    const EngineSettings& settings;
     std::unique_ptr<World> world;
 public:
-    const Content* const content;
+    const Content& content;
     
-    std::unique_ptr<Chunks> chunks;
-    std::unique_ptr<ChunksStorage> chunksStorage;
+    std::unique_ptr<GlobalChunks> chunks;
     std::unique_ptr<Inventories> inventories;
-
     std::unique_ptr<PhysicsSolver> physics;
-    std::unique_ptr<Lighting> lighting;
     std::unique_ptr<LevelEvents> events;
     std::unique_ptr<Entities> entities;
     std::unique_ptr<Players> players;
     std::vector<std::shared_ptr<Camera>> cameras;  // move somewhere?
 
-    const EngineSettings& settings;
-
     Level(
         std::unique_ptr<World> world,
-        const Content* content,
+        const Content& content,
         EngineSettings& settings
     );
     ~Level();
 
-    void loadMatrix(int32_t x, int32_t z, uint32_t radius);
-
     World* getWorld();
 
     const World* getWorld() const;
diff --git a/src/world/LevelEvents.cpp b/src/world/LevelEvents.cpp
index 00017cc66..cb98cb9dd 100644
--- a/src/world/LevelEvents.cpp
+++ b/src/world/LevelEvents.cpp
@@ -4,14 +4,14 @@
 
 using std::vector;
 
-void LevelEvents::listen(lvl_event_type type, const chunk_event_func& func) {
+void LevelEvents::listen(LevelEventType type, const ChunkEventFunc& func) {
     auto& callbacks = chunk_callbacks[type];
     callbacks.push_back(func);
 }
 
-void LevelEvents::trigger(lvl_event_type type, Chunk* chunk) {
+void LevelEvents::trigger(LevelEventType type, Chunk* chunk) {
     const auto& callbacks = chunk_callbacks[type];
-    for (const chunk_event_func& func : callbacks) {
+    for (const ChunkEventFunc& func : callbacks) {
         func(type, chunk);
     }
 }
diff --git a/src/world/LevelEvents.hpp b/src/world/LevelEvents.hpp
index d0518b5ca..f7bbaa7f6 100644
--- a/src/world/LevelEvents.hpp
+++ b/src/world/LevelEvents.hpp
@@ -6,16 +6,17 @@
 
 class Chunk;
 
-enum lvl_event_type {
+enum LevelEventType {
+    EVT_CHUNK_SHOWN,
     EVT_CHUNK_HIDDEN,
 };
 
-using chunk_event_func = std::function<void(lvl_event_type, Chunk*)>;
+using ChunkEventFunc = std::function<void(LevelEventType, Chunk*)>;
 
 class LevelEvents {
-    std::unordered_map<lvl_event_type, std::vector<chunk_event_func>>
+    std::unordered_map<LevelEventType, std::vector<ChunkEventFunc>>
         chunk_callbacks;
 public:
-    void listen(lvl_event_type type, const chunk_event_func& func);
-    void trigger(lvl_event_type type, Chunk* chunk);
+    void listen(LevelEventType type, const ChunkEventFunc& func);
+    void trigger(LevelEventType type, Chunk* chunk);
 };
diff --git a/src/world/World.cpp b/src/world/World.cpp
index 4eb2631a9..a3b837423 100644
--- a/src/world/World.cpp
+++ b/src/world/World.cpp
@@ -15,7 +15,7 @@
 #include "settings.hpp"
 #include "voxels/Chunk.hpp"
 #include "voxels/Chunks.hpp"
-#include "voxels/ChunksStorage.hpp"
+#include "voxels/GlobalChunks.hpp"
 #include "world/generator/WorldGenerator.hpp"
 #include "world/generator/GeneratorDef.hpp"
 #include "Level.hpp"
@@ -30,7 +30,7 @@ world_load_error::world_load_error(const std::string& message)
 World::World(
     WorldInfo info,
     const std::shared_ptr<WorldFiles>& worldFiles,
-    const Content* content,
+    const Content& content,
     const std::vector<ContentPack>& packs
 ) : info(std::move(info)),
     content(content),
@@ -46,12 +46,12 @@ void World::updateTimers(float delta) {
     info.totalTime += delta;
 }
 
-void World::writeResources(const Content* content) {
+void World::writeResources(const Content& content) {
     auto root = dv::object();
     for (size_t typeIndex = 0; typeIndex < RESOURCE_TYPES_COUNT; typeIndex++) {
         auto typeName = to_string(static_cast<ResourceType>(typeIndex));
         auto& list = root.list(typeName);
-        auto& indices = content->resourceIndices[typeIndex];
+        auto& indices = content.resourceIndices[typeIndex];
         for (size_t i = 0; i < indices.size(); i++) {
             auto& map = list.object();
             map["name"] = indices.getName(i);
@@ -65,10 +65,9 @@ void World::writeResources(const Content* content) {
 }
 
 void World::write(Level* level) {
-    const Content* content = level->content;
     level->chunks->saveAll();
     info.nextEntityId = level->entities->peekNextID();
-    wfile->write(this, content);
+    wfile->write(this, &content);
 
     auto playerFile = level->players->serialize();
     files::write_json(wfile->getPlayerFile(), playerFile);
@@ -82,7 +81,7 @@ std::unique_ptr<Level> World::create(
     const fs::path& directory,
     uint64_t seed,
     EngineSettings& settings,
-    const Content* content,
+    const Content& content,
     const std::vector<ContentPack>& packs
 ) {
     WorldInfo info {};
@@ -95,15 +94,15 @@ std::unique_ptr<Level> World::create(
         content,
         packs
     );
-    auto level = std::make_unique<Level>(std::move(world), content, settings);
-    level->players->create();
-    return level;
+    logger.info() << "created world '" << name << "' (" << directory.u8string() << ")";
+    logger.info() << "world seed: " << seed << " generator: " << generator;
+    return std::make_unique<Level>(std::move(world), content, settings);
 }
 
 std::unique_ptr<Level> World::load(
     const std::shared_ptr<WorldFiles>& worldFilesPtr,
     EngineSettings& settings,
-    const Content* content,
+    const Content& content,
     const std::vector<ContentPack>& packs
 ) {
     auto worldFiles = worldFilesPtr.get();
@@ -133,8 +132,10 @@ std::unique_ptr<Level> World::load(
         auto playerRoot = files::read_json(file);
         level->players->deserialize(playerRoot);
 
-        if (!playerRoot["players"][0].has("id")) {
-            level->getWorld()->getInfo().nextPlayerId++;
+        if (!playerRoot["players"].empty()) {
+            if (!playerRoot["players"][0].has("id")) {
+                level->getWorld()->getInfo().nextPlayerId++;
+            }
         }
     }
     return level;
diff --git a/src/world/World.hpp b/src/world/World.hpp
index 24042c40e..552f70ec2 100644
--- a/src/world/World.hpp
+++ b/src/world/World.hpp
@@ -56,17 +56,17 @@ struct WorldInfo : public Serializable {
 class World {
     WorldInfo info {};
 
-    const Content* const content;
+    const Content& content;
     std::vector<ContentPack> packs;
 
-    void writeResources(const Content* content);
+    void writeResources(const Content& content);
 public:
     std::shared_ptr<WorldFiles> wfile;
 
     World(
         WorldInfo info,
         const std::shared_ptr<WorldFiles>& worldFiles,
-        const Content* content,
+        const Content& content,
         const std::vector<ContentPack>& packs
     );
 
@@ -103,7 +103,7 @@ class World {
         const fs::path& directory,
         uint64_t seed,
         EngineSettings& settings,
-        const Content* content,
+        const Content& content,
         const std::vector<ContentPack>& packs
     );
 
@@ -118,7 +118,7 @@ class World {
     static std::unique_ptr<Level> load(
         const std::shared_ptr<WorldFiles>& worldFiles,
         EngineSettings& settings,
-        const Content* content,
+        const Content& content,
         const std::vector<ContentPack>& packs
     );
 
@@ -156,9 +156,4 @@ class World {
     int64_t getNextInventoryId() {
         return info.nextInventoryId++;
     }
-
-    /// @brief Get current world Content instance
-    const Content* getContent() const {
-        return content;
-    }
 };
diff --git a/src/world/generator/VoxelFragment.cpp b/src/world/generator/VoxelFragment.cpp
index f36824b0b..64f9153e7 100644
--- a/src/world/generator/VoxelFragment.cpp
+++ b/src/world/generator/VoxelFragment.cpp
@@ -8,13 +8,14 @@
 #include "content/Content.hpp"
 #include "voxels/Chunks.hpp"
 #include "voxels/Block.hpp"
-#include "voxels/ChunksStorage.hpp"
+#include "voxels/GlobalChunks.hpp"
 #include "voxels/VoxelsVolume.hpp"
+#include "voxels/blocks_agent.hpp"
 #include "world/Level.hpp"
 #include "core_defs.hpp"
 
 std::unique_ptr<VoxelFragment> VoxelFragment::create(
-    Level* level,
+    const Level& level,
     const glm::ivec3& a,
     const glm::ivec3& b,
     bool crop,
@@ -26,7 +27,7 @@ std::unique_ptr<VoxelFragment> VoxelFragment::create(
     if (crop) {
         VoxelsVolume volume(size.x, size.y, size.z);
         volume.setPosition(start.x, start.y, start.z);
-        level->chunks->getVoxels(&volume);
+        blocks_agent::get_voxels(*level.chunks, &volume);
 
         auto end = start + size;
 
@@ -51,14 +52,14 @@ std::unique_ptr<VoxelFragment> VoxelFragment::create(
 
     VoxelsVolume volume(size.x, size.y, size.z);
     volume.setPosition(start.x, start.y, start.z);
-    level->chunks->getVoxels(&volume);
+    blocks_agent::get_voxels(*level.chunks, &volume);
 
     auto volVoxels = volume.getVoxels();
     std::vector<voxel> voxels(size.x * size.y * size.z);
 
     std::vector<std::string> blockNames {CORE_AIR};
     std::unordered_map<blockid_t, blockid_t> blocksRegistered {{0, 0}};
-    auto contentIndices = level->content->getIndices();
+    auto contentIndices = level.content.getIndices();
     for (size_t i = 0 ; i < voxels.size(); i++) {
         blockid_t id = volVoxels[i].id;
         blockid_t index;
@@ -170,7 +171,7 @@ void VoxelFragment::prepare(const Content& content) {
 }
 
 void VoxelFragment::place(
-    Chunks& chunks, const glm::ivec3& offset, ubyte rotation
+    GlobalChunks& chunks, const glm::ivec3& offset, ubyte rotation
 ) {
     auto& structVoxels = getRuntimeVoxels();
     for (int y = 0; y < size.y; y++) {
@@ -185,7 +186,9 @@ void VoxelFragment::place(
                 const auto& structVoxel = 
                     structVoxels[vox_index(x, y, z, size.x, size.z)];
                 if (structVoxel.id) {
-                    chunks.set(sx, sy, sz, structVoxel.id, structVoxel.state);
+                    blocks_agent::set(
+                        chunks, sx, sy, sz, structVoxel.id, structVoxel.state
+                    );
                 }
             }
         }
diff --git a/src/world/generator/VoxelFragment.hpp b/src/world/generator/VoxelFragment.hpp
index 701cac0e8..6efa1998d 100644
--- a/src/world/generator/VoxelFragment.hpp
+++ b/src/world/generator/VoxelFragment.hpp
@@ -10,7 +10,7 @@ inline constexpr int STRUCTURE_FORMAT_VERSION = 1;
 
 class Level;
 class Content;
-class Chunks;
+class GlobalChunks;
 
 class VoxelFragment : public Serializable {
     glm::ivec3 size;
@@ -45,13 +45,13 @@ class VoxelFragment : public Serializable {
     /// @brief Place fragment to the world
     /// @param offset target location
     /// @param rotation rotation index
-    void place(Chunks& chunks, const glm::ivec3& offset, ubyte rotation);
+    void place(GlobalChunks& chunks, const glm::ivec3& offset, ubyte rotation);
 
     /// @brief Create structure copy rotated 90 deg. clockwise
     std::unique_ptr<VoxelFragment> rotated(const Content& content) const;
 
     static std::unique_ptr<VoxelFragment> create(
-        Level* level,
+        const Level& level,
         const glm::ivec3& a,
         const glm::ivec3& b,
         bool crop,
diff --git a/src/world/generator/WorldGenerator.cpp b/src/world/generator/WorldGenerator.cpp
index bc851a074..b0515c247 100644
--- a/src/world/generator/WorldGenerator.cpp
+++ b/src/world/generator/WorldGenerator.cpp
@@ -24,7 +24,7 @@ static inline constexpr uint MAX_PARAMETERS = 4;
 static inline constexpr uint BASIC_PROTOTYPE_LAYERS = 5;
 
 WorldGenerator::WorldGenerator(
-    const GeneratorDef& def, const Content* content, uint64_t seed
+    const GeneratorDef& def, const Content& content, uint64_t seed
 )
     : def(def), 
       content(content), 
@@ -66,10 +66,10 @@ WorldGenerator::WorldGenerator(
     });
     for (int i = 0; i < def.structures.size(); i++) {
         // pre-calculate rotated structure variants
-        def.structures[i]->fragments[0]->prepare(*content);
+        def.structures[i]->fragments[0]->prepare(content);
         for (int j = 1; j < 4; j++) {
             def.structures[i]->fragments[j] = 
-                def.structures[i]->fragments[j-1]->rotated(*content);
+                def.structures[i]->fragments[j-1]->rotated(content);
         }
     }
 }
@@ -189,10 +189,10 @@ void WorldGenerator::placeLine(const LinePlacement& line, int priority) {
     aabb.fix();
     aabb.a -= line.radius;
     aabb.b += line.radius;
-    int cxa = floordiv(aabb.a.x, CHUNK_W);
-    int cza = floordiv(aabb.a.z, CHUNK_D);
-    int cxb = floordiv(aabb.b.x, CHUNK_W);
-    int czb = floordiv(aabb.b.z, CHUNK_D);
+    int cxa = floordiv<CHUNK_W>(aabb.a.x);
+    int cza = floordiv<CHUNK_D>(aabb.a.z);
+    int cxb = floordiv<CHUNK_W>(aabb.b.x);
+    int czb = floordiv<CHUNK_D>(aabb.b.z);
     for (int cz = cza; cz <= czb; cz++) {
         for (int cx = cxa; cx <= cxb; cx++) {
             const auto& found = prototypes.find({cx, cz});
@@ -354,8 +354,8 @@ void WorldGenerator::generateHeightmap(
 
 void WorldGenerator::update(int centerX, int centerY, int loadDistance) {
     surroundMap.setCenter(centerX, centerY);
-    // 1 is safety padding preventing ChunksController rounding problem
-    surroundMap.resize(loadDistance + 1);
+    // 2 is safety padding preventing ChunksController rounding problem
+    surroundMap.resize(loadDistance + 2);
     surroundMap.setCenter(centerX, centerY);
 }
 
@@ -367,7 +367,7 @@ void WorldGenerator::generatePlants(
     int chunkZ,
     const Biome** biomes
 ) {
-    const auto& indices = content->getIndices()->blocks;
+    const auto& indices = content.getIndices()->blocks;
     util::PseudoRandom plantsRand;
     plantsRand.setSeed(chunkX, chunkZ);
 
@@ -431,7 +431,7 @@ void WorldGenerator::generate(voxel* voxels, int chunkX, int chunkZ) {
 
     std::memset(voxels, 0, sizeof(voxel) * CHUNK_VOL);
 
-    const auto& indices = content->getIndices()->blocks;
+    const auto& indices = content.getIndices()->blocks;
     const auto& biomes = prototype.biomes.get();
     for (uint z = 0; z < CHUNK_D; z++) {
         for (uint x = 0; x < CHUNK_W; x++) {
@@ -531,7 +531,7 @@ void WorldGenerator::generateLine(
     voxel* voxels, 
     int chunkX, int chunkZ
 ) {
-    const auto& indices = content->getIndices()->blocks;
+    const auto& indices = content.getIndices()->blocks;
 
     int cgx = chunkX * CHUNK_W;
     int cgz = chunkZ * CHUNK_D;
diff --git a/src/world/generator/WorldGenerator.hpp b/src/world/generator/WorldGenerator.hpp
index 285f0ed6f..df31be4a0 100644
--- a/src/world/generator/WorldGenerator.hpp
+++ b/src/world/generator/WorldGenerator.hpp
@@ -50,7 +50,7 @@ class WorldGenerator {
     /// @param def generator definition
     const GeneratorDef& def;
     /// @param content world content
-    const Content* content;
+    const Content& content;
     /// @param seed world seed
     uint64_t seed;
     /// @brief Chunk prototypes main storage
@@ -120,7 +120,7 @@ class WorldGenerator {
 public:
     WorldGenerator(
         const GeneratorDef& def,
-        const Content* content,
+        const Content& content,
         uint64_t seed
     );
     ~WorldGenerator();
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index cbe038a6e..0597d6e47 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -15,5 +15,16 @@ target_link_libraries(
   GTest::gtest_main
 )
 
+# HACK: copy res to test/ folder for fixing problem compatibility MultiConfig and non
+# MultiConfig builds. Delete in future and use only root res folder
+# Also this resolve problem with ctests, because it set cwd to CMAKE_CURRENT_BINARY_DIR
+add_custom_command(
+  TARGET ${PROJECT_NAME} 
+  POST_BUILD 
+  COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different 
+          ${CMAKE_SOURCE_DIR}/res 
+          ${CMAKE_CURRENT_BINARY_DIR}/res
+  )
+
 include(GoogleTest)
 gtest_discover_tests(${PROJECT_NAME})
diff --git a/test/coders/vec3.cpp b/test/coders/vec3.cpp
index cb699bc33..d404e92bd 100644
--- a/test/coders/vec3.cpp
+++ b/test/coders/vec3.cpp
@@ -5,7 +5,7 @@
 
 TEST(VEC3, Decode) {
     auto file = std::filesystem::u8path(
-        "../res/models/block.vec3"
+        "res/models/block.vec3"
     );
     auto bytes = files::read_bytes_buffer(file);
     auto model = vec3::load(file.u8string(), bytes);
diff --git a/vctest/CMakeLists.txt b/vctest/CMakeLists.txt
new file mode 100644
index 000000000..6c1a3843c
--- /dev/null
+++ b/vctest/CMakeLists.txt
@@ -0,0 +1,31 @@
+project(vctest)
+
+set(CMAKE_CXX_STANDARD 17)
+
+file(GLOB_RECURSE SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
+
+add_executable(${PROJECT_NAME} ${SOURCES})
+
+if(MSVC)
+    if(NOT CMAKE_BUILD_TYPE)
+      set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+    endif()
+    if((CMAKE_BUILD_TYPE EQUAL "Release") OR (CMAKE_BUILD_TYPE EQUAL "RelWithDebInfo"))
+      set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Release>:Release>")
+      target_compile_options(${PROJECT_NAME} PRIVATE /W4 /MT /O2)
+    else()
+      target_compile_options(${PROJECT_NAME} PRIVATE /W4)
+    endif()
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+else()
+  target_compile_options(${PROJECT_NAME} PRIVATE -Wall -Wextra
+    -Wformat-nonliteral -Wcast-align
+    -Wpointer-arith -Wundef
+    -Wwrite-strings -Wno-unused-parameter)
+endif()
+
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -no-pie -lstdc++fs")
+endif()
+
+target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../src ${CMAKE_DL_LIBS})
diff --git a/vctest/main.cpp b/vctest/main.cpp
new file mode 100644
index 000000000..e139ff1e0
--- /dev/null
+++ b/vctest/main.cpp
@@ -0,0 +1,272 @@
+#include <chrono>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <vector>
+
+#include "util/ArgsReader.hpp"
+
+namespace fs = std::filesystem;
+
+inline fs::path TESTING_DIR = fs::u8path(".vctest");
+
+struct Config {
+    fs::path executable;
+    fs::path directory;
+    fs::path resDir {"res"};
+    fs::path workingDir {"."};
+    std::string memchecker = "valgrind";
+    bool outputAlways = false;
+};
+
+static bool perform_keyword(
+    util::ArgsReader& reader, const std::string& keyword, Config& config
+) {
+    if (keyword == "--help" || keyword == "-h") {
+        std::cout << "Options\n\n";
+        std::cout << "  --help, -h                      = show help\n";
+        std::cout << "  --exe <path>, -e <path>         = VoxelCore executable path\n";
+        std::cout << "  --tests <path>, -d <path>       = tests directory path\n";
+        std::cout << "  --res <path>, -r <path>         = 'res' directory path\n";
+        std::cout << "  --user <path>, -u <path>        = user directory path\n";
+        std::cout << "  --memchecker <path>             = path to valgrind\n";
+        std::cout << "  --output-always                 = always show tests output\n";
+        std::cout << std::endl;
+        return false;
+    } else if (keyword == "--exe" || keyword == "-e") {
+        config.executable = fs::path(reader.next());
+    } else if (keyword == "--tests" || keyword == "-d") {
+        config.directory = fs::path(reader.next());
+    } else if (keyword == "--res" || keyword == "-r") {
+        config.resDir = fs::path(reader.next());
+    } else if (keyword == "--user" || keyword == "-u") {
+        config.workingDir = fs::path(reader.next());
+    } else if (keyword == "--output-always") {
+        config.outputAlways = true;
+    } else {
+        std::cerr << "unknown argument " << keyword << std::endl;
+        return false;
+    }
+    return true;
+}
+
+static bool parse_cmdline(int argc, char** argv, Config& config) {
+    util::ArgsReader reader(argc, argv);
+    while (reader.hasNext()) {
+        std::string token = reader.next();
+        if (reader.isKeywordArg()) {
+            if (!perform_keyword(reader, token, config)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+static bool check_dir(const fs::path& dir) {
+    if (!fs::is_directory(dir)) {
+        std::cerr << dir << " is not a directory" << std::endl;
+        return false;
+    }
+    return true;
+}
+
+static void print_separator(std::ostream& stream) {
+    for (int i = 0; i < 32; i++) {
+        stream << "=";
+    }
+    stream << "\n";
+}
+
+static bool check_config(const Config& config) {
+    if (!fs::exists(config.executable)) {
+        std::cerr << "file " << config.executable << " not found" << std::endl;
+        return true;
+    }
+    if (!check_dir(config.directory)) {
+        return true;
+    }
+    if (!check_dir(config.resDir)) {
+        return true;
+    }
+    if (!check_dir(config.workingDir)) {
+        return true;
+    }
+    return false;
+}
+
+static void dump_config(const Config& config) {
+    std::cout << "paths:\n";
+    std::cout << "  VoxelCore executable = " << fs::canonical(config.executable).string() << "\n";
+    std::cout << "  Tests directory      = " << fs::canonical(config.directory).string() << "\n";
+    std::cout << "  Resources directory  = " << fs::canonical(config.resDir).string() << "\n";
+    std::cout << "  Working directory    = " << fs::canonical(config.workingDir).string();
+    std::cout << std::endl;
+}
+
+static void cleanup(const fs::path& dir) {
+    std::cout << "cleaning up " << dir << std::endl;
+    fs::remove_all(dir);
+}
+
+static void setup_working_dir(const fs::path& workingDir) {
+    auto dir = workingDir / TESTING_DIR;
+    std::cout << "setting up working directory " << dir << std::endl;
+    if (fs::is_directory(dir)) {
+        cleanup(dir);
+    }
+    fs::create_directories(dir);
+}
+
+static void display_test_output(
+    const fs::path& path, const fs::path& name, std::ostream& stream
+) {
+    stream << "[OUTPUT] " << name << std::endl;
+    if (fs::exists(path)) {
+        std::ifstream t(path);
+        stream << t.rdbuf();
+    }
+}
+
+static void display_segfault_valgrind(
+    const fs::path& path, const fs::path& name, std::ostream& stream
+) {
+    stream << "[MEMCHECK] " << name << std::endl;
+    if (fs::exists(path)) {
+        std::ifstream t(path);
+        while (!t.eof()) {
+            std::string line;
+            std::getline(t, line);
+            // skip until the terminating signal
+            if (line.find("Process terminating with default action of signal ") != std::string::npos) {
+                break;
+            }
+        }
+        std::stringstream ss;
+        while (!t.eof()) {
+            std::string line;
+            std::getline(t, line);
+            size_t pos = line.find("== ");
+            if (pos == std::string::npos) {
+                continue;
+            }
+            if (line.find("If you") != std::string::npos ||
+                line.find("HEAP SUMMARY:") != std::string::npos) {
+                break;
+            }
+            ss << line.substr(pos + 3) << "\n";
+        }
+        stream << ss.str() << std::endl;
+    }
+}
+
+static std::string fix_path(std::string s) {
+    for (char& c : s) {
+        if (c == '\\') {
+            c = '/';
+        }
+    }
+    return s;
+}
+
+static bool run_test(const Config& config, const fs::path& path, bool memcheck = false) {
+    using std::chrono::duration_cast;
+    using std::chrono::high_resolution_clock;
+    using std::chrono::milliseconds;
+
+    auto outputFile = config.workingDir / "output.txt";
+    auto memcheckLogFile = config.workingDir / "memcheck.txt";
+
+    auto name = path.stem();
+    std::stringstream ss;
+    if (memcheck) {
+        ss << config.memchecker << " --log-file="
+           << fix_path(memcheckLogFile.string()) << " ";
+    }
+    ss << fs::canonical(config.executable) << " --headless";
+    ss << " --test " << fix_path(path.string());
+    ss << " --res " << fix_path(config.resDir.string());
+    ss << " --dir " << fix_path(config.workingDir.string());
+    ss << " >" << fix_path(outputFile.string()) << " 2>&1";
+    auto command = ss.str();
+
+    print_separator(std::cout);
+    std::cout << "executing test " << name << "\ncommand: " << command << std::endl;
+
+    auto start = high_resolution_clock::now();
+    int code = system(command.c_str());
+    auto testTime =
+        duration_cast<milliseconds>(high_resolution_clock::now() - start)
+            .count();
+
+    if (code) {
+        if (memcheck) {
+            // valgrind-specific output
+            display_segfault_valgrind(memcheckLogFile, name, std::cerr);
+            fs::remove(memcheckLogFile);
+            fs::remove(outputFile);
+        } else {
+            display_test_output(outputFile, name, std::cerr);
+            std::cerr << "[FAILED] " << name << " in " << testTime
+                    << " ms (code=" << code << ")" << std::endl;
+            fs::remove(outputFile);
+            run_test(config, path, true);
+        }
+        return false;
+    } else {
+        if (config.outputAlways) {
+            display_test_output(outputFile, name, std::cout);
+        }
+        std::cout << "[PASSED] " << name << " in " << testTime << " ms" << std::endl;
+        fs::remove(outputFile);
+        return true;
+    }
+}
+
+int main(int argc, char** argv) {
+    Config config;
+    try {
+        if (!parse_cmdline(argc, argv, config)) {
+            return 0;
+        }
+    } catch (const std::runtime_error& err) {
+        std::cerr << err.what() << std::endl;
+        throw;
+    }
+    if (check_config(config)) {
+        return 1;
+    }
+    dump_config(config);
+
+    std::vector<fs::path> tests;
+    std::cout << "scanning for tests" << std::endl;
+    for (const auto& entry : fs::directory_iterator(config.directory)) {
+        auto path = entry.path();
+        if (path.extension().string() != ".lua") {
+            std::cout << "  " << entry.path() << " skipped" << std::endl;
+            continue;
+        }
+        std::cout << "  " << entry.path() << " enqueued" << std::endl;
+        tests.push_back(path);
+    }
+
+    setup_working_dir(config.workingDir);
+    config.workingDir /= TESTING_DIR;
+
+    size_t passed = 0;
+    std::cout << "running " << tests.size() << " test(s)" << std::endl;
+    for (const auto& path : tests) {
+        passed += run_test(config, path);
+        fs::remove_all(config.workingDir / fs::u8path("worlds"));
+    }
+    print_separator(std::cout);
+    cleanup(config.workingDir);
+    std::cout << std::endl;
+    std::cout << passed << " test(s) passed, " << (tests.size() - passed)
+              << " test(s) failed" << std::endl;
+    if (passed < tests.size()) {
+        return 1;
+    }
+    return 0;
+}