build: Bumped version to 1.12.1

This should completely fix #81

.github/workflows/analysis.yml

@@ -30,8 +30,8 @@ jobs:
       with:
         path: |
           ~/.ccache
-        key: ${{ runner.os }}-build-${{ github.run_id }}
-        restore-keys: ${{ runner.os }}-build-
+        key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
+        restore-keys: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-
 
     - name: ⬇️ Install dependencies
       run: |

.github/workflows/build.yml

@@ -26,11 +26,16 @@ jobs:
         path: |
           ~/.ccache
           .flatpak-builder
-        key: ${{ runner.os }}-build-${{ github.run_id }}
-        restore-keys: ${{ runner.os }}-build-
+        key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
+        restore-keys: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-
 
     - name: ⬇️ Install dependencies
       run: |
+        sudo rm -rf /usr/share/dotnet
+        sudo rm -rf /opt/ghc
+        sudo rm -rf "/usr/local/share/boost"
+        sudo rm -rf "$AGENT_TOOLSDIRECTORY"
+        
         sudo apt update
         sudo bash dist/get_deps_debian.sh
 
@@ -59,7 +64,7 @@ jobs:
         flatpak --user remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
         flatpak --user install -y flathub org.freedesktop.Platform//20.08
         flatpak --user install -y flathub org.freedesktop.Sdk//20.08
-        flatpak-builder --repo=imhex _flatpak dist/net.werwolv.ImHex.yaml --ccache --keep-build-dirs
+        flatpak-builder --jobs=4 --repo=imhex _flatpak dist/net.werwolv.ImHex.yaml --ccache --keep-build-dirs
         flatpak build-bundle imhex imhex.flatpak net.werwolv.ImHex stable
         
     - name: 📦 Bundle DEB
@@ -126,7 +131,6 @@ jobs:
           cmake:p
           make:p
           ccache:p
-          capstone:p
           glfw:p
           file:p
           mbedtls:p
@@ -154,8 +158,8 @@ jobs:
       id:    cache-ccache
       with:
         path: ${{ steps.prep-ccache.outputs.dir }}
-        key: ${{ runner.os }}-build-${{ github.run_id }}
-        restore-keys: ${{ runner.os }}-build-
+        key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
+        restore-keys: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-
 
     - name: 🛠️ Build
       run: |
@@ -210,8 +214,8 @@ jobs:
       with:
         path: |
           ~/.ccache
-        key: ${{ runner.os }}-build-${{ github.run_id }}
-        restore-keys: ${{ runner.os }}-build-
+        key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
+        restore-keys: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-
 
     - name: 🛠️ Build
       run: |

.github/workflows/tests.yml

@@ -27,8 +27,8 @@ jobs:
       with:
         path: |
           ~/.ccache
-        key: ${{ runner.os }}-build-${{ github.run_id }}
-        restore-keys: ${{ runner.os }}-build-
+        key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
+        restore-keys: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-
 
     - name: ⬇️ Install dependencies
       run: |
@@ -44,7 +44,7 @@ jobs:
           -DCMAKE_INSTALL_PREFIX="$PWD/install" \
           -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
           ..
-        make -j 4 install
+        make -j4 unit_tests install
 
     - name: 🧪 Perform Unit Tests
       run: |

.gitmodules

@@ -18,3 +18,6 @@
 	path = external/curl
 	url = https://github.com/curl/curl
 	ignore = dirty
+[submodule "external/capstone"]
+	path = external/capstone
+	url = https://github.com/capstone-engine/capstone

.idea/vcs.xml

@@ -2,6 +2,7 @@
 <project version="4">
   <component name="VcsDirectoryMappings">
     <mapping directory="$PROJECT_DIR$" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/external/capstone" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/external/curl" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/external/fmt" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/external/nativefiledialog" vcs="Git" />

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.16)
 
 # Updating the version here will update it throughout ImHex as well
-set(IMHEX_VERSION "1.11.2")
+set(IMHEX_VERSION "1.12.1")
 project(imhex VERSION ${IMHEX_VERSION})
 
 set(CMAKE_CXX_STANDARD 20)
@@ -18,8 +18,6 @@ set(PLUGINS
         # example_rust
         )
 
-findLibraries()
-
 detectOS()
 detectArch()
 
@@ -30,7 +28,7 @@ add_subdirectory(plugins/libimhex)
 include_directories(include)
 
 enable_testing()
-add_subdirectory(tests)
+add_subdirectory(tests EXCLUDE_FROM_ALL)
 
 addVersionDefines()
 configurePackageCreation()
@@ -46,33 +44,7 @@ add_executable(imhex ${application_type}
         source/init/splash_window.cpp
         source/init/tasks.cpp
 
-        source/helpers/patches.cpp
-        source/helpers/project_file_handler.cpp
-        source/helpers/loader_script_handler.cpp
         source/helpers/plugin_manager.cpp
-        source/helpers/encoding_file.cpp
-
-        source/providers/file_provider.cpp
-
-        source/views/view_hexeditor.cpp
-        source/views/view_pattern_editor.cpp
-        source/views/view_pattern_data.cpp
-        source/views/view_hashes.cpp
-        source/views/view_information.cpp
-        source/views/view_help.cpp
-        source/views/view_tools.cpp
-        source/views/view_strings.cpp
-        source/views/view_data_inspector.cpp
-        source/views/view_disassembler.cpp
-        source/views/view_bookmarks.cpp
-        source/views/view_patches.cpp
-        source/views/view_command_palette.cpp
-        source/views/view_settings.cpp
-        source/views/view_data_processor.cpp
-        source/views/view_yara.cpp
-        source/views/view_constants.cpp
-        source/views/view_store.cpp
-        source/views/view_diff.cpp
 
         ${imhex_icon}
         )
@@ -80,9 +52,9 @@ add_executable(imhex ${application_type}
 set_target_properties(imhex PROPERTIES CXX_VISIBILITY_PRESET hidden)
 
 if (WIN32)
-    target_link_libraries(imhex dl libimhex wsock32 ws2_32 Dwmapi.lib)
+    target_link_libraries(imhex PUBLIC dl libimhex wsock32 ws2_32 Dwmapi.lib)
 else ()
-    target_link_libraries(imhex dl libimhex pthread)
+    target_link_libraries(imhex PUBLIC dl libimhex pthread)
 endif ()
 
 createPackage()

cmake/build_helpers.cmake

@@ -27,22 +27,13 @@ macro(addVersionDefines)
     set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -DRELEASE -DIMHEX_VERSION=\"\\\"${PROJECT_VERSION}-ReleaseMinimumSize\"\\\"")
 endmacro()
 
-macro(findLibraries)
+macro(configurePython)
     set(CMAKE_FIND_PACKAGE_SORT_ORDER NATURAL)
     set(CMAKE_FIND_PACKAGE_SORT_DIRECTION DEC)
 
     # Enforce that we use non system Python 3 on macOS.
     set(Python_FIND_FRAMEWORK NEVER)
 
-    # Find packages
-    find_package(PkgConfig REQUIRED)
-
-    find_package(mbedTLS 2.26.0 REQUIRED)
-
-    pkg_search_module(CAPSTONE 4.0.2 REQUIRED capstone)
-
-    find_package(OpenGL REQUIRED)
-
     find_package(Python COMPONENTS Development REQUIRED)
     if(Python_VERSION LESS 3)
         message(STATUS ${PYTHON_VERSION_MAJOR_MINOR})
@@ -59,13 +50,6 @@ macro(findLibraries)
     list(JOIN PYTHON_VERSION_MAJOR_MINOR "." PYTHON_VERSION_MAJOR_MINOR)
 
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_C_FLAGS} -DPYTHON_VERSION_MAJOR_MINOR=\"\\\"${PYTHON_VERSION_MAJOR_MINOR}\"\\\"")
-
-    pkg_search_module(MAGIC libmagic>=5.39)
-    if(NOT MAGIC_FOUND)
-        find_library(MAGIC 5.39 magic REQUIRED)
-    else()
-        set(MAGIC_INCLUDE_DIRS ${MAGIC_INCLUDEDIR})
-    endif()
 endmacro()
 
 # Detect current OS / System
@@ -199,19 +183,19 @@ macro(createPackage)
         INSTALL(CODE "LIST(APPEND DEP_FOLDERS \${PY_PARENT})")
         install(CODE [[
         file(GET_RUNTIME_DEPENDENCIES
-            EXECUTABLES $<TARGET_FILE:imhex>
+            EXECUTABLES $<TARGET_FILE:builtin> $<TARGET_FILE:libimhex> $<TARGET_FILE:imhex>
             RESOLVED_DEPENDENCIES_VAR _r_deps
             UNRESOLVED_DEPENDENCIES_VAR _u_deps
             CONFLICTING_DEPENDENCIES_PREFIX _c_deps
-            DIRECTORIES ${DEP_FOLDERS}
+            DIRECTORIES ${DEP_FOLDERS} $ENV{PATH}
             POST_EXCLUDE_REGEXES ".*system32/.*\\.dll"
         )
 
         if(_u_deps)
-            message(WARNING "There were unresolved dependencies for binary $<TARGET_FILE:imhex>: \"${_u_deps}\"!")
+            message(WARNING "There were unresolved dependencies for binary: \"${_u_deps}\"!")
         endif()
         if(_c_deps_FILENAMES)
-            message(WARNING "There were conflicting dependencies for library $<TARGET_FILE:imhex>: \"${_c_deps}\"!")
+            message(WARNING "There were conflicting dependencies for library: \"${_c_deps}\"!")
         endif()
 
         foreach(_file ${_r_deps})

dist/AppImage/package.sh

@@ -39,7 +39,9 @@ mv ${BUILDDIR}/ImHex.AppDir/AppRun-x86_64 ${APPDIR}/AppRun
 chmod a+x ${BUILDDIR}/ImHex.AppDir/AppRun
 
 ## Add all dependencies
-ldd ${BUILDDIR}/imhex | awk '/ => /{print $3}' | xargs -I '{}' cp '{}' ${APPDIR}/usr/lib
+ldd ${BUILDDIR}/imhex | awk '/ => /{print $3}' | awk '!/(libc|libstdc++|libc++|libdl|libpthread|libselinux|ld-linux|libgdk)/' | xargs -I '{}' cp '{}' ${APPDIR}/usr/lib
+ldd ${BUILDDIR}/plugins/builtin/builtin.hexplug | awk '/ => /{print $3}' | awk '!/(libc|libstdc++|libc++|libdl|libpthread|libselinux|ld-linux|libgdk)/' | xargs -I '{}' cp '{}' ${APPDIR}/usr/lib
+ldd ${BUILDDIR}/plugins/libimhex/libimhex.so | awk '/ => /{print $3}' | awk '!/(libc|libstdc++|libc++|libdl|libpthread|libselinux|ld-linux|libgdk)/' | xargs -I '{}' cp '{}' ${APPDIR}/usr/lib
 
 # Package it up as described here:
 # https://github.com/AppImage/AppImageKit#appimagetool-usage

dist/Brewfile

@@ -1,6 +1,5 @@
 brew "glfw3"
 brew "mbedtls"
-brew "capstone"
 brew "nlohmann-json"
 brew "cmake"
 brew "ccache"

dist/Dockerfile

@@ -13,7 +13,6 @@ RUN pacman -S --needed --noconfirm      \
     glfw-x11                            \
     file                                \
     mbedtls                             \
-    capstone                            \
     python3                             \
     freetype2                           \
     gtk3

dist/ImHex-9999.ebuild

@@ -26,7 +26,6 @@ RDEPEND="${DEPEND}
 		media-libs/glfw
 		sys-apps/file
 		dev-libs/mbedtls
-		dev-libs/capstone
 		dev-cpp/nlohmann_json
 		x11-libs/gtk+
 		"

dist/get_deps_archlinux.sh

@@ -6,7 +6,6 @@ pacman -S --needed \
   glfw \
   file \
   mbedtls \
-  capstone \
   python3 \
   freetype2 \
   gtk3

dist/get_deps_debian.sh

@@ -22,7 +22,6 @@ apt install -y \
   libglm-dev            \
   libmagic-dev          \
   libmbedtls-dev        \
-  libcapstone-dev       \
   python3-dev           \
   libfreetype-dev       \
   libgtk-3-dev          \

dist/get_deps_fedora.sh

@@ -3,7 +3,6 @@
 dnf install \
   cmake \
   gcc-c++ \
-  capstone-devel \
   file-devel \
   glfw-devel \
   mesa-libGL-devel \

dist/get_deps_msys2.sh

@@ -5,7 +5,6 @@ pacman -S --needed --noconfirm \
   mingw-w64-x86_64-cmake \
   mingw-w64-x86_64-make \
   mingw-w64-x86_64-ccache \
-  mingw-w64-x86_64-capstone \
   mingw-w64-x86_64-glfw \
   mingw-w64-x86_64-file \
   mingw-w64-x86_64-mbedtls \

dist/msys2/PKGBUILD

@@ -12,7 +12,6 @@ makedepends=("${MINGW_PACKAGE_PREFIX}-gcc"
              "${MINGW_PACKAGE_PREFIX}-cmake"
              "${MINGW_PACKAGE_PREFIX}-make"
              "${MINGW_PACKAGE_PREFIX}-dlfcn"
-             "${MINGW_PACKAGE_PREFIX}-capstone"
              "${MINGW_PACKAGE_PREFIX}-glfw"
              "${MINGW_PACKAGE_PREFIX}-file"
              "${MINGW_PACKAGE_PREFIX}-mbedtls"

dist/net.werwolv.ImHex.yaml

@@ -3,7 +3,7 @@ runtime: org.freedesktop.Platform
 runtime-version: '20.08'
 default-branch: stable
 sdk: org.freedesktop.Sdk
-command: /usr/bin/imhex
+command: /bin/imhex
 
 finish-args:
   - --share=ipc
@@ -12,16 +12,6 @@ finish-args:
   - --device=all
 
 modules:
-  - name: capstone
-    buildsystem: cmake-ninja
-    builddir: true
-    config-opts:
-      - -DCMAKE_BUILD_TYPE=RelWithDebInfo
-    sources:
-      - type: archive
-        url: https://github.com/aquynh/capstone/archive/4.0.2.tar.gz
-        sha256: 7c81d798022f81e7507f1a60d6817f63aa76e489aa4e7055255f21a22f5e526a
-
   - name: libiconv
     sources:
       - type: archive
@@ -64,7 +54,7 @@ modules:
         sha256: 4cf0df69731494668bdd6460ed8cb269b68de9c19ad8c27abc24cd72605b2d5b
 
   - name: imhex
-    buildsystem: cmake-ninja
+    buildsystem: cmake
 
     sources:
       - type: git

external/ImGui/CMakeLists.txt

@@ -5,6 +5,7 @@ set(CMAKE_CXX_STANDARD 17)
 
 find_package(PkgConfig REQUIRED)
 find_package(Freetype REQUIRED)
+find_package(OpenGL REQUIRED)
 pkg_search_module(GLFW REQUIRED glfw3)
 
 if (UNIX)

external/ImGui/include/imgui_imhex_extensions.h

@@ -45,6 +45,8 @@ namespace ImGui {
         }
     };
 
+    int UpdateStringSizeCallback(ImGuiInputTextCallbackData *data);
+
     bool IconHyperlink(const char *icon, const char* label, const ImVec2& size_arg = ImVec2(0, 0), ImGuiButtonFlags flags = 0);
     bool Hyperlink(const char* label, const ImVec2& size_arg = ImVec2(0, 0), ImGuiButtonFlags flags = 0);
     bool BulletHyperlink(const char* label, const ImVec2& size_arg = ImVec2(0, 0), ImGuiButtonFlags flags = 0);

external/ImGui/include/imgui_memory_editor.h

@@ -239,7 +239,9 @@ struct MemoryEditor
             DataPreviewAddrOld = DataPreviewAddr;
             DataPreviewAddrEndOld = DataPreviewAddrEnd;
 
-            DrawContents(mem_data, mem_size, base_display_addr);
+            if (mem_size > 0)
+                DrawContents(mem_data, mem_size, base_display_addr);
+
             if (ContentsWidthChanged)
             {
                 CalcSizes(s, mem_size, base_display_addr);
@@ -706,8 +708,8 @@ struct MemoryEditor
     {
         IM_UNUSED(mem_data);
         ImGuiStyle& style = ImGui::GetStyle();
-        const char* format_range = OptUpperCaseHex ? "Range %0*" _PRISizeT "X..%0*" _PRISizeT "X" : "Range %0*" _PRISizeT "x..%0*" _PRISizeT "x";
-        const char* format_selection = OptUpperCaseHex ? "Selection %0*" _PRISizeT "X..%0*" _PRISizeT "X (%ld %s)" : "Range %0*" _PRISizeT "x..%0*" _PRISizeT "x (%ld %s)";
+        const char* format_range = OptUpperCaseHex ? "Range 0x%0*" _PRISizeT "X..0x%0*" _PRISizeT "X" : "Range 0x%0*" _PRISizeT "x..0x%0*" _PRISizeT "x";
+        const char* format_selection = OptUpperCaseHex ? "Selection 0x%0*" _PRISizeT "X..0x%0*" _PRISizeT "X (%ld [0x%lX] %s)" : "Range 0x%0*" _PRISizeT "x..0x%0*" _PRISizeT "x (%ld [0x%lX] %s)";
 
         if (this->OptShowExtraInfo) {
             ImGui::Text(format_range, s.AddrDigitsCount, base_display_addr, s.AddrDigitsCount, base_display_addr + mem_size - 1);
@@ -720,7 +722,7 @@ struct MemoryEditor
                 auto selectionEnd = std::max(DataPreviewAddr, DataPreviewAddrEnd);
 
                 size_t regionSize = (selectionEnd - selectionStart) + 1;
-                ImGui::Text(format_selection, s.AddrDigitsCount, base_display_addr + selectionStart, s.AddrDigitsCount, base_display_addr + selectionEnd, regionSize, regionSize == 1 ? "byte" : "bytes");
+                ImGui::Text(format_selection, s.AddrDigitsCount, base_display_addr + selectionStart, s.AddrDigitsCount, base_display_addr + selectionEnd, regionSize, regionSize, regionSize == 1 ? "byte" : "bytes");
             }
         }
 

external/ImGui/source/imgui_imhex_extensions.cpp

@@ -15,6 +15,13 @@
 
 namespace ImGui {
 
+    int UpdateStringSizeCallback(ImGuiInputTextCallbackData *data) {
+        auto &mathInput = *static_cast<std::string*>(data->UserData);
+
+        mathInput.resize(data->BufTextLen);
+        return 0;
+    }
+
     bool IconHyperlink(const char *icon, const char* label, const ImVec2& size_arg, ImGuiButtonFlags flags) {
         ImGuiWindow* window = GetCurrentWindow();
         if (window->SkipItems)

external/ImGui/source/imgui_impl_glfw.cpp

@@ -472,10 +472,12 @@ static void ImGui_ImplGlfw_UpdateMouseCursor()
         }
         else
         {
-            // Show OS mouse cursor
-            // FIXME-PLATFORM: Unfocused windows seems to fail changing the mouse cursor with GLFW 3.2, but 3.3 works here.
-            glfwSetCursor(window, bd->MouseCursors[imgui_cursor] ? bd->MouseCursors[imgui_cursor] : bd->MouseCursors[ImGuiMouseCursor_Arrow]);
-            glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+            #if !defined(OS_WINDOWS)
+                // Show OS mouse cursor
+                // FIXME-PLATFORM: Unfocused windows seems to fail changing the mouse cursor with GLFW 3.2, but 3.3 works here.
+                glfwSetCursor(window, bd->MouseCursors[imgui_cursor] ? bd->MouseCursors[imgui_cursor] : bd->MouseCursors[ImGuiMouseCursor_Arrow]);
+                glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+            #endif
         }
     }
 }

external/yara/CMakeLists.txt

@@ -104,6 +104,7 @@ add_compile_definitions("MAGIC_MODULE")
 add_compile_definitions("MACHO_MODULE")
 add_compile_definitions("DEX_MODULE")
 
+find_package(mbedTLS 2.26.0 REQUIRED)
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-shift-count-overflow")
 add_library(libyara STATIC ${LIBYARA_SOURCE} ${LIBYARA_INCLUDES} ${LIBYARA_MODULES})
@@ -115,10 +116,12 @@ target_include_directories(
         PRIVATE ${LIBYARA_SOURCE_PATH} ${MBEDTLS_INCLUDE_DIR}
 )
 
+target_link_directories(libyara PRIVATE ${MBEDTLS_LIBRARY_DIR})
+
 if (UNIX)
-    target_link_libraries(libyara magic pthread)
+    target_link_libraries(libyara PRIVATE magic ${MBEDTLS_LIBRARIES} pthread)
 else ()
-    target_link_libraries(libyara magic)
+    target_link_libraries(libyara PRIVATE magic ${MBEDTLS_LIBRARIES})
 endif ()
 
 include(GNUInstallDirs)

include/window.hpp

@@ -25,7 +25,8 @@ namespace hex {
 
     private:
         void setupNativeWindow();
-        void updateNativeWindow();
+        void beginNativeWindowFrame();
+        void endNativeWindowFrame();
         void drawTitleBar();
 
         void frameBegin();
@@ -61,8 +62,8 @@ namespace hex {
         bool m_showTipOfTheDay;
         std::string m_tipOfTheDay;
 
-        ImGui::Texture m_bannerTexture;
-        ImGui::Texture m_logoTexture;
+        ImGui::Texture m_bannerTexture = { 0 };
+        ImGui::Texture m_logoTexture = { 0 };
 
         std::filesystem::path m_safetyBackupPath;
 

plugins/builtin/CMakeLists.txt

@@ -13,6 +13,34 @@ add_library(${PROJECT_NAME} SHARED
         source/content/tools_entries.cpp
         source/content/data_processor_nodes.cpp
         source/content/ui_items.cpp
+        source/content/providers.cpp
+        source/content/views.cpp
+
+        source/content/providers/file_provider.cpp
+        source/content/providers/gdb_provider.cpp
+        source/content/providers/disk_provider.cpp
+
+        source/content/views/view_hexeditor.cpp
+        source/content/views/view_pattern_editor.cpp
+        source/content/views/view_pattern_data.cpp
+        source/content/views/view_hashes.cpp
+        source/content/views/view_information.cpp
+        source/content/views/view_help.cpp
+        source/content/views/view_tools.cpp
+        source/content/views/view_strings.cpp
+        source/content/views/view_data_inspector.cpp
+        source/content/views/view_disassembler.cpp
+        source/content/views/view_bookmarks.cpp
+        source/content/views/view_patches.cpp
+        source/content/views/view_command_palette.cpp
+        source/content/views/view_settings.cpp
+        source/content/views/view_data_processor.cpp
+        source/content/views/view_yara.cpp
+        source/content/views/view_constants.cpp
+        source/content/views/view_store.cpp
+        source/content/views/view_diff.cpp
+        source/content/views/view_provider_settings.cpp
+
 
         source/math_evaluator.cpp
 
@@ -24,11 +52,10 @@ add_library(${PROJECT_NAME} SHARED
 
 # Add additional include directories here #
 target_include_directories(${PROJECT_NAME} PRIVATE include)
+
 # Add additional libraries here #
 target_link_libraries(${PROJECT_NAME} PRIVATE libimhex LLVMDemangle)
 
-
-
 # ---- No need to change anything from here downwards unless you know what you're doing ---- #
 
 set(CMAKE_CXX_STANDARD 20)

plugins/builtin/include/content/providers/disk_provider.hpp

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <hex/providers/provider.hpp>
+
+#include <set>
+#include <string>
+#include <vector>
+
+#if defined(OS_WINDOWS)
+    #include <windows.h>
+#endif
+
+namespace hex::plugin::builtin::prv {
+
+    class DiskProvider : public hex::prv::Provider {
+    public:
+        DiskProvider();
+        ~DiskProvider() override;
+
+        [[nodiscard]] bool isAvailable() const override;
+        [[nodiscard]] bool isReadable() const override;
+        [[nodiscard]] bool isWritable() const override;
+        [[nodiscard]] bool isResizable() const override;
+        [[nodiscard]] bool isSavable() const override;
+
+        void readRaw(u64 offset, void *buffer, size_t size) override;
+        void writeRaw(u64 offset, const void *buffer, size_t size) override;
+        [[nodiscard]] size_t getActualSize() const override;
+
+        void setPath(const std::string &path);
+
+        [[nodiscard]] bool open() override;
+        void close() override;
+
+        [[nodiscard]] virtual std::string getName() const;
+        [[nodiscard]] virtual std::vector<std::pair<std::string, std::string>> getDataInformation() const;
+
+        [[nodiscard]] bool hasLoadInterface() const override { return true; }
+        void drawLoadInterface() override;
+
+    protected:
+        void reloadDrives();
+
+        std::set<std::string> m_availableDrives;
+        std::string m_path;
+
+        #if defined(OS_WINDOWS)
+            HANDLE m_diskHandle = INVALID_HANDLE_VALUE;
+        #else
+            int m_diskHandle = -1;
+        #endif
+
+        size_t m_diskSize;
+        size_t m_sectorSize;
+
+        u64 m_sectorBufferAddress;
+        std::vector<u8> m_sectorBuffer;
+
+        bool m_readable = false;
+        bool m_writable = false;
+    };
+
+}

plugins/builtin/include/content/providers/file_provider.hpp

@@ -14,18 +14,18 @@
 #include <sys/fcntl.h>
 #endif
 
-namespace hex::prv {
+namespace hex::plugin::builtin::prv {
 
-    class FileProvider : public Provider {
+    class FileProvider : public hex::prv::Provider {
     public:
-        explicit FileProvider(std::string path);
+        explicit FileProvider();
         ~FileProvider() override;
 
-        bool isAvailable() const override;
-        bool isReadable() const override;
-        bool isWritable() const override;
-        bool isResizable() const override;
-        bool isSavable() const override;
+        [[nodiscard]] bool isAvailable() const override;
+        [[nodiscard]] bool isReadable() const override;
+        [[nodiscard]] bool isWritable() const override;
+        [[nodiscard]] bool isResizable() const override;
+        [[nodiscard]] bool isSavable() const override;
 
         void read(u64 offset, void *buffer, size_t size, bool overlays) override;
         void write(u64 offset, const void *buffer, size_t size) override;
@@ -33,7 +33,7 @@ namespace hex::prv {
 
         void readRaw(u64 offset, void *buffer, size_t size) override;
         void writeRaw(u64 offset, const void *buffer, size_t size) override;
-        size_t getActualSize() const override;
+        [[nodiscard]] size_t getActualSize() const override;
 
         void save() override;
         void saveAs(const std::string &path) override;
@@ -41,7 +41,12 @@ namespace hex::prv {
         [[nodiscard]] std::string getName() const override;
         [[nodiscard]] std::vector<std::pair<std::string, std::string>> getDataInformation() const override;
 
-    private:
+        void setPath(const std::string &path);
+
+        [[nodiscard]] bool open() override;
+        void close() override;
+
+    protected:
         #if defined(OS_WINDOWS)
         HANDLE m_file = INVALID_HANDLE_VALUE;
         HANDLE m_mapping = INVALID_HANDLE_VALUE;
@@ -54,12 +59,10 @@ namespace hex::prv {
         size_t m_fileSize = 0;
 
         bool m_fileStatsValid = false;
+        bool m_emptyFile = false;
         struct stat m_fileStats = { 0 };
 
         bool m_readable = false, m_writable = false;
-
-        void open();
-        void close();
     };
 
 }

plugins/builtin/include/content/providers/gdb_provider.hpp

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <hex/helpers/socket.hpp>
+#include <hex/providers/provider.hpp>
+
+#include <mutex>
+#include <string_view>
+#include <thread>
+
+namespace hex::plugin::builtin::prv {
+
+class GDBProvider : public hex::prv::Provider {
+    public:
+        explicit GDBProvider();
+        ~GDBProvider() override;
+
+        [[nodiscard]] bool isAvailable() const override;
+        [[nodiscard]] bool isReadable() const override;
+        [[nodiscard]] bool isWritable() const override;
+        [[nodiscard]] bool isResizable() const override;
+        [[nodiscard]] bool isSavable() const override;
+
+        void read(u64 offset, void *buffer, size_t size, bool overlays) override;
+        void write(u64 offset, const void *buffer, size_t size) override;
+        void resize(ssize_t newSize) override;
+
+        void readRaw(u64 offset, void *buffer, size_t size) override;
+        void writeRaw(u64 offset, const void *buffer, size_t size) override;
+        [[nodiscard]] size_t getActualSize() const override;
+
+        void save() override;
+        void saveAs(const std::string &path) override;
+
+        [[nodiscard]] std::string getName() const override;
+        [[nodiscard]] std::vector<std::pair<std::string, std::string>> getDataInformation() const override;
+
+        [[nodiscard]] bool open() override;
+        void close() override;
+
+        [[nodiscard]] bool isConnected() const;
+
+        [[nodiscard]] bool hasLoadInterface() const override { return true; }
+        void drawLoadInterface() override;
+
+    protected:
+        hex::Socket m_socket;
+
+        std::string m_ipAddress;
+        int m_port;
+
+        constexpr static size_t CacheLineSize = 0x1000;
+
+        struct CacheLine {
+            u64 address;
+
+            std::array<u8, CacheLineSize> data;
+        };
+
+        std::list<CacheLine> m_cache;
+
+        std::thread m_cacheUpdateThread;
+        std::mutex m_cacheLock;
+    };
+
+}

plugins/builtin/include/content/views/view_bookmarks.hpp

@@ -5,7 +5,7 @@
 #include <vector>
 #include <list>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     namespace prv { class Provider; }
 

plugins/builtin/include/content/views/view_command_palette.hpp

@@ -9,7 +9,7 @@
 #include <tuple>
 #include <cstdio>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     namespace prv { class Provider; }
 

plugins/builtin/include/content/views/view_constants.hpp

@@ -5,7 +5,7 @@
 #include <cstdio>
 #include <string>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     enum class ConstantType {
         Int10,

plugins/builtin/include/content/views/view_data_inspector.hpp

@@ -8,7 +8,7 @@
 #include <cstdio>
 #include <string>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     namespace prv { class Provider; }
 
@@ -23,7 +23,7 @@ namespace hex {
     private:
         struct InspectorCacheEntry {
             std::string unlocalizedName;
-            ContentRegistry::DataInspector::DisplayFunction displayFunction;
+            ContentRegistry::DataInspector::impl::DisplayFunction displayFunction;
         };
 
         bool m_shouldInvalidate = true;

plugins/builtin/include/content/views/view_data_processor.hpp

@@ -10,7 +10,7 @@
 #include <array>
 #include <string>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     namespace prv { class Provider; }
 
@@ -27,7 +27,7 @@ namespace hex {
         std::list<dp::Node*> m_nodes;
         std::list<dp::Link>  m_links;
 
-        std::vector<prv::Overlay*> m_dataOverlays;
+        std::vector<hex::prv::Overlay*> m_dataOverlays;
 
         int m_rightClickedId = -1;
         ImVec2 m_rightClickedCoords;

plugins/builtin/include/content/views/view_diff.hpp

@@ -9,7 +9,7 @@
 #include <string>
 #include <vector>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     namespace prv { class Provider; }
 

plugins/builtin/include/content/views/view_disassembler.hpp

@@ -2,13 +2,13 @@
 
 #include <hex/views/view.hpp>
 
-#include "helpers/disassembler.hpp"
+#include <hex/helpers/disassembler.hpp>
 
 #include <cstdio>
 #include <string>
 #include <vector>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     namespace prv { class Provider; }
 
@@ -37,7 +37,12 @@ namespace hex {
         bool m_shouldMatchSelection = false;
 
         Architecture m_architecture = Architecture::ARM;
-        cs_mode m_modeBasicARM = cs_mode(0), m_modeExtraARM = cs_mode(0), m_modeBasicMIPS = cs_mode(0), m_modeBasicPPC = cs_mode(0), m_modeBasicX86 = cs_mode(0);
+        cs_mode m_modeBasicARM = cs_mode(0);
+        cs_mode m_modeExtraARM = cs_mode(0);
+        cs_mode m_modeBasicMIPS = cs_mode(0);
+        cs_mode m_modeBasicPPC = cs_mode(0);
+        cs_mode m_modeBasicX86 = cs_mode(0);
+
         bool m_littleEndianMode = true, m_micoMode = false, m_sparcV9Mode = false;
 
         std::vector<Disassembly> m_disassembly;

plugins/builtin/include/content/views/view_hashes.hpp

@@ -6,7 +6,7 @@
 #include <utility>
 #include <cstdio>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     namespace prv { class Provider; }
 

plugins/builtin/include/content/views/view_help.hpp

@@ -9,7 +9,7 @@
 #include <tuple>
 #include <cstdio>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     namespace prv { class Provider; }
 
@@ -30,12 +30,13 @@ namespace hex {
 
     private:
         bool m_aboutWindowOpen = false;
-        bool m_patternHelpWindowOpen = false;
-        bool m_mathHelpWindowOpen = false;
 
         void drawAboutPopup();
-        void drawPatternHelpPopup();
-        void drawMathEvaluatorHelp();
+
+        void drawAboutMainPage();
+        void drawContributorPage();
+        void drawLibraryCreditsPage();
+        void drawPathsPage();
     };
 
 }

plugins/builtin/include/content/views/view_hexeditor.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <hex/views/view.hpp>
-#include "helpers/encoding_file.hpp"
+#include <hex/helpers/encoding_file.hpp>
 
 #include <imgui_memory_editor.h>
 
@@ -10,9 +10,11 @@
 #include <random>
 #include <vector>
 
-namespace hex {
+namespace hex::prv { class Provider; }
+
+
+namespace hex::plugin::builtin {
 
-    namespace prv { class Provider; }
 
     using SearchFunction = std::vector<std::pair<u64, u64>> (*)(prv::Provider* &provider, std::string string);
 

plugins/builtin/include/content/views/view_information.hpp

@@ -3,11 +3,12 @@
 #include <hex/views/view.hpp>
 
 #include <array>
+#include <atomic>
 #include <cstdio>
 #include <string>
 #include <vector>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     namespace prv { class Provider; }
 
@@ -30,6 +31,7 @@ namespace hex {
 
         std::array<ImU64, 256> m_valueCounts = { 0 };
         bool m_analyzing = false;
+        std::atomic<u64> m_bytesAnalyzed;
 
         std::pair<u64, u64> m_analyzedRegion = { 0, 0 };
 

plugins/builtin/include/content/views/view_patches.hpp

@@ -7,7 +7,7 @@
 
 #include <optional>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     namespace prv { class Provider; }
 

plugins/builtin/include/content/views/view_pattern_data.hpp

@@ -14,6 +14,11 @@ namespace hex {
     namespace prv { class Provider; }
     namespace lang { class PatternData; }
 
+}
+
+
+namespace hex::plugin::builtin {
+
     class ViewPatternData : public View {
     public:
         ViewPatternData();

plugins/builtin/include/content/views/view_pattern_editor.hpp

@@ -13,7 +13,7 @@
 
 #include <TextEditor.h>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     class ViewPatternEditor : public View {
     public:
@@ -37,6 +37,21 @@ namespace hex {
         TextEditor m_textEditor;
         std::vector<std::pair<pl::LogConsole::Level, std::string>> m_console;
 
+        enum class EnvVarType {
+            Integer,
+            Float,
+            String,
+            Bool
+        };
+
+        struct EnvVar {
+            std::string name;
+            pl::Token::Literal value;
+            EnvVarType type;
+        };
+
+        std::vector<EnvVar> m_envVarEntries;
+
         void loadPatternFile(const std::string &path);
         void clearPatternData();
         void parsePattern(char *buffer);

plugins/builtin/include/content/views/view_provider_settings.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <hex.hpp>
+
+#include <imgui.h>
+#include <hex/views/view.hpp>
+
+#include <array>
+#include <string>
+
+namespace hex::plugin::builtin {
+
+    class ViewProviderSettings : public hex::View {
+    public:
+        ViewProviderSettings();
+        ~ViewProviderSettings();
+
+        void drawContent() override;
+        void drawAlwaysVisible() override;
+
+        bool hasViewMenuItemEntry() override;
+
+        bool isAvailable();
+    };
+
+}

plugins/builtin/include/content/views/view_settings.hpp

@@ -5,7 +5,7 @@
 #include <cstdio>
 #include <string>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     class ViewSettings : public View {
     public:

plugins/builtin/include/content/views/view_store.hpp

@@ -11,7 +11,7 @@
 #include <string>
 #include <filesystem>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     struct StoreEntry {
         std::string name;

plugins/builtin/include/content/views/view_strings.hpp

@@ -5,7 +5,7 @@
 #include <cstdio>
 #include <string>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     namespace prv { class Provider; }
 

plugins/builtin/include/content/views/view_tools.hpp

@@ -8,7 +8,7 @@
 #include <array>
 #include <string>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     namespace prv { class Provider; }
 

plugins/builtin/include/content/views/view_yara.hpp

@@ -5,7 +5,7 @@
 #include <imgui.h>
 #include <hex/views/view.hpp>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     class ViewYara : public View {
     public:

plugins/builtin/source/content/pl_builtin_functions.cpp

@@ -51,7 +51,7 @@ namespace hex::plugin::builtin {
             /* assert(condition, message) */
             ContentRegistry::PatternLanguageFunctions::add(nsStd, "assert", 2, [](Evaluator *ctx, auto params) -> std::optional<Token::Literal> {
                 auto condition = Token::literalToBoolean(params[0]);
-                auto message = std::get<std::string>(params[1]);
+                auto message = Token::literalToString(params[1], false);
 
                 if (!condition)
                     LogConsole::abortEvaluation(hex::format("assertion failed \"{0}\"", message));
@@ -62,7 +62,7 @@ namespace hex::plugin::builtin {
             /* assert_warn(condition, message) */
             ContentRegistry::PatternLanguageFunctions::add(nsStd, "assert_warn", 2, [](auto *ctx, auto params) -> std::optional<Token::Literal> {
                 auto condition = Token::literalToBoolean(params[0]);
-                auto message = std::get<std::string>(params[1]);
+                auto message = Token::literalToString(params[1], false);
 
                 if (!condition)
                     ctx->getConsole().log(LogConsole::Level::Warning, hex::format("assertion failed \"{0}\"", message));
@@ -82,6 +82,13 @@ namespace hex::plugin::builtin {
                 return format(ctx, params);
             });
 
+            /* env(name) */
+            ContentRegistry::PatternLanguageFunctions::add(nsStd, "env", 1, [](Evaluator *ctx, auto params) -> std::optional<Token::Literal> {
+                auto name = Token::literalToString(params[0], false);
+
+                return ctx->getEnvVariable(name);
+            });
+
         }
 
         ContentRegistry::PatternLanguageFunctions::Namespace nsStdMem = { "std", "mem" };

plugins/builtin/source/content/providers.cpp

@@ -0,0 +1,17 @@
+#include <hex/api/content_registry.hpp>
+
+#include "content/providers/gdb_provider.hpp"
+#include "content/providers/file_provider.hpp"
+#include "content/providers/disk_provider.hpp"
+
+namespace hex::plugin::builtin {
+
+    void registerProviders() {
+
+        ContentRegistry::Provider::add<prv::FileProvider>("hex.builtin.provider.file", false);
+        ContentRegistry::Provider::add<prv::GDBProvider>("hex.builtin.provider.gdb");
+        ContentRegistry::Provider::add<prv::DiskProvider>("hex.builtin.provider.disk");
+
+    }
+
+}

plugins/builtin/source/content/providers/disk_provider.cpp

@@ -0,0 +1,322 @@
+#include "content/providers/disk_provider.hpp"
+
+#include <hex/helpers/fmt.hpp>
+
+#include <bitset>
+#include <filesystem>
+
+#if defined (OS_LINUX)
+    #include <fcntl.h>
+    #include <unistd.h>
+    #include <sys/stat.h>
+    #include <sys/types.h>
+
+    #define lseek lseek64
+#elif defined (OS_MACOS)
+    #include <fcntl.h>
+    #include <unistd.h>
+    #include <sys/stat.h>
+    #include <sys/types.h>
+#endif
+
+namespace hex::plugin::builtin::prv {
+
+    DiskProvider::DiskProvider() : Provider() {
+        this->reloadDrives();
+    }
+
+    DiskProvider::~DiskProvider() {
+        this->close();
+    }
+
+    bool DiskProvider::isAvailable() const {
+        #if defined (OS_WINDOWS)
+            return this->m_diskHandle != INVALID_HANDLE_VALUE;
+        #else
+            return this->m_diskHandle != -1;
+        #endif
+    }
+
+    bool DiskProvider::isReadable() const {
+        return this->m_readable;
+    }
+
+    bool DiskProvider::isWritable() const {
+        return this->m_writable;
+    }
+
+    bool DiskProvider::isResizable() const {
+        return false;
+    }
+
+    bool DiskProvider::isSavable() const {
+        return false;
+    }
+
+
+    void DiskProvider::setPath(const std::string &path) {
+        this->m_path = path;
+    }
+
+    bool DiskProvider::open() {
+        this->m_readable = true;
+        this->m_writable = true;
+
+        #if defined (OS_WINDOWS)
+
+            std::wstring widePath;
+            {
+                auto length = this->m_path.length() + 1;
+                auto wideLength = MultiByteToWideChar(CP_UTF8, 0, this->m_path.data(), length, 0, 0);
+                auto buffer = new wchar_t[wideLength];
+                MultiByteToWideChar(CP_UTF8, 0, this->m_path.data(), length, buffer, wideLength);
+                widePath = buffer;
+                delete[] buffer;
+            }
+
+            this->m_diskHandle = reinterpret_cast<HANDLE>(CreateFileW(widePath.data(), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr));
+            if (this->m_diskHandle == INVALID_HANDLE_VALUE) {
+                this->m_diskHandle = reinterpret_cast<HANDLE>(CreateFileW(widePath.data(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr));
+                this->m_writable = false;
+
+                if (this->m_diskHandle == INVALID_HANDLE_VALUE)
+                    return false;
+            }
+
+            {
+                DISK_GEOMETRY_EX diskGeometry = { 0 };
+                DWORD bytesRead = 0;
+                if (DeviceIoControl(
+                        this->m_diskHandle,
+                        IOCTL_DISK_GET_DRIVE_GEOMETRY_EX,
+                        nullptr, 0,
+                        &diskGeometry, sizeof(DISK_GEOMETRY_EX),
+                        &bytesRead,
+                        nullptr))
+                {
+                    this->m_diskSize = diskGeometry.DiskSize.QuadPart;
+                    this->m_sectorSize = diskGeometry.Geometry.BytesPerSector;
+                    this->m_sectorBuffer.resize(this->m_sectorSize);
+                }
+            }
+
+            if (this->m_diskHandle == nullptr || this->m_diskHandle == INVALID_HANDLE_VALUE) {
+                this->m_readable = false;
+                this->m_diskHandle = nullptr;
+                CloseHandle(this->m_diskHandle);
+
+                return false;
+            }
+
+
+
+        #else
+            struct stat driveStat;
+
+            ::stat(this->m_path.data(), &driveStat) == 0;
+            this->m_diskSize = driveStat.st_size;
+            this->m_sectorSize = 0;
+
+            this->m_diskHandle = ::open(this->m_path.data(), O_RDWR);
+            if (this->m_diskHandle == -1) {
+                this->m_diskHandle = ::open(this->m_path.data(), O_RDONLY);
+                this->m_writable = false;
+            }
+
+            if (this->m_diskHandle == -1) {
+                this->m_readable = false;
+                return false;
+            }
+
+        #endif
+
+        return true;
+    }
+
+    void DiskProvider::close() {
+        #if defined (OS_WINDOWS)
+            if (this->m_diskHandle != INVALID_HANDLE_VALUE)
+                ::CloseHandle(this->m_diskHandle);
+
+            this->m_diskHandle = INVALID_HANDLE_VALUE;
+        #else
+            if (this->m_diskHandle != -1)
+                ::close(this->m_diskHandle);
+
+            this->m_diskHandle = -1;
+        #endif
+    }
+
+    void DiskProvider::readRaw(u64 offset, void *buffer, size_t size) {
+        #if defined (OS_WINDOWS)
+            DWORD bytesRead = 0;
+
+            u64 startOffset = offset;
+
+            while (size > 0) {
+                LARGE_INTEGER seekPosition;
+                seekPosition.LowPart = (offset & 0xFFFF'FFFF) - (offset % this->m_sectorSize);
+                seekPosition.HighPart = offset >> 32;
+
+                if (this->m_sectorBufferAddress != seekPosition.QuadPart) {
+                    ::SetFilePointer(this->m_diskHandle, seekPosition.LowPart, &seekPosition.HighPart, FILE_BEGIN);
+                    ::ReadFile(this->m_diskHandle, this->m_sectorBuffer.data(), this->m_sectorBuffer.size(), &bytesRead, nullptr);
+                    this->m_sectorBufferAddress = seekPosition.QuadPart;
+                }
+
+                std::memcpy(reinterpret_cast<u8*>(buffer) + (offset - startOffset), this->m_sectorBuffer.data() + (offset & (this->m_sectorSize - 1)), std::min(this->m_sectorSize, size));
+
+                size = std::max<ssize_t>(static_cast<ssize_t>(size) - this->m_sectorSize, 0);
+                offset += this->m_sectorSize;
+            }
+        #else
+            u64 startOffset = offset;
+
+            while (size > 0) {
+                u64 seekPosition = offset - (offset % this->m_sectorSize);
+
+                if (this->m_sectorBufferAddress != seekPosition) {
+                    ::lseek(this->m_diskHandle, seekPosition, SEEK_SET);
+                    ::read(this->m_diskHandle, buffer, size);
+                    this->m_sectorBufferAddress = seekPosition;
+                }
+
+                std::memcpy(reinterpret_cast<u8*>(buffer) + (offset - startOffset), this->m_sectorBuffer.data() + (offset & (this->m_sectorSize - 1)), std::min(this->m_sectorSize, size));
+
+                size = std::max<ssize_t>(static_cast<ssize_t>(size) - this->m_sectorSize, 0);
+                offset += this->m_sectorSize;
+            }
+        #endif
+    }
+
+    void DiskProvider::writeRaw(u64 offset, const void *buffer, size_t size) {
+        #if defined (OS_WINDOWS)
+            DWORD bytesWritten = 0;
+
+            u64 startOffset = offset;
+
+            std::vector<u8> modifiedSectorBuffer;
+            modifiedSectorBuffer.resize(this->m_sectorSize);
+
+            while (size > 0) {
+                u64 sectorBase = offset - (offset % this->m_sectorSize);
+                size_t currSize = std::min(size, this->m_sectorSize);
+
+                this->readRaw(sectorBase, modifiedSectorBuffer.data(), modifiedSectorBuffer.size());
+                std::memcpy(modifiedSectorBuffer.data() + ((offset - sectorBase) % this->m_sectorSize), reinterpret_cast<const u8*>(buffer) + (startOffset - offset), currSize);
+
+                LARGE_INTEGER seekPosition;
+                seekPosition.LowPart = (offset & 0xFFFF'FFFF) - (offset % this->m_sectorSize);
+                seekPosition.HighPart = offset >> 32;
+
+                ::SetFilePointer(this->m_diskHandle, seekPosition.LowPart, &seekPosition.HighPart, FILE_BEGIN);
+                ::WriteFile(this->m_diskHandle, modifiedSectorBuffer.data(), modifiedSectorBuffer.size(), &bytesWritten, nullptr);
+
+                offset += currSize;
+                size -= currSize;
+            }
+
+        #else
+
+            u64 startOffset = offset;
+
+            std::vector<u8> modifiedSectorBuffer;
+            modifiedSectorBuffer.resize(this->m_sectorSize);
+
+            while (size > 0) {
+                u64 sectorBase = offset - (offset % this->m_sectorSize);
+                size_t currSize = std::min(size, this->m_sectorSize);
+
+                this->readRaw(sectorBase, modifiedSectorBuffer.data(), modifiedSectorBuffer.size());
+                std::memcpy(modifiedSectorBuffer.data() + ((offset - sectorBase) % this->m_sectorSize), reinterpret_cast<const u8*>(buffer) + (startOffset - offset), currSize);
+
+                ::lseek(this->m_diskHandle, sectorBase, SEEK_SET);
+                ::write(this->m_diskHandle, modifiedSectorBuffer.data(), modifiedSectorBuffer.size());
+
+                offset += currSize;
+                size -= currSize;
+            }
+
+        #endif
+    }
+
+    size_t DiskProvider::getActualSize() const {
+        return this->m_diskSize;
+    }
+
+    std::string DiskProvider::getName() const {
+        return this->m_path;
+    }
+
+    std::vector<std::pair<std::string, std::string>> DiskProvider::getDataInformation() const {
+        return {
+                { "hex.builtin.provider.disk.selected_disk"_lang, this->m_path },
+                { "hex.builtin.provider.disk.disk_size"_lang, hex::toByteString(this->m_diskSize) },
+                { "hex.builtin.provider.disk.sector_size"_lang, hex::toByteString(this->m_sectorSize) }
+        };
+    }
+
+
+    void DiskProvider::reloadDrives() {
+        #if defined (OS_WINDOWS)
+            this->m_availableDrives.clear();
+            std::bitset<32> drives = ::GetLogicalDrives();
+            for (char i = 0; i < 26; i++) {
+                if (drives[i])
+                    this->m_availableDrives.insert(hex::format(R"(\\.\{:c}:)", 'A' + i));
+            }
+
+            auto logicalDrives = this->m_availableDrives;
+            for (const auto &drive : logicalDrives) {
+                auto handle = reinterpret_cast<HANDLE>(::CreateFile(drive.data(), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, 0, nullptr));
+
+                if (handle == INVALID_HANDLE_VALUE) continue;
+
+                VOLUME_DISK_EXTENTS diskExtents = { 0 };
+                DWORD bytesRead = 0;
+                auto result = ::DeviceIoControl(
+                        handle,
+                        IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
+                        nullptr,
+                        0,
+                        &diskExtents,
+                        sizeof(VOLUME_DISK_EXTENTS),
+                        &bytesRead,
+                        nullptr);
+
+                if (result) {
+                    auto diskPath = hex::format(R"(\\.\PhysicalDrive{})", diskExtents.Extents[0].DiskNumber);
+                    this->m_availableDrives.insert(diskPath);
+                }
+
+                ::CloseHandle(handle);
+            }
+        #endif
+    }
+
+    void DiskProvider::drawLoadInterface() {
+        #if defined (OS_WINDOWS)
+            if (ImGui::BeginListBox("hex.builtin.provider.disk.selected_disk"_lang)) {
+
+                for (const auto &drive : this->m_availableDrives) {
+                    if (ImGui::Selectable(drive.c_str(), this->m_path == drive))
+                        this->m_path = drive;
+                }
+
+                ImGui::EndListBox();
+            }
+
+            ImGui::SameLine();
+
+            if (ImGui::Button("hex.builtin.provider.disk.reload"_lang)) {
+                this->reloadDrives();
+            }
+
+        #else
+
+            ImGui::InputText("hex.builtin.provider.disk.selected_disk"_lang, this->m_path.data(), this->m_path.capacity(), ImGuiInputTextFlags_CallbackResize, ImGui::UpdateStringSizeCallback, &this->m_path);
+
+        #endif
+    }
+
+}

plugins/builtin/source/content/providers/file_provider.cpp

@@ -1,16 +1,16 @@
-#include "providers/file_provider.hpp"
+#include "content/providers/file_provider.hpp"
 
 #include <ctime>
 #include <cstring>
 
 #include <hex/helpers/utils.hpp>
 #include <hex/helpers/file.hpp>
-#include "helpers/project_file_handler.hpp"
+#include <hex/helpers/project_file_handler.hpp>
 
-namespace hex::prv {
+namespace hex::plugin::builtin::prv {
+
+    FileProvider::FileProvider() : Provider() {
 
-    FileProvider::FileProvider(std::string path) : Provider(), m_path(std::move(path)) {
-        this->open();
     }
 
     FileProvider::~FileProvider() {
@@ -20,7 +20,7 @@ namespace hex::prv {
 
     bool FileProvider::isAvailable() const {
         #if defined(OS_WINDOWS)
-        return this->m_file != nullptr && this->m_mapping != nullptr && this->m_mappedFile != nullptr;
+        return this->m_file != INVALID_HANDLE_VALUE && this->m_mapping != INVALID_HANDLE_VALUE && this->m_mappedFile != nullptr;
         #else
         return this->m_file != -1 && this->m_mappedFile != nullptr;
         #endif
@@ -44,11 +44,10 @@ namespace hex::prv {
 
 
     void FileProvider::read(u64 offset, void *buffer, size_t size, bool overlays) {
-
-        if ((offset - this->getBaseAddress()) > (this->getSize() - size) || buffer == nullptr || size == 0)
+        if ((offset - this->getBaseAddress()) > (this->getActualSize() - size) || buffer == nullptr || size == 0)
             return;
 
-        std::memcpy(buffer, reinterpret_cast<u8*>(this->m_mappedFile) + PageSize * this->m_currPage + offset - this->getBaseAddress(), size);
+        this->readRaw(offset - this->getBaseAddress(), buffer, size);
 
         for (u64 i = 0; i < size; i++)
             if (getPatches().contains(offset + i))
@@ -59,25 +58,21 @@ namespace hex::prv {
     }
 
     void FileProvider::write(u64 offset, const void *buffer, size_t size) {
-        if (((offset - this->getBaseAddress()) + size) > this->getSize() || buffer == nullptr || size == 0)
+        if ((offset - this->getBaseAddress()) > (this->getActualSize() - size) || buffer == nullptr || size == 0)
             return;
 
         addPatch(offset, buffer, size);
     }
 
     void FileProvider::readRaw(u64 offset, void *buffer, size_t size) {
-        offset -= this->getBaseAddress();
-
-        if ((offset + size) > this->getSize() || buffer == nullptr || size == 0)
+        if ((offset + size) > this->getActualSize() || buffer == nullptr || size == 0)
             return;
 
         std::memcpy(buffer, reinterpret_cast<u8*>(this->m_mappedFile) + PageSize * this->m_currPage + offset, size);
     }
 
     void FileProvider::writeRaw(u64 offset, const void *buffer, size_t size) {
-        offset -= this->getBaseAddress();
-
-        if ((offset + size) > this->getSize() || buffer == nullptr || size == 0)
+        if ((offset + size) > this->getActualSize() || buffer == nullptr || size == 0)
             return;
 
         std::memcpy(reinterpret_cast<u8*>(this->m_mappedFile) + PageSize * this->m_currPage + offset, buffer, size);
@@ -100,7 +95,7 @@ namespace hex::prv {
                 if (bufferSize > provider->getActualSize() - offset)
                     bufferSize = provider->getActualSize() - offset;
 
-                provider->readRelative(offset, buffer.data(), bufferSize);
+                provider->read(offset + this->getBaseAddress(), buffer.data(), bufferSize);
                 file.write(buffer);
             }
         }
@@ -161,7 +156,11 @@ namespace hex::prv {
         return result;
     }
 
-    void FileProvider::open() {
+    void FileProvider::setPath(const std::string &path) {
+        this->m_path = path;
+    }
+
+    bool FileProvider::open() {
         this->m_fileStatsValid = stat(this->m_path.data(), &this->m_fileStats) == 0;
 
         this->m_readable = true;
@@ -198,33 +197,41 @@ namespace hex::prv {
         };
 
         if (this->m_file == nullptr || this->m_file == INVALID_HANDLE_VALUE) {
-            return;
+            return false;
         }
 
-        this->m_mapping = CreateFileMapping(this->m_file, nullptr, PAGE_READWRITE, fileSize.HighPart, fileSize.LowPart, nullptr);
-        if (this->m_mapping == nullptr || this->m_mapping == INVALID_HANDLE_VALUE) {
-            return;
-        }
+        if (this->m_fileSize > 0) {
+            this->m_mapping = CreateFileMapping(this->m_file, nullptr, PAGE_READWRITE, fileSize.HighPart, fileSize.LowPart, nullptr);
+            if (this->m_mapping == nullptr || this->m_mapping == INVALID_HANDLE_VALUE) {
+                return false;
+            }
 
-        auto mappingCleanup = SCOPE_GUARD {
-            this->m_readable = false;
-            this->m_mapping = nullptr;
-            CloseHandle(this->m_mapping);
-        };
+            auto mappingCleanup = SCOPE_GUARD {
+                this->m_readable = false;
+                this->m_mapping = nullptr;
+                CloseHandle(this->m_mapping);
+            };
 
-        this->m_mappedFile = MapViewOfFile(this->m_mapping, FILE_MAP_ALL_ACCESS, 0, 0, this->m_fileSize);
-        if (this->m_mappedFile == nullptr) {
-            this->m_readable = false;
-            return;
+            this->m_mappedFile = MapViewOfFile(this->m_mapping, FILE_MAP_ALL_ACCESS, 0, 0, this->m_fileSize);
+            if (this->m_mappedFile == nullptr) {
+                this->m_readable = false;
+                return false;
+            }
+
+            mappingCleanup.release();
+
+            ProjectFile::setFilePath(this->m_path);
+        } else if (!this->m_emptyFile) {
+            this->m_emptyFile = true;
+            this->resize(1);
+        } else {
+            return false;
         }
 
         fileCleanup.release();
-        mappingCleanup.release();
-
-        ProjectFile::setFilePath(this->m_path);
 
         #else
-        this->m_file = ::open(this->m_path.data(), O_RDWR);
+            this->m_file = ::open(this->m_path.data(), O_RDWR);
             if (this->m_file == -1) {
                 this->m_file = ::open(this->m_path.data(), O_RDONLY);
                 this->m_writable = false;
@@ -232,14 +239,21 @@ namespace hex::prv {
 
             if (this->m_file == -1) {
                 this->m_readable = false;
-                return;
+                return false;
             }
 
             this->m_fileSize = this->m_fileStats.st_size;
 
-            this->m_mappedFile = mmap(nullptr, this->m_fileSize, PROT_READ | PROT_WRITE, MAP_PRIVATE, this->m_file, 0);
+            this->m_mappedFile = ::mmap(nullptr, this->m_fileSize, PROT_READ | PROT_WRITE, MAP_PRIVATE, this->m_file, 0);
+            if (this->m_mappedFile == nullptr) {
+                ::close(this->m_file);
+                this->m_file = -1;
 
-    #endif
+                return false;
+            }
+        #endif
+
+        return true;
     }
 
     void FileProvider::close() {

plugins/builtin/source/content/providers/gdb_provider.cpp

@@ -0,0 +1,312 @@
+#include "content/providers/gdb_provider.hpp"
+
+#include <cstring>
+#include <thread>
+#include <chrono>
+
+#include <hex/helpers/fmt.hpp>
+#include <hex/helpers/crypto.hpp>
+
+namespace hex::plugin::builtin::prv {
+
+    using namespace std::chrono_literals;
+
+    namespace gdb {
+
+        namespace {
+
+            u8 calculateChecksum(const std::string &data) {
+                u64 checksum = 0;
+
+                for (const auto &c : data)
+                    checksum += c;
+
+                return checksum & 0xFF;
+            }
+
+            std::string createPacket(const std::string &data) {
+                return hex::format("${}#{:02x}", data, calculateChecksum(data));
+            }
+
+            std::optional<std::string> parsePacket(const std::string &packet) {
+                if (packet.length() < 4)
+                    return std::nullopt;
+
+                if (!packet.starts_with('$'))
+                    return std::nullopt;
+
+                if (packet[packet.length() - 3] != '#')
+                    return std::nullopt;
+
+                std::string data = packet.substr(1, packet.length() - 4);
+                std::string checksum = packet.substr(packet.length() - 2, 2);
+
+                if (checksum.length() != 2 || crypt::decode16(checksum)[0] != calculateChecksum(data))
+                    return std::nullopt;
+
+                return data;
+            }
+
+        }
+
+        void sendAck(Socket &socket) {
+            socket.writeString("+");
+        }
+
+        std::vector<u8> readMemory(Socket &socket, u64 address, size_t size) {
+            std::string packet = createPacket(hex::format("m{:X},{:X}", address, size));
+
+            socket.writeString(packet);
+
+            auto receivedPacket = socket.readString(size * 2 + 4);
+
+            if (receivedPacket.empty())
+                return { };
+
+            auto receivedData = parsePacket(receivedPacket);
+            if (!receivedData.has_value())
+                return { };
+
+            if (receivedData->size() == 3 && receivedData->starts_with("E"))
+                return { };
+
+            auto data = crypt::decode16(receivedData.value());
+
+            data.resize(size);
+
+            return data;
+        }
+
+        void writeMemory(Socket &socket, u64 address, const void *buffer, size_t size) {
+            std::vector<u8> bytes(size);
+            std::memcpy(bytes.data(), buffer, size);
+
+            std::string byteString = crypt::encode16(bytes);
+
+            std::string packet = createPacket(hex::format("M{:X},{:X}:{}", address, size, byteString));
+
+            socket.writeString(packet);
+
+            auto receivedPacket = socket.readString(3);
+        }
+
+        bool enableNoAckMode(Socket &socket) {
+            socket.writeString(createPacket("QStartNoAckMode"));
+
+            auto ack = socket.readString(1);
+
+            if (ack.empty() || ack[0] != '+')
+                return {};
+
+            auto receivedPacket = socket.readString(6);
+
+            auto receivedData = parsePacket(receivedPacket);
+
+            if (receivedData && *receivedData == "OK") {
+                sendAck(socket);
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+    }
+
+    GDBProvider::GDBProvider() : Provider() {
+
+    }
+
+    GDBProvider::~GDBProvider() {
+        this->close();
+    }
+
+
+    bool GDBProvider::isAvailable() const {
+        return this->m_socket.isConnected();
+    }
+
+    bool GDBProvider::isReadable() const {
+        return this->m_socket.isConnected();
+    }
+
+    bool GDBProvider::isWritable() const {
+        return false;
+    }
+
+    bool GDBProvider::isResizable() const {
+        return false;
+    }
+
+    bool GDBProvider::isSavable() const {
+        return false;
+    }
+
+
+    void GDBProvider::read(u64 offset, void *buffer, size_t size, bool overlays) {
+        if ((offset - this->getBaseAddress()) > (this->getActualSize() - size) || buffer == nullptr || size == 0)
+            return;
+
+        offset -= this->getBaseAddress();
+
+        u64 alignedOffset = offset - (offset % CacheLineSize);
+
+        if (size <= CacheLineSize) {
+            std::scoped_lock lock(this->m_cacheLock);
+
+            const auto &cacheLine = std::find_if(this->m_cache.begin(), this->m_cache.end(), [&](auto &line){
+                return line.address == alignedOffset;
+            });
+
+            if (cacheLine != this->m_cache.end()) {
+                // Cache hit
+
+            } else {
+                // Cache miss
+
+                this->m_cache.push_back({ alignedOffset, { 0 } });
+            }
+
+            if (cacheLine != this->m_cache.end())
+                std::memcpy(buffer, &cacheLine->data[0] + (offset % CacheLineSize), size);
+        } else {
+            while (size > 0) {
+                size_t readSize = std::min(size, CacheLineSize);
+                this->readRaw(offset, buffer, readSize);
+
+                size -= readSize;
+                offset += readSize;
+            }
+        }
+
+        for (u64 i = 0; i < size; i++)
+            if (getPatches().contains(offset + i))
+                reinterpret_cast<u8*>(buffer)[i] = getPatches()[offset + PageSize * this->m_currPage + i];
+
+        if (overlays)
+            this->applyOverlays(offset, buffer, size);
+    }
+
+    void GDBProvider::write(u64 offset, const void *buffer, size_t size) {
+        if ((offset - this->getBaseAddress()) > (this->getActualSize() - size) || buffer == nullptr || size == 0)
+            return;
+
+        offset -= this->getBaseAddress();
+
+        gdb::writeMemory(this->m_socket, offset, buffer, size);
+    }
+
+    void GDBProvider::readRaw(u64 offset, void *buffer, size_t size) {
+        if ((offset - this->getBaseAddress()) > (this->getActualSize() - size) || buffer == nullptr || size == 0)
+            return;
+
+        auto data = gdb::readMemory(this->m_socket, offset, size);
+        std::memcpy(buffer, &data[0], data.size());
+    }
+
+    void GDBProvider::writeRaw(u64 offset, const void *buffer, size_t size) {
+        if ((offset - this->getBaseAddress()) > (this->getActualSize() - size) || buffer == nullptr || size == 0)
+            return;
+
+        gdb::writeMemory(this->m_socket, offset, buffer, size);
+    }
+
+    void GDBProvider::save() {
+        this->applyPatches();
+    }
+
+    void GDBProvider::saveAs(const std::string &path) {
+
+    }
+
+    void GDBProvider::resize(ssize_t newSize) {
+
+    }
+
+    size_t GDBProvider::getActualSize() const {
+        return 0xFFFF'FFFF;
+    }
+
+    std::string GDBProvider::getName() const {
+        std::string address, port;
+
+        if (!this->isConnected()) {
+            address = "-";
+            port = "-";
+        } else {
+            address = this->m_ipAddress;
+            port = std::to_string(this->m_port);
+        }
+
+        return hex::format("hex.builtin.provider.gdb.name"_lang, address, port);
+    }
+
+    std::vector<std::pair<std::string, std::string>> GDBProvider::getDataInformation() const {
+        return {
+                { "hex.builtin.provider.gdb.server"_lang, hex::format("{}:{}", this->m_ipAddress, this->m_port) },
+        };
+    }
+
+    bool GDBProvider::open() {
+        this->m_socket.connect(this->m_ipAddress, this->m_port);
+        if (!gdb::enableNoAckMode(this->m_socket)) {
+            this->m_socket.disconnect();
+            return false;
+        }
+
+        if (this->m_socket.isConnected()) {
+            this->m_cacheUpdateThread = std::thread([this]() {
+                auto cacheLine = this->m_cache.begin();
+                while (this->isConnected()) {
+                    {
+                        std::scoped_lock lock(this->m_cacheLock);
+
+                        if (cacheLine != this->m_cache.end()) {
+                            auto data = gdb::readMemory(this->m_socket, cacheLine->address, 0x1000);
+
+                            while (this->m_cache.size() > 10) {
+                                this->m_cache.pop_front();
+                                cacheLine = this->m_cache.begin();
+                            }
+
+                            std::memcpy(cacheLine->data.data(), data.data(), data.size());
+                        }
+
+                        cacheLine++;
+                        if (cacheLine == this->m_cache.end())
+                            cacheLine = this->m_cache.begin();
+                    }
+                    std::this_thread::sleep_for(100ms);
+                }
+            });
+
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    void GDBProvider::close() {
+        this->m_socket.disconnect();
+
+        if (this->m_cacheUpdateThread.joinable()) {
+            this->m_cacheUpdateThread.join();
+        }
+    }
+
+    bool GDBProvider::isConnected() const {
+        return this->m_socket.isConnected();
+    }
+
+
+
+    void GDBProvider::drawLoadInterface() {
+        ImGui::InputText("hex.builtin.provider.gdb.ip"_lang, this->m_ipAddress.data(), this->m_ipAddress.capacity(), ImGuiInputTextFlags_CallbackEdit, ImGui::UpdateStringSizeCallback, &this->m_ipAddress);
+        ImGui::InputInt("hex.builtin.provider.gdb.port"_lang, &this->m_port, 0, 0);
+
+        if (this->m_port < 0)
+            this->m_port = 0;
+        else if (this->m_port > 0xFFFF)
+            this->m_port = 0xFFFF;
+    }
+
+}

plugins/builtin/source/content/tools_entries.cpp

@@ -30,13 +30,6 @@ namespace hex::plugin::builtin {
         using namespace std::literals::chrono_literals;
         using namespace hex::literals;
 
-        int updateStringSizeCallback(ImGuiInputTextCallbackData *data) {
-            auto &mathInput = *static_cast<std::string*>(data->UserData);
-
-            mathInput.resize(data->BufTextLen);
-            return 0;
-        }
-
         void drawDemangler() {
             static std::vector<char> mangledBuffer(0xF'FFFF, 0x00);
             static std::string demangledName;
@@ -108,9 +101,9 @@ namespace hex::plugin::builtin {
             static auto replacePattern = []{ std::string s; s.reserve(0xFFF); return s; }();
             static auto regexOutput = []{ std::string s; s.reserve(0xFFF); return s; }();
 
-            bool changed1 = ImGui::InputText("hex.builtin.tools.regex_replacer.pattern"_lang, regexPattern.data(), regexPattern.capacity(), ImGuiInputTextFlags_CallbackEdit, updateStringSizeCallback, &regexPattern);
-            bool changed2 = ImGui::InputText("hex.builtin.tools.regex_replacer.replace"_lang, replacePattern.data(), replacePattern.capacity(), ImGuiInputTextFlags_CallbackEdit, updateStringSizeCallback, &replacePattern);
-            bool changed3 = ImGui::InputTextMultiline("hex.builtin.tools.regex_replacer.input"_lang, regexInput.data(), regexInput.capacity(), ImVec2(0, 0), ImGuiInputTextFlags_CallbackEdit, updateStringSizeCallback, &regexInput);
+            bool changed1 = ImGui::InputText("hex.builtin.tools.regex_replacer.pattern"_lang, regexPattern.data(), regexPattern.capacity(), ImGuiInputTextFlags_CallbackEdit, ImGui::UpdateStringSizeCallback, &regexPattern);
+            bool changed2 = ImGui::InputText("hex.builtin.tools.regex_replacer.replace"_lang, replacePattern.data(), replacePattern.capacity(), ImGuiInputTextFlags_CallbackEdit, ImGui::UpdateStringSizeCallback, &replacePattern);
+            bool changed3 = ImGui::InputTextMultiline("hex.builtin.tools.regex_replacer.input"_lang, regexInput.data(), regexInput.capacity(), ImVec2(0, 0), ImGuiInputTextFlags_CallbackEdit, ImGui::UpdateStringSizeCallback, &regexInput);
 
             if (changed1 || changed2 || changed3) {
                 try {
@@ -363,7 +356,7 @@ namespace hex::plugin::builtin {
             }
 
             ImGui::PushItemWidth(ImGui::GetContentRegionAvailWidth());
-            if (ImGui::InputText("##input", mathInput.data(), mathInput.capacity(), ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_CallbackEdit, updateStringSizeCallback, &mathInput)) {
+            if (ImGui::InputText("##input", mathInput.data(), mathInput.capacity(), ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_CallbackEdit, ImGui::UpdateStringSizeCallback, &mathInput)) {
                 ImGui::SetKeyboardFocusHere();
                 evaluate = true;
             }
@@ -619,7 +612,7 @@ namespace hex::plugin::builtin {
 
         bool startSearch;
 
-        startSearch = ImGui::InputText("##search", searchString.data(), searchString.capacity(), ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_CallbackEdit, updateStringSizeCallback, &searchString);
+        startSearch = ImGui::InputText("##search", searchString.data(), searchString.capacity(), ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_CallbackEdit, ImGui::UpdateStringSizeCallback, &searchString);
         ImGui::SameLine();
 
         ImGui::BeginDisabled(searchProcess.valid() && searchProcess.wait_for(0s) != std::future_status::ready || searchString.empty());
@@ -685,7 +678,7 @@ namespace hex::plugin::builtin {
             {
                 ImGui::TextUnformatted("hex.builtin.tools.file_tools.shredder.input"_lang);
                 ImGui::SameLine();
-                ImGui::InputText("##path", selectedFile.data(), selectedFile.capacity(), ImGuiInputTextFlags_CallbackEdit, updateStringSizeCallback, &selectedFile);
+                ImGui::InputText("##path", selectedFile.data(), selectedFile.capacity(), ImGuiInputTextFlags_CallbackEdit, ImGui::UpdateStringSizeCallback, &selectedFile);
                 ImGui::SameLine();
                 if (ImGui::Button("...")) {
                     hex::openFileBrowser("hex.builtin.tools.file_tools.shredder.picker"_lang, DialogMode::Open, {}, [](const std::string &path) {
@@ -800,7 +793,7 @@ namespace hex::plugin::builtin {
             {
                 ImGui::TextUnformatted("hex.builtin.tools.file_tools.splitter.input"_lang);
                 ImGui::SameLine();
-                ImGui::InputText("##path", selectedFile.data(), selectedFile.capacity(), ImGuiInputTextFlags_CallbackEdit, updateStringSizeCallback, &selectedFile);
+                ImGui::InputText("##path", selectedFile.data(), selectedFile.capacity(), ImGuiInputTextFlags_CallbackEdit, ImGui::UpdateStringSizeCallback, &selectedFile);
                 ImGui::SameLine();
                 if (ImGui::Button("...##input")) {
                     hex::openFileBrowser("hex.builtin.tools.file_tools.splitter.picker.input"_lang, DialogMode::Open, {}, [](const std::string &path) {
@@ -810,7 +803,7 @@ namespace hex::plugin::builtin {
 
                 ImGui::TextUnformatted("hex.builtin.tools.file_tools.splitter.output"_lang);
                 ImGui::SameLine();
-                ImGui::InputText("##base_path", baseOutputPath.data(), baseOutputPath.capacity(), ImGuiInputTextFlags_CallbackEdit, updateStringSizeCallback, &baseOutputPath);
+                ImGui::InputText("##base_path", baseOutputPath.data(), baseOutputPath.capacity(), ImGuiInputTextFlags_CallbackEdit, ImGui::UpdateStringSizeCallback, &baseOutputPath);
                 ImGui::SameLine();
                 if (ImGui::Button("...##output")) {
                     hex::openFileBrowser("hex.builtin.tools.file_tools.splitter.picker.output"_lang, DialogMode::Save, {}, [](const std::string &path) {
@@ -957,7 +950,7 @@ namespace hex::plugin::builtin {
         {
             ImGui::TextUnformatted("hex.builtin.tools.file_tools.combiner.output"_lang);
             ImGui::SameLine();
-            ImGui::InputText("##output_path", outputPath.data(), outputPath.capacity(), ImGuiInputTextFlags_CallbackEdit, updateStringSizeCallback, &outputPath);
+            ImGui::InputText("##output_path", outputPath.data(), outputPath.capacity(), ImGuiInputTextFlags_CallbackEdit, ImGui::UpdateStringSizeCallback, &outputPath);
             ImGui::SameLine();
             if (ImGui::Button("...")) {
                 hex::openFileBrowser("hex.builtin.tools.file_tools.combiner.output.picker"_lang, DialogMode::Save, {}, [](const std::string &path) {

plugins/builtin/source/content/ui_items.cpp

@@ -13,6 +13,12 @@ namespace hex::plugin::builtin {
 
     void addFooterItems() {
 
+        if (hex::isProcessElevated()) {
+            ContentRegistry::Interface::addFooterItem([] {
+                ImGui::TextUnformatted(ICON_VS_SHIELD);
+            });
+        }
+
         ContentRegistry::Interface::addFooterItem([] {
             static float framerate = 0;
             if (ImGui::HasSecondPassed()) {
@@ -63,7 +69,7 @@ namespace hex::plugin::builtin {
             // Save file as
             ImGui::Disabled([&provider] {
                 if (ImGui::ToolBarButton(ICON_VS_SAVE_AS, ImGui::GetCustomColorVec4(ImGuiCustomCol_ToolbarBlue)))
-                    hex::openFileBrowser("hex.view.hexeditor.save_as"_lang, DialogMode::Save, { }, [&provider](auto path) {
+                    hex::openFileBrowser("hex.builtin.view.hexeditor.save_as"_lang, DialogMode::Save, { }, [&provider](auto path) {
                         provider->saveAs(path);
                     });
             }, !ImHexApi::Provider::isValid() || !provider->isSavable());

plugins/builtin/source/content/views.cpp

@@ -0,0 +1,47 @@
+#include "content/views/view_hexeditor.hpp"
+#include "content/views/view_pattern_editor.hpp"
+#include "content/views/view_pattern_data.hpp"
+#include "content/views/view_hashes.hpp"
+#include "content/views/view_information.hpp"
+#include "content/views/view_help.hpp"
+#include "content/views/view_tools.hpp"
+#include "content/views/view_strings.hpp"
+#include "content/views/view_data_inspector.hpp"
+#include "content/views/view_disassembler.hpp"
+#include "content/views/view_bookmarks.hpp"
+#include "content/views/view_patches.hpp"
+#include "content/views/view_command_palette.hpp"
+#include "content/views/view_settings.hpp"
+#include "content/views/view_data_processor.hpp"
+#include "content/views/view_yara.hpp"
+#include "content/views/view_constants.hpp"
+#include "content/views/view_store.hpp"
+#include "content/views/view_diff.hpp"
+#include "content/views/view_provider_settings.hpp"
+
+namespace hex::plugin::builtin {
+
+    void registerViews() {
+        ContentRegistry::Views::add<ViewHexEditor>();
+        ContentRegistry::Views::add<ViewPatternEditor>();
+        ContentRegistry::Views::add<ViewPatternData>();
+        ContentRegistry::Views::add<ViewDataInspector>();
+        ContentRegistry::Views::add<ViewHashes>();
+        ContentRegistry::Views::add<ViewInformation>();
+        ContentRegistry::Views::add<ViewStrings>();
+        ContentRegistry::Views::add<ViewDisassembler>();
+        ContentRegistry::Views::add<ViewBookmarks>();
+        ContentRegistry::Views::add<ViewPatches>();
+        ContentRegistry::Views::add<ViewTools>();
+        ContentRegistry::Views::add<ViewCommandPalette>();
+        ContentRegistry::Views::add<ViewHelp>();
+        ContentRegistry::Views::add<ViewSettings>();
+        ContentRegistry::Views::add<ViewDataProcessor>();
+        ContentRegistry::Views::add<ViewYara>();
+        ContentRegistry::Views::add<ViewConstants>();
+        ContentRegistry::Views::add<ViewStore>();
+        ContentRegistry::Views::add<ViewDiff>();
+        ContentRegistry::Views::add<ViewProviderSettings>();
+    }
+
+}

plugins/builtin/source/content/views/view_bookmarks.cpp

@@ -1,22 +1,22 @@
-#include "views/view_bookmarks.hpp"
+#include "content/views/view_bookmarks.hpp"
 
 #include <hex/providers/provider.hpp>
 #include <hex/helpers/fmt.hpp>
 
-#include "helpers/project_file_handler.hpp"
+#include <hex/helpers/project_file_handler.hpp>
 
 #include <cstring>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
-    ViewBookmarks::ViewBookmarks() : View("hex.view.bookmarks.name") {
+    ViewBookmarks::ViewBookmarks() : View("hex.builtin.view.bookmarks.name") {
         EventManager::subscribe<RequestAddBookmark>(this, [](ImHexApi::Bookmarks::Entry bookmark) {
             bookmark.comment.resize(0xF'FFFF);
 
             if (bookmark.name.empty()) {
                 bookmark.name.resize(64);
                 std::memset(bookmark.name.data(), 0x00, 64);
-                std::strcpy(bookmark.name.data(), hex::format("hex.view.bookmarks.default_title"_lang,
+                std::strcpy(bookmark.name.data(), hex::format("hex.builtin.view.bookmarks.default_title"_lang,
                                                               bookmark.region.address,
                                                               bookmark.region.address + bookmark.region.size - 1).c_str());
             }
@@ -37,22 +37,27 @@ namespace hex {
         EventManager::subscribe<EventProjectFileStore>(this, []{
             ProjectFile::setBookmarks(SharedData::bookmarkEntries);
         });
+
+        EventManager::subscribe<EventFileUnloaded>(this, []{
+            ImHexApi::Bookmarks::getEntries().clear();
+        });
     }
 
     ViewBookmarks::~ViewBookmarks() {
         EventManager::unsubscribe<RequestAddBookmark>(this);
         EventManager::unsubscribe<EventProjectFileLoad>(this);
         EventManager::unsubscribe<EventProjectFileStore>(this);
+        EventManager::unsubscribe<EventFileUnloaded>(this);
     }
 
     void ViewBookmarks::drawContent() {
-        if (ImGui::Begin(View::toWindowName("hex.view.bookmarks.name").c_str(), &this->getWindowOpenState())) {
+        if (ImGui::Begin(View::toWindowName("hex.builtin.view.bookmarks.name").c_str(), &this->getWindowOpenState())) {
             if (ImGui::BeginChild("##scrolling")) {
 
                 auto &bookmarks = ImHexApi::Bookmarks::getEntries();
 
                 if (bookmarks.empty()) {
-                    std::string text = "hex.view.bookmarks.no_bookmarks"_lang;
+                    std::string text = "hex.builtin.view.bookmarks.no_bookmarks"_lang;
                     auto textSize = ImGui::CalcTextSize(text.c_str());
                     auto availableSpace = ImGui::GetContentRegionAvail();
 
@@ -74,9 +79,9 @@ namespace hex {
                     ImGui::PushStyleColor(ImGuiCol_HeaderActive, color);
                     ImGui::PushStyleColor(ImGuiCol_HeaderHovered, u32(hoverColor));
                     if (ImGui::CollapsingHeader((std::string(name.data()) + "###bookmark").c_str())) {
-                        ImGui::TextUnformatted("hex.view.bookmarks.title.info"_lang);
+                        ImGui::TextUnformatted("hex.builtin.view.bookmarks.title.info"_lang);
                         ImGui::Separator();
-                        ImGui::TextUnformatted(hex::format("hex.view.bookmarks.address"_lang, region.address, region.address + region.size - 1, region.size).c_str());
+                        ImGui::TextUnformatted(hex::format("hex.builtin.view.bookmarks.address"_lang, region.address, region.address + region.size - 1, region.size).c_str());
 
                         if (ImGui::BeginChild("hexData", ImVec2(0, ImGui::GetTextLineHeight() * 8), true)) {
                             size_t offset = region.address % 0x10;
@@ -123,11 +128,11 @@ namespace hex {
                         }
                         ImGui::EndChild();
 
-                        if (ImGui::Button("hex.view.bookmarks.button.jump"_lang))
+                        if (ImGui::Button("hex.builtin.view.bookmarks.button.jump"_lang))
                             EventManager::post<RequestSelectionChange>(region);
                         ImGui::SameLine(0, 15);
 
-                        if (ImGui::Button("hex.view.bookmarks.button.remove"_lang))
+                        if (ImGui::Button("hex.builtin.view.bookmarks.button.remove"_lang))
                             bookmarkToRemove = iter;
                         ImGui::SameLine(0, 15);
 
@@ -138,10 +143,10 @@ namespace hex {
                         }
 
                         ImGui::NewLine();
-                        ImGui::TextUnformatted("hex.view.bookmarks.header.name"_lang);
+                        ImGui::TextUnformatted("hex.builtin.view.bookmarks.header.name"_lang);
                         ImGui::Separator();
 
-                        ImGui::ColorEdit4("hex.view.bookmarks.header.color"_lang, (float*)&headerColor.Value, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoLabel | ImGuiColorEditFlags_NoAlpha | (locked ? ImGuiColorEditFlags_NoPicker : ImGuiColorEditFlags_None));
+                        ImGui::ColorEdit4("hex.builtin.view.bookmarks.header.color"_lang, (float*)&headerColor.Value, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoLabel | ImGuiColorEditFlags_NoAlpha | (locked ? ImGuiColorEditFlags_NoPicker : ImGuiColorEditFlags_None));
                         color = headerColor;
                         ImGui::SameLine();
 
@@ -151,7 +156,7 @@ namespace hex {
                             ImGui::InputText("##nameInput", name.data(), 64);
 
                         ImGui::NewLine();
-                        ImGui::TextUnformatted("hex.view.bookmarks.header.comment"_lang);
+                        ImGui::TextUnformatted("hex.builtin.view.bookmarks.header.comment"_lang);
                         ImGui::Separator();
 
                         if (locked)

plugins/builtin/source/content/views/view_command_palette.cpp

@@ -1,10 +1,10 @@
-#include "views/view_command_palette.hpp"
+#include "content/views/view_command_palette.hpp"
 
 #include <cstring>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
-    ViewCommandPalette::ViewCommandPalette() : View("hex.view.command_palette.name") {
+    ViewCommandPalette::ViewCommandPalette() : View("hex.builtin.view.command_palette.name") {
         this->m_commandBuffer.resize(1024, 0x00);
     }
 
@@ -17,7 +17,7 @@ namespace hex {
         if (!this->m_commandPaletteOpen) return;
 
         ImGui::SetNextWindowPos(ImVec2(SharedData::windowPos.x + SharedData::windowSize.x * 0.5F, SharedData::windowPos.y), ImGuiCond_Always, ImVec2(0.5F,0.0F));
-        if (ImGui::BeginPopup("hex.view.command_palette.name"_lang)) {
+        if (ImGui::BeginPopup("hex.builtin.view.command_palette.name"_lang)) {
             if (ImGui::IsKeyDown(ImGui::GetKeyIndex(ImGuiKey_Escape)))
                 ImGui::CloseCurrentPopup();
 
@@ -75,7 +75,7 @@ namespace hex {
     bool ViewCommandPalette::handleShortcut(bool keys[512], bool ctrl, bool shift, bool alt) {
         if (ctrl && shift && keys['P']) {
             View::doLater([this] {
-                ImGui::OpenPopup("hex.view.command_palette.name"_lang);
+                ImGui::OpenPopup("hex.builtin.view.command_palette.name"_lang);
                 this->m_commandPaletteOpen = true;
                 this->m_justOpened = true;
             });

plugins/builtin/source/content/views/view_constants.cpp

@@ -1,4 +1,4 @@
-#include "views/view_constants.hpp"
+#include "content/views/view_constants.hpp"
 
 #include <hex/helpers/paths.hpp>
 #include <hex/helpers/logger.hpp>
@@ -8,9 +8,9 @@
 #include <filesystem>
 #include <nlohmann/json.hpp>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
-    ViewConstants::ViewConstants() : View("hex.view.constants.name") {
+    ViewConstants::ViewConstants() : View("hex.builtin.view.constants.name") {
         this->reloadConstants();
 
         this->m_filter.reserve(0xFFFF);
@@ -65,7 +65,7 @@ namespace hex {
     }
 
     void ViewConstants::drawContent() {
-        if (ImGui::Begin(View::toWindowName("hex.view.constants.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
+        if (ImGui::Begin(View::toWindowName("hex.builtin.view.constants.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
 
             ImGui::InputText("##search", this->m_filter.data(), this->m_filter.capacity(), ImGuiInputTextFlags_CallbackEdit, [](ImGuiInputTextCallbackData *data) {
                 auto &view = *static_cast<ViewConstants*>(data->UserData);
@@ -88,10 +88,10 @@ namespace hex {
                                   ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable | ImGuiTableFlags_Sortable |
                                   ImGuiTableFlags_Reorderable | ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY)) {
                 ImGui::TableSetupScrollFreeze(0, 1);
-                ImGui::TableSetupColumn("hex.view.constants.row.category"_lang, 0, -1, ImGui::GetID("category"));
-                ImGui::TableSetupColumn("hex.view.constants.row.name"_lang, 0, -1, ImGui::GetID("name"));
-                ImGui::TableSetupColumn("hex.view.constants.row.desc"_lang, 0, -1, ImGui::GetID("desc"));
-                ImGui::TableSetupColumn("hex.view.constants.row.value"_lang, 0, -1, ImGui::GetID("value"));
+                ImGui::TableSetupColumn("hex.builtin.view.constants.row.category"_lang, 0, -1, ImGui::GetID("category"));
+                ImGui::TableSetupColumn("hex.builtin.view.constants.row.name"_lang, 0, -1, ImGui::GetID("name"));
+                ImGui::TableSetupColumn("hex.builtin.view.constants.row.desc"_lang, 0, -1, ImGui::GetID("desc"));
+                ImGui::TableSetupColumn("hex.builtin.view.constants.row.value"_lang, 0, -1, ImGui::GetID("value"));
 
                 auto sortSpecs = ImGui::TableGetSortSpecs();
 

plugins/builtin/source/content/views/view_data_inspector.cpp

@@ -1,4 +1,4 @@
-#include "views/view_data_inspector.hpp"
+#include "content/views/view_data_inspector.hpp"
 
 #include <hex/providers/provider.hpp>
 
@@ -6,11 +6,11 @@
 
 extern int ImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end);
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     using NumberDisplayStyle = ContentRegistry::DataInspector::NumberDisplayStyle;
 
-    ViewDataInspector::ViewDataInspector() : View("hex.view.data_inspector.name") {
+    ViewDataInspector::ViewDataInspector() : View("hex.builtin.view.data_inspector.name") {
         EventManager::subscribe<EventRegionSelected>(this, [this](Region region) {
             auto provider = ImHexApi::Provider::get();
 
@@ -47,7 +47,7 @@ namespace hex {
         }
 
 
-        if (ImGui::Begin(View::toWindowName("hex.view.data_inspector.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
+        if (ImGui::Begin(View::toWindowName("hex.builtin.view.data_inspector.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
             auto provider = ImHexApi::Provider::get();
 
             if (ImHexApi::Provider::isValid() && provider->isReadable() && this->m_validBytes > 0) {
@@ -55,8 +55,8 @@ namespace hex {
                     ImGuiTableFlags_ScrollY | ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable | ImGuiTableFlags_RowBg,
                     ImVec2(0, ImGui::GetTextLineHeightWithSpacing() * (this->m_cachedData.size() + 1)))) {
                     ImGui::TableSetupScrollFreeze(0, 1);
-                    ImGui::TableSetupColumn("hex.view.data_inspector.table.name"_lang);
-                    ImGui::TableSetupColumn("hex.view.data_inspector.table.value"_lang);
+                    ImGui::TableSetupColumn("hex.builtin.view.data_inspector.table.name"_lang);
+                    ImGui::TableSetupColumn("hex.builtin.view.data_inspector.table.value"_lang);
 
                     ImGui::TableHeadersRow();
 
@@ -107,7 +107,7 @@ namespace hex {
                     this->m_shouldInvalidate = true;
                 }
             } else {
-                std::string text = "hex.view.data_inspector.no_data"_lang;
+                std::string text = "hex.builtin.view.data_inspector.no_data"_lang;
                 auto textSize = ImGui::CalcTextSize(text.c_str());
                 auto availableSpace = ImGui::GetContentRegionAvail();
 

plugins/builtin/source/content/views/view_data_processor.cpp

@@ -1,14 +1,14 @@
-#include "views/view_data_processor.hpp"
+#include "content/views/view_data_processor.hpp"
 
 #include <hex/providers/provider.hpp>
-#include <helpers/project_file_handler.hpp>
+#include <hex/helpers/project_file_handler.hpp>
 
 #include <imnodes.h>
 #include <nlohmann/json.hpp>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
-    ViewDataProcessor::ViewDataProcessor() : View("hex.view.data_processor.name") {
+    ViewDataProcessor::ViewDataProcessor() : View("hex.builtin.view.data_processor.name") {
         EventManager::subscribe<RequestChangeTheme>(this, [](u32 theme) {
             switch (theme) {
                 default:
@@ -31,7 +31,11 @@ namespace hex {
         });
 
         EventManager::subscribe<EventProjectFileLoad>(this, [this] {
-            this->loadNodes(ProjectFile::getDataProcessorContent());
+            try {
+                this->loadNodes(ProjectFile::getDataProcessorContent());
+            } catch (nlohmann::json::exception &e) {
+
+            }
         });
 
         EventManager::subscribe<EventFileLoaded>(this, [this](const std::string &path){
@@ -138,7 +142,7 @@ namespace hex {
     }
 
     void ViewDataProcessor::drawContent() {
-        if (ImGui::Begin(View::toWindowName("hex.view.data_processor.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
+        if (ImGui::Begin(View::toWindowName("hex.builtin.view.data_processor.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
 
             if (ImGui::IsMouseReleased(ImGuiMouseButton_Right) && ImGui::IsWindowHovered(ImGuiHoveredFlags_ChildWindows)) {
                 ImNodes::ClearNodeSelection();
@@ -158,7 +162,7 @@ namespace hex {
                 dp::Node *node = nullptr;
 
                 if (ImNodes::NumSelectedNodes() > 0 || ImNodes::NumSelectedLinks() > 0) {
-                    if (ImGui::MenuItem("hex.view.data_processor.name"_lang)) {
+                    if (ImGui::MenuItem("hex.builtin.view.data_processor.name"_lang)) {
                         std::vector<int> ids;
                         ids.resize(ImNodes::NumSelectedNodes());
                         ImNodes::GetSelectedNodes(ids.data());
@@ -217,14 +221,14 @@ namespace hex {
             }
 
             if (ImGui::BeginPopup("Node Menu")) {
-                if (ImGui::MenuItem("hex.view.data_processor.menu.remove_node"_lang))
+                if (ImGui::MenuItem("hex.builtin.view.data_processor.menu.remove_node"_lang))
                     this->eraseNodes({ this->m_rightClickedId });
 
                 ImGui::EndPopup();
             }
 
             if (ImGui::BeginPopup("Link Menu")) {
-                if (ImGui::MenuItem("hex.view.data_processor.menu.remove_link"_lang))
+                if (ImGui::MenuItem("hex.builtin.view.data_processor.menu.remove_link"_lang))
                     this->eraseLink(this->m_rightClickedId);
 
                 ImGui::EndPopup();

plugins/builtin/source/content/views/view_diff.cpp

@@ -1,4 +1,4 @@
-#include "views/view_diff.hpp"
+#include "content/views/view_diff.hpp"
 
 #include <hex/api/imhex_api.hpp>
 #include <hex/providers/provider.hpp>
@@ -8,9 +8,9 @@
 #include <hex/api/content_registry.hpp>
 #include <nlohmann/json.hpp>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
-    ViewDiff::ViewDiff() : View("hex.view.diff.name") {
+    ViewDiff::ViewDiff() : View("hex.builtin.view.diff.name") {
 
         EventManager::subscribe<EventSettingsChanged>(this, [this]{
             {
@@ -169,7 +169,7 @@ namespace hex {
     }
 
     void ViewDiff::drawContent() {
-        if (ImGui::Begin(View::toWindowName("hex.view.diff.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
+        if (ImGui::Begin(View::toWindowName("hex.builtin.view.diff.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
 
             ImGui::SameLine();
             ImGui::PushID(1);

plugins/builtin/source/content/views/view_disassembler.cpp

@@ -1,4 +1,4 @@
-#include "views/view_disassembler.hpp"
+#include "content/views/view_disassembler.hpp"
 
 #include <hex/providers/provider.hpp>
 #include <hex/helpers/fmt.hpp>
@@ -10,9 +10,9 @@
 
 using namespace std::literals::string_literals;
 
-namespace hex {
+namespace hex::plugin::builtin {
 
-    ViewDisassembler::ViewDisassembler() : View("hex.view.disassembler.name") {
+    ViewDisassembler::ViewDisassembler() : View("hex.builtin.view.disassembler.name") {
         EventManager::subscribe<EventDataChanged>(this, [this]() {
             this->disassemble();
         });
@@ -27,11 +27,16 @@ namespace hex {
                 }
             }
         });
+
+        EventManager::subscribe<EventFileUnloaded>(this, [this]{
+            this->m_disassembly.clear();
+        });
     }
 
     ViewDisassembler::~ViewDisassembler() {
         EventManager::unsubscribe<EventDataChanged>(this);
         EventManager::unsubscribe<EventRegionSelected>(this);
+        EventManager::unsubscribe<EventFileUnloaded>(this);
     }
 
     void ViewDisassembler::disassemble() {
@@ -104,15 +109,15 @@ namespace hex {
 
     void ViewDisassembler::drawContent() {
 
-        if (ImGui::Begin(View::toWindowName("hex.view.disassembler.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
+        if (ImGui::Begin(View::toWindowName("hex.builtin.view.disassembler.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
 
             auto provider = ImHexApi::Provider::get();
             if (ImHexApi::Provider::isValid() && provider->isReadable()) {
-                ImGui::TextUnformatted("hex.view.disassembler.position"_lang);
+                ImGui::TextUnformatted("hex.builtin.view.disassembler.position"_lang);
                 ImGui::Separator();
 
-                ImGui::InputScalar("hex.view.disassembler.base"_lang, ImGuiDataType_U64, &this->m_baseAddress, nullptr, nullptr, "%08llX", ImGuiInputTextFlags_CharsHexadecimal);
-                ImGui::InputScalarN("hex.view.disassembler.region"_lang, ImGuiDataType_U64, this->m_codeRegion, 2, nullptr, nullptr, "%08llX", ImGuiInputTextFlags_CharsHexadecimal);
+                ImGui::InputScalar("hex.builtin.view.disassembler.base"_lang, ImGuiDataType_U64, &this->m_baseAddress, nullptr, nullptr, "%08llX", ImGuiInputTextFlags_CharsHexadecimal);
+                ImGui::InputScalarN("hex.builtin.view.disassembler.region"_lang, ImGuiDataType_U64, this->m_codeRegion, 2, nullptr, nullptr, "%08llX", ImGuiInputTextFlags_CharsHexadecimal);
 
                 ImGui::Checkbox("hex.common.match_selection"_lang, &this->m_shouldMatchSelection);
                 if (ImGui::IsItemEdited()) {
@@ -121,10 +126,10 @@ namespace hex {
                 }
 
                 ImGui::NewLine();
-                ImGui::TextUnformatted("hex.view.disassembler.settings.header"_lang);
+                ImGui::TextUnformatted("hex.builtin.view.disassembler.settings.header"_lang);
                 ImGui::Separator();
 
-                ImGui::Combo("hex.view.disassembler.arch"_lang, reinterpret_cast<int*>(&this->m_architecture), Disassembler::ArchitectureNames, Disassembler::getArchitectureSupportedCount());
+                ImGui::Combo("hex.builtin.view.disassembler.arch"_lang, reinterpret_cast<int*>(&this->m_architecture), Disassembler::ArchitectureNames, Disassembler::getArchitectureSupportedCount());
 
 
                 if (ImGui::BeginChild("modes", ImVec2(0, ImGui::GetTextLineHeightWithSpacing() * 6), true, ImGuiWindowFlags_AlwaysAutoResize)) {
@@ -148,19 +153,19 @@ namespace hex {
                             if (this->m_modeBasicARM == cs_mode(0))
                                 this->m_modeBasicARM = CS_MODE_ARM;
 
-                            if (ImGui::RadioButton("hex.view.disassembler.arm.arm"_lang, this->m_modeBasicARM == CS_MODE_ARM))
+                            if (ImGui::RadioButton("hex.builtin.view.disassembler.arm.arm"_lang, this->m_modeBasicARM == CS_MODE_ARM))
                                 this->m_modeBasicARM = CS_MODE_ARM;
                             ImGui::SameLine();
-                            if (ImGui::RadioButton("hex.view.disassembler.arm.thumb"_lang, this->m_modeBasicARM == CS_MODE_THUMB))
+                            if (ImGui::RadioButton("hex.builtin.view.disassembler.arm.thumb"_lang, this->m_modeBasicARM == CS_MODE_THUMB))
                                 this->m_modeBasicARM = CS_MODE_THUMB;
 
-                            if (ImGui::RadioButton("hex.view.disassembler.arm.default"_lang, (this->m_modeExtraARM & (CS_MODE_MCLASS | CS_MODE_V8)) == 0))
+                            if (ImGui::RadioButton("hex.builtin.view.disassembler.arm.default"_lang, (this->m_modeExtraARM & (CS_MODE_MCLASS | CS_MODE_V8)) == 0))
                                 this->m_modeExtraARM = cs_mode(0);
                             ImGui::SameLine();
-                            if (ImGui::RadioButton("hex.view.disassembler.arm.cortex_m"_lang, (this->m_modeExtraARM & (CS_MODE_MCLASS | CS_MODE_V8)) == CS_MODE_MCLASS))
+                            if (ImGui::RadioButton("hex.builtin.view.disassembler.arm.cortex_m"_lang, (this->m_modeExtraARM & (CS_MODE_MCLASS | CS_MODE_V8)) == CS_MODE_MCLASS))
                                 this->m_modeExtraARM = CS_MODE_MCLASS;
                             ImGui::SameLine();
-                            if (ImGui::RadioButton("hex.view.disassembler.arm.armv8"_lang, (this->m_modeExtraARM & (CS_MODE_MCLASS | CS_MODE_V8)) == CS_MODE_V8))
+                            if (ImGui::RadioButton("hex.builtin.view.disassembler.arm.armv8"_lang, (this->m_modeExtraARM & (CS_MODE_MCLASS | CS_MODE_V8)) == CS_MODE_V8))
                                 this->m_modeExtraARM = CS_MODE_V8;
                             break;
                         case Architecture::MIPS:
@@ -173,16 +178,16 @@ namespace hex {
                             if (this->m_modeBasicMIPS == cs_mode(0))
                                 this->m_modeBasicMIPS = CS_MODE_MIPS32;
 
-                            if (ImGui::RadioButton("hex.view.disassembler.mips.mips32"_lang, this->m_modeBasicMIPS == CS_MODE_MIPS32))
+                            if (ImGui::RadioButton("hex.builtin.view.disassembler.mips.mips32"_lang, this->m_modeBasicMIPS == CS_MODE_MIPS32))
                                 this->m_modeBasicMIPS = CS_MODE_MIPS32;
                             ImGui::SameLine();
-                            if (ImGui::RadioButton("hex.view.disassembler.mips.mips64"_lang, this->m_modeBasicMIPS == CS_MODE_MIPS64))
+                            if (ImGui::RadioButton("hex.builtin.view.disassembler.mips.mips64"_lang, this->m_modeBasicMIPS == CS_MODE_MIPS64))
                                 this->m_modeBasicMIPS = CS_MODE_MIPS64;
                             ImGui::SameLine();
-                            if (ImGui::RadioButton("hex.view.disassembler.mips.mips32R6"_lang, this->m_modeBasicMIPS == CS_MODE_MIPS32R6))
+                            if (ImGui::RadioButton("hex.builtin.view.disassembler.mips.mips32R6"_lang, this->m_modeBasicMIPS == CS_MODE_MIPS32R6))
                                 this->m_modeBasicMIPS = CS_MODE_MIPS32R6;
 
-                            ImGui::Checkbox("hex.view.disassembler.mips.micro"_lang, &this->m_micoMode);
+                            ImGui::Checkbox("hex.builtin.view.disassembler.mips.micro"_lang, &this->m_micoMode);
                             break;
                         case Architecture::X86:
                             this->m_modeBasicARM = cs_mode(0);
@@ -195,13 +200,13 @@ namespace hex {
                             if (this->m_modeBasicX86 == cs_mode(0))
                                 this->m_modeBasicX86 = CS_MODE_16;
 
-                            if (ImGui::RadioButton("hex.view.disassembler.x86.16bit"_lang, this->m_modeBasicX86 == CS_MODE_16))
+                            if (ImGui::RadioButton("hex.builtin.view.disassembler.x86.16bit"_lang, this->m_modeBasicX86 == CS_MODE_16))
                                 this->m_modeBasicX86 = CS_MODE_16;
                             ImGui::SameLine();
-                            if (ImGui::RadioButton("hex.view.disassembler.x86.32bit"_lang, this->m_modeBasicX86 == CS_MODE_32))
+                            if (ImGui::RadioButton("hex.builtin.view.disassembler.x86.32bit"_lang, this->m_modeBasicX86 == CS_MODE_32))
                                 this->m_modeBasicX86 = CS_MODE_32;
                             ImGui::SameLine();
-                            if (ImGui::RadioButton("hex.view.disassembler.x86.64bit"_lang, this->m_modeBasicX86 == CS_MODE_64))
+                            if (ImGui::RadioButton("hex.builtin.view.disassembler.x86.64bit"_lang, this->m_modeBasicX86 == CS_MODE_64))
                                 this->m_modeBasicX86 = CS_MODE_64;
                             break;
                         case Architecture::PPC:
@@ -215,10 +220,10 @@ namespace hex {
                             if (m_modeBasicPPC == cs_mode(0))
                                 this->m_modeBasicPPC = CS_MODE_32;
 
-                            if (ImGui::RadioButton("hex.view.disassembler.ppc.32bit"_lang, this->m_modeBasicPPC == CS_MODE_32))
+                            if (ImGui::RadioButton("hex.builtin.view.disassembler.ppc.32bit"_lang, this->m_modeBasicPPC == CS_MODE_32))
                                 this->m_modeBasicPPC = CS_MODE_32;
                             ImGui::SameLine();
-                            if (ImGui::RadioButton("hex.view.disassembler.ppc.64bit"_lang, this->m_modeBasicPPC == CS_MODE_64))
+                            if (ImGui::RadioButton("hex.builtin.view.disassembler.ppc.64bit"_lang, this->m_modeBasicPPC == CS_MODE_64))
                                 this->m_modeBasicPPC = CS_MODE_64;
                             break;
                         case Architecture::SPARC:
@@ -229,7 +234,7 @@ namespace hex {
                             this->m_modeBasicPPC = cs_mode(0);
                             this->m_micoMode = false;
 
-                            ImGui::Checkbox("hex.view.disassembler.sparc.v9"_lang, &this->m_sparcV9Mode);
+                            ImGui::Checkbox("hex.builtin.view.disassembler.sparc.v9"_lang, &this->m_sparcV9Mode);
                             break;
                         case Architecture::ARM64:
                         case Architecture::SYSZ:
@@ -252,26 +257,26 @@ namespace hex {
                 ImGui::EndChild();
 
                 ImGui::Disabled([this] {
-                    if (ImGui::Button("hex.view.disassembler.disassemble"_lang))
+                    if (ImGui::Button("hex.builtin.view.disassembler.disassemble"_lang))
                         this->disassemble();
                 }, this->m_disassembling);
 
                 if (this->m_disassembling) {
                     ImGui::SameLine();
-                    ImGui::TextSpinner("hex.view.disassembler.disassembling"_lang);
+                    ImGui::TextSpinner("hex.builtin.view.disassembler.disassembling"_lang);
                 }
 
                 ImGui::NewLine();
 
-                ImGui::TextUnformatted("hex.view.disassembler.disassembly.title"_lang);
+                ImGui::TextUnformatted("hex.builtin.view.disassembler.disassembly.title"_lang);
                 ImGui::Separator();
 
                 if (ImGui::BeginTable("##disassembly", 4, ImGuiTableFlags_ScrollY | ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable | ImGuiTableFlags_RowBg | ImGuiTableFlags_Reorderable)) {
                     ImGui::TableSetupScrollFreeze(0, 1);
-                    ImGui::TableSetupColumn("hex.view.disassembler.disassembly.address"_lang);
-                    ImGui::TableSetupColumn("hex.view.disassembler.disassembly.offset"_lang);
-                    ImGui::TableSetupColumn("hex.view.disassembler.disassembly.bytes"_lang);
-                    ImGui::TableSetupColumn("hex.view.disassembler.disassembly.title"_lang);
+                    ImGui::TableSetupColumn("hex.builtin.view.disassembler.disassembly.address"_lang);
+                    ImGui::TableSetupColumn("hex.builtin.view.disassembler.disassembly.offset"_lang);
+                    ImGui::TableSetupColumn("hex.builtin.view.disassembler.disassembly.bytes"_lang);
+                    ImGui::TableSetupColumn("hex.builtin.view.disassembler.disassembly.title"_lang);
 
                     ImGuiListClipper clipper;
                     clipper.Begin(this->m_disassembly.size());

plugins/builtin/source/content/views/view_hashes.cpp

@@ -1,4 +1,4 @@
-#include "views/view_hashes.hpp"
+#include "content/views/view_hashes.hpp"
 
 #include <hex/providers/provider.hpp>
 #include <hex/helpers/crypto.hpp>
@@ -6,9 +6,9 @@
 #include <vector>
 
 
-namespace hex {
+namespace hex::plugin::builtin {
 
-    ViewHashes::ViewHashes() : View("hex.view.hashes.name") {
+    ViewHashes::ViewHashes() : View("hex.builtin.view.hashes.name") {
         EventManager::subscribe<EventDataChanged>(this, [this]() {
             this->m_shouldInvalidate = true;
         });
@@ -39,7 +39,7 @@ namespace hex {
     }
 
     void ViewHashes::drawContent() {
-        if (ImGui::Begin(View::toWindowName("hex.view.hashes.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
+        if (ImGui::Begin(View::toWindowName("hex.builtin.view.hashes.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
             if (ImGui::BeginChild("##scrolling", ImVec2(0, 0), false, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoNav)) {
 
 
@@ -60,10 +60,10 @@ namespace hex {
                     }
 
                     ImGui::NewLine();
-                    ImGui::TextUnformatted("hex.view.hashes.settings"_lang);
+                    ImGui::TextUnformatted("hex.builtin.view.hashes.settings"_lang);
                     ImGui::Separator();
 
-                    if (ImGui::BeginCombo("hex.view.hashes.function"_lang, hashFunctionNames[this->m_currHashFunction].second, 0))
+                    if (ImGui::BeginCombo("hex.builtin.view.hashes.function"_lang, hashFunctionNames[this->m_currHashFunction].second, 0))
                     {
                         for (int i = 0; i < hashFunctionNames.size(); i++)
                         {
@@ -88,10 +88,10 @@ namespace hex {
                             static int polynomial = 0x07, init = 0x0000, xorout = 0x0000;
                             static bool reflectIn = false, reflectOut = false;
 
-                            ImGui::InputInt("hex.view.hashes.iv"_lang, &init, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
+                            ImGui::InputInt("hex.builtin.view.hashes.iv"_lang, &init, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
                             if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
 
-                            ImGui::InputInt("hex.view.hashes.xorout"_lang, &xorout, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
+                            ImGui::InputInt("hex.builtin.view.hashes.xorout"_lang, &xorout, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
                             if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
 
                             ImGui::Checkbox("hex.common.reflectIn"_lang, &reflectIn);
@@ -100,7 +100,7 @@ namespace hex {
                             ImGui::Checkbox("hex.common.reflectOut"_lang, &reflectOut);
                             if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
 
-                            ImGui::InputInt("hex.view.hashes.poly"_lang, &polynomial, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
+                            ImGui::InputInt("hex.builtin.view.hashes.poly"_lang, &polynomial, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
                             if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
 
                             ImGui::NewLine();
@@ -114,7 +114,7 @@ namespace hex {
                             char buffer[sizeof(result) * 2 + 1];
                             snprintf(buffer, sizeof(buffer), "%02X", result);
 
-                            ImGui::TextUnformatted("hex.view.hashes.result"_lang);
+                            ImGui::TextUnformatted("hex.builtin.view.hashes.result"_lang);
                             ImGui::Separator();
                             ImGui::InputText("##nolabel", buffer, ImGuiInputTextFlags_ReadOnly);
                         }
@@ -124,10 +124,10 @@ namespace hex {
                             static int polynomial = 0x8005, init = 0x0000, xorout = 0x0000;
                             static bool reflectIn = false, reflectOut = false;
 
-                            ImGui::InputInt("hex.view.hashes.iv"_lang, &init, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
+                            ImGui::InputInt("hex.builtin.view.hashes.iv"_lang, &init, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
                             if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
 
-                            ImGui::InputInt("hex.view.hashes.xorout"_lang, &xorout, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
+                            ImGui::InputInt("hex.builtin.view.hashes.xorout"_lang, &xorout, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
                             if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
 
                             ImGui::Checkbox("hex.common.reflectIn"_lang, &reflectIn);
@@ -136,7 +136,7 @@ namespace hex {
                             ImGui::Checkbox("hex.common.reflectOut"_lang, &reflectOut);
                             if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
 
-                            ImGui::InputInt("hex.view.hashes.poly"_lang, &polynomial, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
+                            ImGui::InputInt("hex.builtin.view.hashes.poly"_lang, &polynomial, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
                             if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
 
                             ImGui::NewLine();
@@ -150,7 +150,7 @@ namespace hex {
                             char buffer[sizeof(result) * 2 + 1];
                             snprintf(buffer, sizeof(buffer), "%04X", result);
 
-                            ImGui::TextUnformatted("hex.view.hashes.result"_lang);
+                            ImGui::TextUnformatted("hex.builtin.view.hashes.result"_lang);
                             ImGui::Separator();
                             ImGui::InputText("##nolabel", buffer, ImGuiInputTextFlags_ReadOnly);
                         }
@@ -162,10 +162,10 @@ namespace hex {
 
 
 
-                            ImGui::InputInt("hex.view.hashes.iv"_lang, &init, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
+                            ImGui::InputInt("hex.builtin.view.hashes.iv"_lang, &init, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
                             if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
 
-                            ImGui::InputInt("hex.view.hashes.xorout"_lang, &xorout, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
+                            ImGui::InputInt("hex.builtin.view.hashes.xorout"_lang, &xorout, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
                             if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
 
                             ImGui::Checkbox("hex.common.reflectIn"_lang, &reflectIn);
@@ -174,7 +174,7 @@ namespace hex {
                             ImGui::Checkbox("hex.common.reflectOut"_lang, &reflectOut);
                             if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
 
-                            ImGui::InputInt("hex.view.hashes.poly"_lang, &polynomial, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
+                            ImGui::InputInt("hex.builtin.view.hashes.poly"_lang, &polynomial, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
                             if (ImGui::IsItemEdited()) this->m_shouldInvalidate = true;
 
                             ImGui::NewLine();
@@ -188,7 +188,7 @@ namespace hex {
                             char buffer[sizeof(result) * 2 + 1];
                             snprintf(buffer, sizeof(buffer), "%08X", result);
 
-                            ImGui::TextUnformatted("hex.view.hashes.result"_lang);
+                            ImGui::TextUnformatted("hex.builtin.view.hashes.result"_lang);
                             ImGui::Separator();
                             ImGui::InputText("##nolabel", buffer, ImGuiInputTextFlags_ReadOnly);
                         }
@@ -204,7 +204,7 @@ namespace hex {
                             formatBigHexInt(result, buffer, sizeof(buffer));
 
                             ImGui::NewLine();
-                            ImGui::TextUnformatted("hex.view.hashes.result"_lang);
+                            ImGui::TextUnformatted("hex.builtin.view.hashes.result"_lang);
                             ImGui::Separator();
                             ImGui::InputText("##nolabel", buffer, ImGuiInputTextFlags_ReadOnly);
                         }
@@ -220,7 +220,7 @@ namespace hex {
                             formatBigHexInt(result, buffer, sizeof(buffer));
 
                             ImGui::NewLine();
-                            ImGui::TextUnformatted("hex.view.hashes.result"_lang);
+                            ImGui::TextUnformatted("hex.builtin.view.hashes.result"_lang);
                             ImGui::Separator();
                             ImGui::InputText("##nolabel", buffer, ImGuiInputTextFlags_ReadOnly);
                         }
@@ -236,7 +236,7 @@ namespace hex {
                             formatBigHexInt(result, buffer, sizeof(buffer));
 
                             ImGui::NewLine();
-                            ImGui::TextUnformatted("hex.view.hashes.result"_lang);
+                            ImGui::TextUnformatted("hex.builtin.view.hashes.result"_lang);
                             ImGui::Separator();
                             ImGui::InputText("##nolabel", buffer, ImGuiInputTextFlags_ReadOnly);
                         }
@@ -252,7 +252,7 @@ namespace hex {
                             formatBigHexInt(result, buffer, sizeof(buffer));
 
                             ImGui::NewLine();
-                            ImGui::TextUnformatted("hex.view.hashes.result"_lang);
+                            ImGui::TextUnformatted("hex.builtin.view.hashes.result"_lang);
                             ImGui::Separator();
                             ImGui::InputText("##nolabel", buffer, ImGuiInputTextFlags_ReadOnly);
                         }
@@ -268,7 +268,7 @@ namespace hex {
                             formatBigHexInt(result, buffer, sizeof(buffer));
 
                             ImGui::NewLine();
-                            ImGui::TextUnformatted("hex.view.hashes.result"_lang);
+                            ImGui::TextUnformatted("hex.builtin.view.hashes.result"_lang);
                             ImGui::Separator();
                             ImGui::InputText("##nolabel", buffer, ImGuiInputTextFlags_ReadOnly);
                         }
@@ -284,7 +284,7 @@ namespace hex {
                             formatBigHexInt(result, buffer, sizeof(buffer));
 
                             ImGui::NewLine();
-                            ImGui::TextUnformatted("hex.view.hashes.result"_lang);
+                            ImGui::TextUnformatted("hex.builtin.view.hashes.result"_lang);
                             ImGui::Separator();
                             ImGui::InputText("##nolabel", buffer, ImGuiInputTextFlags_ReadOnly);
                         }

plugins/builtin/source/content/views/view_help.cpp

@@ -0,0 +1,178 @@
+#include "content/views/view_help.hpp"
+#include <hex/helpers/paths.hpp>
+
+#include <imgui_imhex_extensions.h>
+
+#include <hex/helpers/fmt.hpp>
+#include <hex/helpers/utils.hpp>
+
+namespace hex::plugin::builtin {
+
+    ViewHelp::ViewHelp() : View("hex.builtin.view.help.about.name") {
+    }
+
+    ViewHelp::~ViewHelp() {
+
+    }
+
+    static void link(const std::string &label, const std::string &url) {
+        if (ImGui::BulletHyperlink(label.data()))
+            hex::openWebpage(url.data());
+    }
+
+    void ViewHelp::drawAboutMainPage() {
+        ImGui::Text("ImHex Hex Editor v%s by WerWolv - " ICON_FA_CODE_BRANCH, IMHEX_VERSION);
+
+        #if defined(GIT_BRANCH) && defined(GIT_COMMIT_HASH)
+            ImGui::SameLine();
+            if (ImGui::Hyperlink(hex::format("{0}@{1}", GIT_BRANCH, GIT_COMMIT_HASH).c_str()))
+                hex::openWebpage("https://github.com/WerWolv/ImHex/commit/" GIT_COMMIT_HASH);
+        #endif
+
+        ImGui::TextUnformatted("hex.builtin.view.help.about.translator"_lang);
+
+        ImGui::TextUnformatted("hex.builtin.view.help.about.source"_lang); ImGui::SameLine();
+        if (ImGui::Hyperlink("WerWolv/ImHex"))
+            hex::openWebpage("https://github.com/WerWolv/ImHex");
+        ImGui::NewLine();
+
+        ImGui::TextUnformatted("hex.builtin.view.help.about.donations"_lang);
+        ImGui::Separator();
+
+        constexpr const char* Links[] = { "https://werwolv.net/donate", "https://www.patreon.com/werwolv", "https://github.com/sponsors/WerWolv" };
+
+        ImGui::TextWrapped("%s", static_cast<const char *>("hex.builtin.view.help.about.thanks"_lang));
+
+        ImGui::NewLine();
+
+        for (auto &link : Links) {
+            if (ImGui::Hyperlink(link))
+                hex::openWebpage(link);
+        }
+    }
+
+    void ViewHelp::drawContributorPage() {
+        link("Mary for porting ImHex to MacOS", "https://github.com/Thog");
+        link("Roblabla for adding the MSI Windows installer", "https://github.com/roblabla");
+        link("jam1garner for adding support for Rust plugins", "https://github.com/jam1garner");
+
+    }
+
+    void ViewHelp::drawLibraryCreditsPage() {
+        ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(0.2F, 0.2F, 0.2F, 0.3F));
+
+        link("ImGui by ocornut", "https://github.com/ocornut/imgui");
+        link("imgui_club by ocornut", "https://github.com/ocornut/imgui_club");
+        link("imnodes by Nelarius", "https://github.com/Nelarius/imnodes");
+        link("ImGuiColorTextEdit by BalazsJako", "https://github.com/BalazsJako/ImGuiColorTextEdit");
+        link("ImPlot by epezent", "https://github.com/epezent/implot");
+        link("capstone by aquynh", "https://github.com/aquynh/capstone");
+        link("JSON for Modern C++ by nlohmann", "https://github.com/nlohmann/json");
+        link("YARA by VirusTotal", "https://github.com/VirusTotal/yara");
+        link("Native File Dialog Extended by btzy and mlabbe", "https://github.com/btzy/nativefiledialog-extended");
+        link("Native File Dialog Extended by btzy and mlabbe", "https://github.com/btzy/nativefiledialog-extended");
+        ImGui::NewLine();
+        link("GNU libmagic", "http://www.darwinsys.com/file/");
+        link("GLFW3", "https://github.com/glfw/glfw");
+        link("LLVM", "https://github.com/llvm/llvm-project");
+        link("Python 3", "https://github.com/python/cpython");
+        link("FreeType", "https://gitlab.freedesktop.org/freetype/freetype");
+        link("Mbed TLS", "https://github.com/ARMmbed/mbedtls");
+
+        ImGui::PopStyleColor();
+    }
+
+    void ViewHelp::drawPathsPage() {
+        if (ImGui::BeginTable("##imhex_paths", 2, ImGuiTableFlags_ScrollY | ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingFixedFit)) {
+            ImGui::TableSetupScrollFreeze(0, 1);
+            ImGui::TableSetupColumn("Type");
+            ImGui::TableSetupColumn("Paths");
+
+            constexpr std::array<std::pair<const char*, ImHexPath>, 8> PathTypes = {{
+                { "Resources",          ImHexPath::Resources },
+                { "Config",             ImHexPath::Config },
+                { "Magic",              ImHexPath::Magic },
+                { "Patterns",           ImHexPath::Patterns },
+                { "Patterns Includes",  ImHexPath::PatternsInclude },
+                { "Plugins",            ImHexPath::Plugins },
+                { "Python Scripts",     ImHexPath::Python },
+                { "Yara Patterns",      ImHexPath::Yara }
+            }};
+
+            ImGui::TableHeadersRow();
+            for (const auto &[name, type] : PathTypes) {
+                ImGui::TableNextRow();
+                ImGui::TableNextColumn();
+                ImGui::TextUnformatted(name);
+
+                ImGui::TableNextColumn();
+                for (auto &path : hex::getPath(type))
+                    ImGui::TextUnformatted(path.c_str());
+            }
+
+            ImGui::EndTable();
+        }
+    }
+
+    void ViewHelp::drawAboutPopup() {
+        ImGui::SetNextWindowSize(ImVec2(600, 350) * SharedData::globalScale, ImGuiCond_Always);
+        if (ImGui::BeginPopupModal(View::toWindowName("hex.builtin.view.help.about.name").c_str(), &this->m_aboutWindowOpen, ImGuiWindowFlags_NoResize)) {
+
+            if (ImGui::IsKeyDown(ImGui::GetKeyIndex(ImGuiKey_Escape)))
+                ImGui::CloseCurrentPopup();
+
+            if (ImGui::BeginTabBar("about_tab_bar")) {
+
+                if (ImGui::BeginTabItem("ImHex")) {
+                    ImGui::NewLine();
+                    this->drawAboutMainPage();
+                    ImGui::EndTabItem();
+                }
+
+                if (ImGui::BeginTabItem("hex.builtin.view.help.about.contributor"_lang)) {
+                    ImGui::NewLine();
+                    this->drawContributorPage();
+                    ImGui::EndTabItem();
+                }
+
+                if (ImGui::BeginTabItem("hex.builtin.view.help.about.libs"_lang)) {
+                    ImGui::NewLine();
+                    this->drawLibraryCreditsPage();
+                    ImGui::EndTabItem();
+                }
+
+                if (ImGui::BeginTabItem("hex.builtin.view.help.about.paths"_lang)) {
+                    ImGui::NewLine();
+                    this->drawPathsPage();
+                    ImGui::EndTabItem();
+                }
+
+                ImGui::EndTabBar();
+            }
+
+            ImGui::EndPopup();
+        }
+    }
+
+    void ViewHelp::drawContent() {
+        if (!this->m_aboutWindowOpen)
+            this->getWindowOpenState() = false;
+
+        this->drawAboutPopup();
+    }
+
+    void ViewHelp::drawMenu() {
+        if (ImGui::BeginMenu("hex.menu.help"_lang)) {
+            if (ImGui::MenuItem("hex.builtin.view.help.about.name"_lang, "")) {
+                View::doLater([] { ImGui::OpenPopup(View::toWindowName("hex.builtin.view.help.about.name").c_str()); });
+                this->m_aboutWindowOpen = true;
+                this->getWindowOpenState() = true;
+            }
+            if (ImGui::MenuItem("hex.builtin.view.help.documentation"_lang, "")) {
+                hex::openWebpage("https://imhex.werwolv.net/docs");
+            }
+            ImGui::EndMenu();
+        }
+    }
+
+}

plugins/builtin/source/content/views/view_hexeditor.cpp

@@ -1,4 +1,4 @@
-#include "views/view_hexeditor.hpp"
+#include "content/views/view_hexeditor.hpp"
 
 #include <hex/api/imhex_api.hpp>
 #include <hex/providers/provider.hpp>
@@ -6,10 +6,11 @@
 #include <hex/helpers/file.hpp>
 #include <hex/pattern_language/pattern_data.hpp>
 
-#include "providers/file_provider.hpp"
-#include "helpers/patches.hpp"
-#include "helpers/project_file_handler.hpp"
-#include "helpers/loader_script_handler.hpp"
+#include "content/providers/file_provider.hpp"
+
+#include <hex/helpers/patches.hpp>
+#include <hex/helpers/project_file_handler.hpp>
+#include <hex/helpers/loader_script_handler.hpp>
 
 #include <GLFW/glfw3.h>
 
@@ -27,9 +28,9 @@
     #include <unistd.h>
 #endif
 
-namespace hex {
+namespace hex::plugin::builtin {
 
-    ViewHexEditor::ViewHexEditor() : View("hex.view.hexeditor.name"_lang) {
+    ViewHexEditor::ViewHexEditor() : View("hex.builtin.view.hexeditor.name"_lang) {
 
         this->m_searchStringBuffer.resize(0xFFF, 0x00);
         this->m_searchHexBuffer.resize(0xFFF, 0x00);
@@ -40,7 +41,7 @@ namespace hex {
                 return 0x00;
 
             ImU8 byte;
-            provider->readRelative(off, &byte, sizeof(ImU8));
+            provider->read(off + provider->getBaseAddress() + provider->getCurrentPageAddress(), &byte, sizeof(ImU8));
 
             return byte;
         };
@@ -50,7 +51,7 @@ namespace hex {
             if (!provider->isAvailable() || !provider->isWritable())
                 return;
 
-            provider->writeRelative(off, &d, sizeof(ImU8));
+            provider->write(off + provider->getBaseAddress() + provider->getCurrentPageAddress(), &d, sizeof(ImU8));
             EventManager::post<EventDataChanged>();
             ProjectFile::markDirty();
         };
@@ -60,7 +61,9 @@ namespace hex {
 
             std::optional<u32> currColor, prevColor;
 
-            off += ImHexApi::Provider::get()->getBaseAddress();
+            auto provider = ImHexApi::Provider::get();
+
+            off += provider->getBaseAddress() + provider->getCurrentPageAddress();
 
             u32 alpha = static_cast<u32>(_this->m_highlightAlpha) << 24;
 
@@ -124,7 +127,7 @@ namespace hex {
             size_t size = std::min<size_t>(_this->m_currEncodingFile.getLongestSequence(), provider->getActualSize() - addr);
 
             std::vector<u8> buffer(size);
-            provider->readRelative(addr, buffer.data(), size);
+            provider->read(addr + provider->getBaseAddress() + provider->getCurrentPageAddress(), buffer.data(), size);
 
             auto [decoded, advance] = _this->m_currEncodingFile.getEncodingFor(buffer);
 
@@ -152,8 +155,8 @@ namespace hex {
 
             if (region.size != 0) {
                 provider->setCurrentPage(page.value());
-                u64 start = region.address;
-                this->m_memoryEditor.GotoAddrAndSelect(start - provider->getBaseAddress(), start + region.size - provider->getBaseAddress() - 1);
+                u64 start = region.address - provider->getBaseAddress() - provider->getCurrentPageAddress();
+                this->m_memoryEditor.GotoAddrAndSelect(start, start + region.size - 1);
             }
 
             EventManager::post<EventRegionSelected>(Region { this->m_memoryEditor.DataPreviewAddr, (this->m_memoryEditor.DataPreviewAddrEnd - this->m_memoryEditor.DataPreviewAddr) + 1});
@@ -166,7 +169,7 @@ namespace hex {
         EventManager::subscribe<EventWindowClosing>(this, [](GLFWwindow *window) {
             if (ProjectFile::hasUnsavedChanges()) {
                 glfwSetWindowShouldClose(window, GLFW_FALSE);
-                View::doLater([] { ImGui::OpenPopup("hex.view.hexeditor.exit_application.title"_lang); });
+                View::doLater([] { ImGui::OpenPopup("hex.builtin.view.hexeditor.exit_application.title"_lang); });
             }
         });
 
@@ -180,9 +183,9 @@ namespace hex {
 
         EventManager::subscribe<RequestOpenWindow>(this, [this](std::string name) {
             if (name == "Create File") {
-                hex::openFileBrowser("hex.view.hexeditor.create_file"_lang, DialogMode::Save, { }, [this](auto path) {
+                hex::openFileBrowser("hex.builtin.view.hexeditor.create_file"_lang, DialogMode::Save, { }, [this](auto path) {
                     if (!this->createFile(path)) {
-                        View::showErrorPopup("hex.view.hexeditor.error.create"_lang);
+                        View::showErrorPopup("hex.builtin.view.hexeditor.error.create"_lang);
                         return;
                     }
 
@@ -190,12 +193,12 @@ namespace hex {
                     this->getWindowOpenState() = true;
                 });
             } else if (name == "Open File") {
-                hex::openFileBrowser("hex.view.hexeditor.open_file"_lang, DialogMode::Open, { }, [this](auto path) {
+                hex::openFileBrowser("hex.builtin.view.hexeditor.open_file"_lang, DialogMode::Open, { }, [this](auto path) {
                     EventManager::post<RequestOpenFile>(path);
                     this->getWindowOpenState() = true;
                 });
             } else if (name == "Open Project") {
-                hex::openFileBrowser("hex.view.hexeditor.open_project"_lang, DialogMode::Open, { { "Project File", "hexproj" } }, [this](auto path) {
+                hex::openFileBrowser("hex.builtin.view.hexeditor.open_project"_lang, DialogMode::Open, { { "Project File", "hexproj" } }, [this](auto path) {
                     ProjectFile::load(path);
                     this->getWindowOpenState() = true;
                 });
@@ -283,10 +286,10 @@ namespace hex {
 
         size_t dataSize = (!ImHexApi::Provider::isValid() || !provider->isReadable()) ? 0x00 : provider->getSize();
 
-        this->m_memoryEditor.DrawWindow(View::toWindowName("hex.view.hexeditor.name").c_str(), &this->getWindowOpenState(), this, dataSize, dataSize == 0 ? 0x00 : provider->getBaseAddress());
+        this->m_memoryEditor.DrawWindow(View::toWindowName("hex.builtin.view.hexeditor.name").c_str(), &this->getWindowOpenState(), this, dataSize, dataSize == 0 ? 0x00 : provider->getBaseAddress() + provider->getCurrentPageAddress());
 
         if (dataSize != 0x00) {
-            if (ImGui::Begin(View::toWindowName("hex.view.hexeditor.name").c_str())) {
+            if (ImGui::Begin(View::toWindowName("hex.builtin.view.hexeditor.name").c_str())) {
 
                 if (ImGui::IsMouseReleased(ImGuiMouseButton_Right) && ImGui::IsWindowHovered(ImGuiHoveredFlags_ChildWindows))
                     ImGui::OpenPopup("hex.menu.edit"_lang);
@@ -297,7 +300,9 @@ namespace hex {
                 }
 
                 if (provider->getPageCount() > 1) {
-                    ImGui::TextUnformatted(hex::format("hex.view.hexeditor.page"_lang, provider->getCurrentPage() + 1, provider->getPageCount()).c_str());
+                    ImGui::SameLine();
+
+                    ImGui::TextUnformatted(hex::format("hex.builtin.view.hexeditor.page"_lang, provider->getCurrentPage() + 1, provider->getPageCount()).c_str());
 
                     ImGui::SameLine();
 
@@ -329,7 +334,7 @@ namespace hex {
     }
 
     static void saveAs() {
-        hex::openFileBrowser("hex.view.hexeditor.save_as"_lang, DialogMode::Save, { }, [](auto path) {
+        hex::openFileBrowser("hex.builtin.view.hexeditor.save_as"_lang, DialogMode::Save, { }, [](auto path) {
             ImHexApi::Provider::get()->saveAs(path);
         });
     }
@@ -337,9 +342,9 @@ namespace hex {
     void ViewHexEditor::drawAlwaysVisible() {
         auto provider = ImHexApi::Provider::get();
 
-        if (ImGui::BeginPopupModal("hex.view.hexeditor.exit_application.title"_lang, nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
+        if (ImGui::BeginPopupModal("hex.builtin.view.hexeditor.exit_application.title"_lang, nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
             ImGui::NewLine();
-            ImGui::TextUnformatted("hex.view.hexeditor.exit_application.desc"_lang);
+            ImGui::TextUnformatted("hex.builtin.view.hexeditor.exit_application.desc"_lang);
             ImGui::NewLine();
 
             confirmButtons("hex.common.yes"_lang, "hex.common.no"_lang, [] {
@@ -355,22 +360,22 @@ namespace hex {
             ImGui::EndPopup();
         }
 
-        if (ImGui::BeginPopupModal("hex.view.hexeditor.script.title"_lang, nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
+        if (ImGui::BeginPopupModal("hex.builtin.view.hexeditor.script.title"_lang, nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
             ImGui::SetCursorPosX(10);
-            ImGui::TextWrapped("%s", static_cast<const char *>("hex.view.hexeditor.script.desc"_lang));
+            ImGui::TextWrapped("%s", static_cast<const char *>("hex.builtin.view.hexeditor.script.desc"_lang));
 
             ImGui::NewLine();
             ImGui::InputText("##nolabel", this->m_loaderScriptScriptPath.data(), this->m_loaderScriptScriptPath.length(), ImGuiInputTextFlags_ReadOnly);
             ImGui::SameLine();
-            if (ImGui::Button("hex.view.hexeditor.script.script"_lang)) {
-                hex::openFileBrowser("hex.view.hexeditor.script.script.title"_lang, DialogMode::Open, { { "Python Script", "py" } }, [this](auto path) {
+            if (ImGui::Button("hex.builtin.view.hexeditor.script.script"_lang)) {
+                hex::openFileBrowser("hex.builtin.view.hexeditor.script.script.title"_lang, DialogMode::Open, { { "Python Script", "py" } }, [this](auto path) {
                     this->m_loaderScriptScriptPath = path;
                 });
             }
             ImGui::InputText("##nolabel", this->m_loaderScriptFilePath.data(), this->m_loaderScriptFilePath.length(), ImGuiInputTextFlags_ReadOnly);
             ImGui::SameLine();
-            if (ImGui::Button("hex.view.hexeditor.script.file"_lang)) {
-                hex::openFileBrowser("hex.view.hexeditor.script.file.title"_lang, DialogMode::Open, { }, [this](auto path) {
+            if (ImGui::Button("hex.builtin.view.hexeditor.script.file"_lang)) {
+                hex::openFileBrowser("hex.builtin.view.hexeditor.script.file.title"_lang, DialogMode::Open, { }, [this](auto path) {
                     this->m_loaderScriptFilePath = path;
                 });
             }
@@ -398,7 +403,7 @@ namespace hex {
 
         }
 
-        if (ImGui::BeginPopupModal("hex.view.hexeditor.menu.edit.set_base"_lang, nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
+        if (ImGui::BeginPopupModal("hex.builtin.view.hexeditor.menu.edit.set_base"_lang, nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
             ImGui::InputText("hex.common.address"_lang, this->m_baseAddressBuffer, 16, ImGuiInputTextFlags_CharsHexadecimal);
             ImGui::NewLine();
 
@@ -416,7 +421,7 @@ namespace hex {
             ImGui::EndPopup();
         }
 
-        if (ImGui::BeginPopupModal("hex.view.hexeditor.menu.edit.resize"_lang, nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
+        if (ImGui::BeginPopupModal("hex.builtin.view.hexeditor.menu.edit.resize"_lang, nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
             ImGui::InputScalar("hex.common.size"_lang, ImGuiDataType_U64, &this->m_resizeSize, nullptr, nullptr, "0x%016llx", ImGuiInputTextFlags_CharsHexadecimal);
             ImGui::NewLine();
 
@@ -440,14 +445,14 @@ namespace hex {
         bool providerValid = ImHexApi::Provider::isValid();
 
         if (ImGui::BeginMenu("hex.menu.file"_lang)) {
-            if (ImGui::MenuItem("hex.view.hexeditor.menu.file.open_file"_lang, "CTRL + O")) {
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.file.open_file"_lang, "CTRL + O")) {
 
-                hex::openFileBrowser("hex.view.hexeditor.open_file"_lang, DialogMode::Open, { }, [this](auto path) {
+                hex::openFileBrowser("hex.builtin.view.hexeditor.open_file"_lang, DialogMode::Open, { }, [this](auto path) {
                     EventManager::post<RequestOpenFile>(path);
                 });
             }
 
-            if (ImGui::BeginMenu("hex.view.hexeditor.menu.file.open_recent"_lang, !SharedData::recentFilePaths.empty())) {
+            if (ImGui::BeginMenu("hex.builtin.view.hexeditor.menu.file.open_recent"_lang, !SharedData::recentFilePaths.empty())) {
                 for (auto &path : SharedData::recentFilePaths) {
                     if (ImGui::MenuItem(std::filesystem::path(path).filename().string().c_str())) {
                         EventManager::post<RequestOpenFile>(path);
@@ -457,35 +462,46 @@ namespace hex {
                 ImGui::EndMenu();
             }
 
-            if (ImGui::MenuItem("hex.view.hexeditor.menu.file.save"_lang, "CTRL + S", false, providerValid && provider->isWritable())) {
+            if (ImGui::BeginMenu("hex.builtin.view.hexeditor.menu.file.open_other"_lang)) {
+
+                for (const auto &unlocalizedProviderName : ContentRegistry::Provider::getEntries()) {
+                    if (ImGui::MenuItem(LangEntry(unlocalizedProviderName))) {
+                        EventManager::post<RequestCreateProvider>(unlocalizedProviderName, nullptr);
+                    }
+                }
+
+                ImGui::EndMenu();
+            }
+
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.file.save"_lang, "CTRL + S", false, providerValid && provider->isWritable())) {
                 save();
             }
 
-            if (ImGui::MenuItem("hex.view.hexeditor.menu.file.save_as"_lang, "CTRL + SHIFT + S", false, providerValid && provider->isWritable())) {
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.file.save_as"_lang, "CTRL + SHIFT + S", false, providerValid && provider->isWritable())) {
                 saveAs();
             }
 
-            if (ImGui::MenuItem("hex.view.hexeditor.menu.file.close"_lang, "", false, providerValid && provider->isAvailable())) {
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.file.close"_lang, "", false, providerValid)) {
                 EventManager::post<EventFileUnloaded>();
                 ImHexApi::Provider::remove(ImHexApi::Provider::get());
                 providerValid = false;
             }
 
-            if (ImGui::MenuItem("hex.view.hexeditor.menu.file.quit"_lang, "", false)) {
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.file.quit"_lang, "", false)) {
                 ImHexApi::Common::closeImHex();
             }
 
             ImGui::Separator();
 
-            if (ImGui::MenuItem("hex.view.hexeditor.menu.file.open_project"_lang, "")) {
-                hex::openFileBrowser("hex.view.hexeditor.menu.file.open_project"_lang, DialogMode::Open, { { "Project File", "hexproj" } }, [this](auto path) {
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.file.open_project"_lang, "")) {
+                hex::openFileBrowser("hex.builtin.view.hexeditor.menu.file.open_project"_lang, DialogMode::Open, { { "Project File", "hexproj" } }, [this](auto path) {
                     ProjectFile::load(path);
                 });
             }
 
-            if (ImGui::MenuItem("hex.view.hexeditor.menu.file.save_project"_lang, "", false, providerValid && provider->isWritable())) {
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.file.save_project"_lang, "", false, providerValid && provider->isWritable())) {
                 if (ProjectFile::getProjectFilePath() == "") {
-                    hex::openFileBrowser("hex.view.hexeditor.save_project"_lang, DialogMode::Save, { { "Project File", "hexproj" } }, [](auto path) {
+                    hex::openFileBrowser("hex.builtin.view.hexeditor.save_project"_lang, DialogMode::Save, { { "Project File", "hexproj" } }, [](auto path) {
                         if (path.ends_with(".hexproj")) {
                             ProjectFile::store(path);
                         }
@@ -498,18 +514,18 @@ namespace hex {
                     ProjectFile::store();
             }
 
-            if (ImGui::MenuItem("hex.view.hexeditor.menu.file.load_encoding_file"_lang)) {
-                hex::openFileBrowser("hex.view.hexeditor.load_enconding_file"_lang, DialogMode::Open, { }, [this](auto path) {
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.file.load_encoding_file"_lang)) {
+                hex::openFileBrowser("hex.builtin.view.hexeditor.load_enconding_file"_lang, DialogMode::Open, { }, [this](auto path) {
                     this->m_currEncodingFile = EncodingFile(EncodingFile::Type::Thingy, path);
                 });
             }
 
             ImGui::Separator();
 
-            if (ImGui::BeginMenu("hex.view.hexeditor.menu.file.import"_lang)) {
-                if (ImGui::MenuItem("hex.view.hexeditor.menu.file.import.base64"_lang)) {
+            if (ImGui::BeginMenu("hex.builtin.view.hexeditor.menu.file.import"_lang)) {
+                if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.file.import.base64"_lang)) {
 
-                    hex::openFileBrowser("hex.view.hexeditor.menu.file.import.base64"_lang, DialogMode::Open, { }, [this](auto path) {
+                    hex::openFileBrowser("hex.builtin.view.hexeditor.menu.file.import.base64"_lang, DialogMode::Open, { }, [this](auto path) {
                         std::vector<u8> base64;
                         this->loadFromFile(path, base64);
 
@@ -517,19 +533,19 @@ namespace hex {
                             this->m_dataToSave = crypt::decode64(base64);
 
                             if (this->m_dataToSave.empty())
-                                View::showErrorPopup("hex.view.hexeditor.base64.import_error"_lang);
+                                View::showErrorPopup("hex.builtin.view.hexeditor.base64.import_error"_lang);
                             else
-                                ImGui::OpenPopup("hex.view.hexeditor.save_data"_lang);
+                                ImGui::OpenPopup("hex.builtin.view.hexeditor.save_data"_lang);
                             this->getWindowOpenState() = true;
-                        } else View::showErrorPopup("hex.view.hexeditor.file_open_error"_lang);
+                        } else View::showErrorPopup("hex.builtin.view.hexeditor.file_open_error"_lang);
                     });
                 }
 
                 ImGui::Separator();
 
-                if (ImGui::MenuItem("hex.view.hexeditor.menu.file.import.ips"_lang)) {
+                if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.file.import.ips"_lang)) {
 
-                   hex::openFileBrowser("hex.view.hexeditor.open_file"_lang, DialogMode::Open, { }, [this](auto path) {
+                   hex::openFileBrowser("hex.builtin.view.hexeditor.open_file"_lang, DialogMode::Open, { }, [this](auto path) {
                         auto patchData = File(path, File::Mode::Read).readBytes();
                         auto patch = hex::loadIPSPatch(patchData);
 
@@ -543,8 +559,8 @@ namespace hex {
 
                 }
 
-                if (ImGui::MenuItem("hex.view.hexeditor.menu.file.import.ips32"_lang)) {
-                    hex::openFileBrowser("hex.view.hexeditor.open_file"_lang, DialogMode::Open, { }, [this](auto path) {
+                if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.file.import.ips32"_lang)) {
+                    hex::openFileBrowser("hex.builtin.view.hexeditor.open_file"_lang, DialogMode::Open, { }, [this](auto path) {
                         auto patchData = File(path, File::Mode::Read).readBytes();
                         auto patch = hex::loadIPS32Patch(patchData);
 
@@ -556,17 +572,17 @@ namespace hex {
                     });
                 }
 
-                if (ImGui::MenuItem("hex.view.hexeditor.menu.file.import.script"_lang)) {
+                if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.file.import.script"_lang)) {
                     this->m_loaderScriptFilePath.clear();
                     this->m_loaderScriptScriptPath.clear();
-                    View::doLater([]{ ImGui::OpenPopup("hex.view.hexeditor.script.title"_lang); });
+                    View::doLater([]{ ImGui::OpenPopup("hex.builtin.view.hexeditor.script.title"_lang); });
                 }
 
                 ImGui::EndMenu();
             }
 
-            if (ImGui::BeginMenu("hex.view.hexeditor.menu.file.export"_lang, providerValid && provider->isWritable())) {
-                if (ImGui::MenuItem("hex.view.hexeditor.menu.file.export.ips"_lang)) {
+            if (ImGui::BeginMenu("hex.builtin.view.hexeditor.menu.file.export"_lang, providerValid && provider->isWritable())) {
+                if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.file.export.ips"_lang)) {
                     Patches patches = provider->getPatches();
                     if (!patches.contains(0x00454F45) && patches.contains(0x00454F46)) {
                         u8 value = 0;
@@ -575,11 +591,11 @@ namespace hex {
                     }
 
                     this->m_dataToSave = generateIPSPatch(patches);
-                    hex::openFileBrowser("hex.view.hexeditor.menu.file.export.title"_lang, DialogMode::Save, { }, [this](auto path) {
+                    hex::openFileBrowser("hex.builtin.view.hexeditor.menu.file.export.title"_lang, DialogMode::Save, { }, [this](auto path) {
                         this->saveToFile(path, this->m_dataToSave);
                     });
                 }
-                if (ImGui::MenuItem("hex.view.hexeditor.menu.file.export.ips32"_lang)) {
+                if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.file.export.ips32"_lang)) {
                     Patches patches = provider->getPatches();
                     if (!patches.contains(0x00454F45) && patches.contains(0x45454F46)) {
                         u8 value = 0;
@@ -588,7 +604,7 @@ namespace hex {
                     }
 
                     this->m_dataToSave = generateIPS32Patch(patches);
-                    hex::openFileBrowser("hex.view.hexeditor.menu.file.export.title"_lang, DialogMode::Save, { }, [this](auto path) {
+                    hex::openFileBrowser("hex.builtin.view.hexeditor.menu.file.export.title"_lang, DialogMode::Save, { }, [this](auto path) {
                         this->saveToFile(path, this->m_dataToSave);
                     });
                 }
@@ -600,14 +616,14 @@ namespace hex {
 
             ImGui::Separator();
 
-            if (ImGui::MenuItem("hex.view.hexeditor.menu.file.search"_lang, "CTRL + F")) {
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.file.search"_lang, "CTRL + F")) {
                 this->getWindowOpenState() = true;
-                ImGui::OpenPopupInWindow(View::toWindowName("hex.view.hexeditor.name").c_str(), "hex.view.hexeditor.menu.file.search"_lang);
+                ImGui::OpenPopupInWindow(View::toWindowName("hex.builtin.view.hexeditor.name").c_str(), "hex.builtin.view.hexeditor.menu.file.search"_lang);
             }
 
-            if (ImGui::MenuItem("hex.view.hexeditor.menu.file.goto"_lang, "CTRL + G")) {
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.file.goto"_lang, "CTRL + G")) {
                 this->getWindowOpenState() = true;
-                ImGui::OpenPopupInWindow(View::toWindowName("hex.view.hexeditor.name").c_str(), "hex.view.hexeditor.menu.file.goto"_lang);
+                ImGui::OpenPopupInWindow(View::toWindowName("hex.builtin.view.hexeditor.name").c_str(), "hex.builtin.view.hexeditor.menu.file.goto"_lang);
             }
 
             ImGui::EndMenu();
@@ -629,7 +645,7 @@ namespace hex {
         }
 
         ON_SCOPE_EXIT { ImGui::End(); };
-        if (ImGui::Begin(View::toWindowName("hex.view.hexeditor.name").c_str())) {
+        if (ImGui::Begin(View::toWindowName("hex.builtin.view.hexeditor.name").c_str())) {
 
             if (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows)) {
                 if (ctrl && keys['Z']) {
@@ -640,13 +656,13 @@ namespace hex {
                     if (ImHexApi::Provider::isValid())
                         ImHexApi::Provider::get()->redo();
                 } else if (ctrl && keys['F']) {
-                    ImGui::OpenPopupInWindow(View::toWindowName("hex.view.hexeditor.name").c_str(), "hex.view.hexeditor.menu.file.search"_lang);
+                    ImGui::OpenPopupInWindow(View::toWindowName("hex.builtin.view.hexeditor.name").c_str(), "hex.builtin.view.hexeditor.menu.file.search"_lang);
                     return true;
                 } else if (ctrl && keys['G']) {
-                    ImGui::OpenPopupInWindow(View::toWindowName("hex.view.hexeditor.name").c_str(), "hex.view.hexeditor.menu.file.goto"_lang);
+                    ImGui::OpenPopupInWindow(View::toWindowName("hex.builtin.view.hexeditor.name").c_str(), "hex.builtin.view.hexeditor.menu.file.goto"_lang);
                     return true;
                 } else if (ctrl && keys['O']) {
-                    hex::openFileBrowser("hex.view.hexeditor.open_file"_lang, DialogMode::Open, { }, [](auto path) {
+                    hex::openFileBrowser("hex.builtin.view.hexeditor.open_file"_lang, DialogMode::Open, { }, [](auto path) {
                         EventManager::post<RequestOpenFile>(path);
                     });
                     return true;
@@ -705,18 +721,28 @@ namespace hex {
     }
 
     void ViewHexEditor::openFile(const std::string &path) {
-        ImHexApi::Provider::add<prv::FileProvider>(path);
-        auto provider = ImHexApi::Provider::get();
+        hex::prv::Provider *provider = nullptr;
+        EventManager::post<RequestCreateProvider>("hex.builtin.provider.file", &provider);
+
+        if (auto fileProvider = dynamic_cast<prv::FileProvider*>(provider)) {
+            fileProvider->setPath(path);
+            if (!fileProvider->open()) {
+                View::showErrorPopup("hex.builtin.view.hexeditor.error.open"_lang);
+                ImHexApi::Provider::remove(provider);
+
+                return;
+            }
+        }
 
         if (!provider->isWritable()) {
             this->m_memoryEditor.ReadOnly = true;
-            View::showErrorPopup("hex.view.hexeditor.error.read_only"_lang);
+            View::showErrorPopup("hex.builtin.view.hexeditor.error.read_only"_lang);
         } else {
             this->m_memoryEditor.ReadOnly = false;
         }
 
         if (!provider->isAvailable()) {
-            View::showErrorPopup("hex.view.hexeditor.error.open"_lang);
+            View::showErrorPopup("hex.builtin.view.hexeditor.error.open"_lang);
             ImHexApi::Provider::remove(provider);
 
             return;
@@ -752,7 +778,7 @@ namespace hex {
         size_t copySize = (end - start) + 1;
 
         std::vector<u8> buffer(copySize, 0x00);
-        provider->readRelative(start, buffer.data(), buffer.size());
+        provider->read(start + provider->getBaseAddress() + provider->getCurrentPageAddress(), buffer.data(), buffer.size());
 
         std::string str;
         for (const auto &byte : buffer)
@@ -801,7 +827,7 @@ namespace hex {
         }
 
         // Write bytes
-        provider->writeRelative(start, buffer.data(), std::min(end - start + 1, buffer.size()));
+        provider->read(start + provider->getBaseAddress() + provider->getCurrentPageAddress(), buffer.data(), std::min(end - start + 1, buffer.size()));
     }
 
     void ViewHexEditor::copyString() const {
@@ -814,7 +840,7 @@ namespace hex {
 
         std::string buffer(copySize, 0x00);
         buffer.reserve(copySize + 1);
-        provider->readRelative(start, buffer.data(), copySize);
+        provider->read(start + provider->getBaseAddress() + provider->getCurrentPageAddress(), buffer.data(), copySize);
 
         ImGui::SetClipboardText(buffer.c_str());
     }
@@ -828,7 +854,7 @@ namespace hex {
         size_t copySize = (end - start) + 1;
 
         std::vector<u8> buffer(copySize, 0x00);
-        provider->readRelative(start, buffer.data(), buffer.size());
+        provider->read(start + provider->getBaseAddress() + provider->getCurrentPageAddress(), buffer.data(), buffer.size());
 
         std::string str;
         switch (language) {
@@ -930,7 +956,7 @@ namespace hex {
         size_t copySize = (end - start) + 1;
 
         std::vector<u8> buffer(copySize, 0x00);
-        provider->readRelative(start, buffer.data(), buffer.size());
+        provider->read(start + provider->getBaseAddress() + provider->getCurrentPageAddress(), buffer.data(), buffer.size());
 
         std::string str = "Hex View  00 01 02 03 04 05 06 07  08 09 0A 0B 0C 0D 0E 0F\n\n";
 
@@ -977,7 +1003,7 @@ namespace hex {
         size_t copySize = (end - start) + 1;
 
         std::vector<u8> buffer(copySize, 0x00);
-        provider->readRelative(start, buffer.data(), buffer.size());
+        provider->read(start + provider->getBaseAddress() + provider->getCurrentPageAddress(), buffer.data(), buffer.size());
 
         std::string str =
 R"(
@@ -1033,7 +1059,7 @@ R"(
         ImGui::SetClipboardText(str.c_str());
     }
 
-    static std::vector<std::pair<u64, u64>> findString(prv::Provider* &provider, std::string string) {
+    static std::vector<std::pair<u64, u64>> findString(hex::prv::Provider* &provider, std::string string) {
         std::vector<std::pair<u64, u64>> results;
 
         u32 foundCharacters = 0;
@@ -1042,7 +1068,7 @@ R"(
         size_t dataSize = provider->getSize();
         for (u64 offset = 0; offset < dataSize; offset += 1024) {
             size_t usedBufferSize = std::min(u64(buffer.size()), dataSize - offset);
-            provider->readRelative(offset, buffer.data(), usedBufferSize);
+            provider->read(offset + provider->getBaseAddress() + provider->getCurrentPageAddress(), buffer.data(), usedBufferSize);
 
             for (u64 i = 0; i < usedBufferSize; i++) {
                 if (buffer[i] == string[foundCharacters])
@@ -1060,7 +1086,7 @@ R"(
         return results;
     }
 
-    static std::vector<std::pair<u64, u64>> findHex(prv::Provider* &provider, std::string string) {
+    static std::vector<std::pair<u64, u64>> findHex(hex::prv::Provider* &provider, std::string string) {
         std::vector<std::pair<u64, u64>> results;
 
         if ((string.size() % 2) == 1)
@@ -1080,7 +1106,7 @@ R"(
         size_t dataSize = provider->getSize();
         for (u64 offset = 0; offset < dataSize; offset += 1024) {
             size_t usedBufferSize = std::min(u64(buffer.size()), dataSize - offset);
-            provider->readRelative(offset, buffer.data(), usedBufferSize);
+            provider->read(offset + provider->getBaseAddress() + provider->getCurrentPageAddress(), buffer.data(), usedBufferSize);
 
             for (u64 i = 0; i < usedBufferSize; i++) {
                 if (buffer[i] == hex[foundCharacters])
@@ -1147,10 +1173,10 @@ R"(
 
 
         ImGui::SetNextWindowPos(ImGui::GetWindowPos() + ImGui::GetWindowContentRegionMin() - ImGui::GetStyle().WindowPadding);
-        if (ImGui::BeginPopup("hex.view.hexeditor.menu.file.search"_lang)) {
+        if (ImGui::BeginPopup("hex.builtin.view.hexeditor.menu.file.search"_lang)) {
             if (ImGui::BeginTabBar("searchTabs")) {
                 std::vector<char> *currBuffer = nullptr;
-                if (ImGui::BeginTabItem("hex.view.hexeditor.search.string"_lang)) {
+                if (ImGui::BeginTabItem("hex.builtin.view.hexeditor.search.string"_lang)) {
                     this->m_searchFunction = findString;
                     this->m_lastSearchBuffer = &this->m_lastStringSearch;
                     currBuffer = &this->m_searchStringBuffer;
@@ -1160,7 +1186,7 @@ R"(
                     ImGui::EndTabItem();
                 }
 
-                if (ImGui::BeginTabItem("hex.view.hexeditor.search.hex"_lang)) {
+                if (ImGui::BeginTabItem("hex.builtin.view.hexeditor.search.hex"_lang)) {
                     this->m_searchFunction = findHex;
                     this->m_lastSearchBuffer = &this->m_lastHexSearch;
                     currBuffer = &this->m_searchHexBuffer;
@@ -1172,16 +1198,16 @@ R"(
                 }
 
                 if (currBuffer != nullptr) {
-                    if (ImGui::Button("hex.view.hexeditor.search.find"_lang))
+                    if (ImGui::Button("hex.builtin.view.hexeditor.search.find"_lang))
                         Find(currBuffer->data());
 
                     if (!this->m_lastSearchBuffer->empty()) {
-                        if ((ImGui::Button("hex.view.hexeditor.search.find_next"_lang)))
+                        if ((ImGui::Button("hex.builtin.view.hexeditor.search.find_next"_lang)))
                             FindNext();
 
                         ImGui::SameLine();
 
-                        if ((ImGui::Button("hex.view.hexeditor.search.find_prev"_lang)))
+                        if ((ImGui::Button("hex.builtin.view.hexeditor.search.find_prev"_lang)))
                             FindPrevious();
                     }
                 }
@@ -1199,10 +1225,10 @@ R"(
         auto dataSize = provider->getActualSize();
 
         ImGui::SetNextWindowPos(ImGui::GetWindowPos() + ImGui::GetWindowContentRegionMin() - ImGui::GetStyle().WindowPadding);
-        if (ImGui::BeginPopup("hex.view.hexeditor.menu.file.goto"_lang)) {
+        if (ImGui::BeginPopup("hex.builtin.view.hexeditor.menu.file.goto"_lang)) {
             if (ImGui::BeginTabBar("gotoTabs")) {
                 u64 newOffset = 0;
-                if (ImGui::BeginTabItem("hex.view.hexeditor.goto.offset.absolute"_lang)) {
+                if (ImGui::BeginTabItem("hex.builtin.view.hexeditor.goto.offset.absolute"_lang)) {
                     ImGui::InputScalar("hex", ImGuiDataType_U64, &this->m_gotoAddress, nullptr, nullptr, "%llx", ImGuiInputTextFlags_CharsHexadecimal);
 
                     if (this->m_gotoAddress < baseAddress || this->m_gotoAddress > baseAddress + dataSize)
@@ -1212,7 +1238,7 @@ R"(
 
                     ImGui::EndTabItem();
                 }
-                if (ImGui::BeginTabItem("hex.view.hexeditor.goto.offset.begin"_lang)) {
+                if (ImGui::BeginTabItem("hex.builtin.view.hexeditor.goto.offset.begin"_lang)) {
                     ImGui::InputScalar("hex", ImGuiDataType_U64, &this->m_gotoAddress, nullptr, nullptr, "%llx", ImGuiInputTextFlags_CharsHexadecimal);
 
                     if (this->m_gotoAddress < 0 || this->m_gotoAddress > dataSize)
@@ -1222,7 +1248,7 @@ R"(
 
                     ImGui::EndTabItem();
                 }
-                if (ImGui::BeginTabItem("hex.view.hexeditor.goto.offset.current"_lang)) {
+                if (ImGui::BeginTabItem("hex.builtin.view.hexeditor.goto.offset.current"_lang)) {
                     ImGui::InputScalar("dec", ImGuiDataType_S64, &this->m_gotoAddress, nullptr, nullptr, "%lld", ImGuiInputTextFlags_CharsDecimal);
 
                     s64 currSelectionOffset = std::min(this->m_memoryEditor.DataPreviewAddr, this->m_memoryEditor.DataPreviewAddrEnd);
@@ -1236,7 +1262,7 @@ R"(
 
                     ImGui::EndTabItem();
                 }
-                if (ImGui::BeginTabItem("hex.view.hexeditor.goto.offset.end"_lang)) {
+                if (ImGui::BeginTabItem("hex.builtin.view.hexeditor.goto.offset.end"_lang)) {
                     ImGui::InputScalar("hex", ImGuiDataType_U64, &this->m_gotoAddress, nullptr, nullptr, "%llx", ImGuiInputTextFlags_CharsHexadecimal);
 
                     if (this->m_gotoAddress < 0 || this->m_gotoAddress > dataSize)
@@ -1247,8 +1273,8 @@ R"(
                     ImGui::EndTabItem();
                 }
 
-                if (ImGui::Button("hex.view.hexeditor.menu.file.goto"_lang)) {
-                    provider->setCurrentPage(std::floor(double(newOffset - baseAddress) / prv::Provider::PageSize));
+                if (ImGui::Button("hex.builtin.view.hexeditor.menu.file.goto"_lang)) {
+                    provider->setCurrentPage(std::floor(double(newOffset - baseAddress) / hex::prv::Provider::PageSize));
                     EventManager::post<RequestSelectionChange>(Region { newOffset, 1 });
                 }
 
@@ -1262,58 +1288,58 @@ R"(
     void ViewHexEditor::drawEditPopup() {
         auto provider = ImHexApi::Provider::get();
         bool providerValid = ImHexApi::Provider::isValid();
-        if (ImGui::MenuItem("hex.view.hexeditor.menu.edit.undo"_lang, "CTRL + Z", false, providerValid))
+        if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.edit.undo"_lang, "CTRL + Z", false, providerValid))
             provider->undo();
-        if (ImGui::MenuItem("hex.view.hexeditor.menu.edit.redo"_lang, "CTRL + Y", false, providerValid))
+        if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.edit.redo"_lang, "CTRL + Y", false, providerValid))
             provider->redo();
 
         ImGui::Separator();
 
         bool bytesSelected = this->m_memoryEditor.DataPreviewAddr != -1 && this->m_memoryEditor.DataPreviewAddrEnd != -1;
 
-        if (ImGui::MenuItem("hex.view.hexeditor.menu.edit.copy"_lang, "CTRL + C", false, bytesSelected))
+        if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.edit.copy"_lang, "CTRL + C", false, bytesSelected))
             this->copyBytes();
 
-        if (ImGui::BeginMenu("hex.view.hexeditor.menu.edit.copy_as"_lang, bytesSelected)) {
-            if (ImGui::MenuItem("hex.view.hexeditor.copy.hex"_lang, "CTRL + SHIFT + C"))
+        if (ImGui::BeginMenu("hex.builtin.view.hexeditor.menu.edit.copy_as"_lang, bytesSelected)) {
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.copy.hex"_lang, "CTRL + SHIFT + C"))
                 this->copyString();
 
             ImGui::Separator();
 
-            if (ImGui::MenuItem("hex.view.hexeditor.copy.c"_lang))
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.copy.c"_lang))
                 this->copyLanguageArray(Language::C);
-            if (ImGui::MenuItem("hex.view.hexeditor.copy.cpp"_lang))
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.copy.cpp"_lang))
                 this->copyLanguageArray(Language::Cpp);
-            if (ImGui::MenuItem("hex.view.hexeditor.copy.csharp"_lang))
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.copy.csharp"_lang))
                 this->copyLanguageArray(Language::CSharp);
-            if (ImGui::MenuItem("hex.view.hexeditor.copy.rust"_lang))
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.copy.rust"_lang))
                 this->copyLanguageArray(Language::Rust);
-            if (ImGui::MenuItem("hex.view.hexeditor.copy.python"_lang))
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.copy.python"_lang))
                 this->copyLanguageArray(Language::Python);
-            if (ImGui::MenuItem("hex.view.hexeditor.copy.java"_lang))
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.copy.java"_lang))
                 this->copyLanguageArray(Language::Java);
-            if (ImGui::MenuItem("hex.view.hexeditor.copy.js"_lang))
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.copy.js"_lang))
                 this->copyLanguageArray(Language::JavaScript);
 
             ImGui::Separator();
 
-            if (ImGui::MenuItem("hex.view.hexeditor.copy.ascii"_lang))
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.copy.ascii"_lang))
                 this->copyHexView();
-            if (ImGui::MenuItem("hex.view.hexeditor.copy.html"_lang))
+            if (ImGui::MenuItem("hex.builtin.view.hexeditor.copy.html"_lang))
                 this->copyHexViewHTML();
 
             ImGui::EndMenu();
         }
 
-        if (ImGui::MenuItem("hex.view.hexeditor.menu.edit.paste"_lang, "CTRL + V", false, bytesSelected))
+        if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.edit.paste"_lang, "CTRL + V", false, bytesSelected))
             this->pasteBytes();
 
-        if (ImGui::MenuItem("hex.view.hexeditor.menu.edit.select_all"_lang, "CTRL + A", false, providerValid))
+        if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.edit.select_all"_lang, "CTRL + A", false, providerValid))
             EventManager::post<RequestSelectionChange>(Region { provider->getBaseAddress(), provider->getActualSize() });
 
         ImGui::Separator();
 
-        if (ImGui::MenuItem("hex.view.hexeditor.menu.edit.bookmark"_lang, nullptr, false, this->m_memoryEditor.DataPreviewAddr != -1 && this->m_memoryEditor.DataPreviewAddrEnd != -1)) {
+        if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.edit.bookmark"_lang, nullptr, false, this->m_memoryEditor.DataPreviewAddr != -1 && this->m_memoryEditor.DataPreviewAddrEnd != -1)) {
             auto base = ImHexApi::Provider::get()->getBaseAddress();
 
             size_t start = base + std::min(this->m_memoryEditor.DataPreviewAddr, this->m_memoryEditor.DataPreviewAddrEnd);
@@ -1322,15 +1348,15 @@ R"(
             ImHexApi::Bookmarks::add(start, end - start + 1, { }, { });
         }
 
-        if (ImGui::MenuItem("hex.view.hexeditor.menu.edit.set_base"_lang, nullptr, false, providerValid && provider->isReadable())) {
+        if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.edit.set_base"_lang, nullptr, false, providerValid && provider->isReadable())) {
             std::memset(this->m_baseAddressBuffer, 0x00, sizeof(this->m_baseAddressBuffer));
-            View::doLater([]{ ImGui::OpenPopup("hex.view.hexeditor.menu.edit.set_base"_lang); });
+            View::doLater([]{ ImGui::OpenPopup("hex.builtin.view.hexeditor.menu.edit.set_base"_lang); });
         }
 
-        if (ImGui::MenuItem("hex.view.hexeditor.menu.edit.resize"_lang, nullptr, false, providerValid && provider->isResizable())) {
+        if (ImGui::MenuItem("hex.builtin.view.hexeditor.menu.edit.resize"_lang, nullptr, false, providerValid && provider->isResizable())) {
             View::doLater([this]{
                 this->m_resizeSize = ImHexApi::Provider::get()->getActualSize();
-                ImGui::OpenPopup("hex.view.hexeditor.menu.edit.resize"_lang);
+                ImGui::OpenPopup("hex.builtin.view.hexeditor.menu.edit.resize"_lang);
             });
         }
     }

plugins/builtin/source/content/views/view_information.cpp

@@ -1,4 +1,4 @@
-#include "views/view_information.hpp"
+#include "content/views/view_information.hpp"
 
 #include <hex/providers/provider.hpp>
 #include <hex/helpers/paths.hpp>
@@ -18,11 +18,11 @@
 #include <imgui_imhex_extensions.h>
 #include <implot.h>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     using namespace hex::literals;
 
-    ViewInformation::ViewInformation() : View("hex.view.information.name") {
+    ViewInformation::ViewInformation() : View("hex.builtin.view.information.name") {
         EventManager::subscribe<EventDataChanged>(this, [this]() {
             this->m_dataValid = false;
             this->m_highestBlockEntropy = 0;
@@ -39,30 +39,30 @@ namespace hex {
             if (this->m_blockSize != 0)
                 this->m_entropyHandlePosition = region.address / this->m_blockSize;
         });
+
+        EventManager::subscribe<EventFileUnloaded>(this, [this]{
+            this->m_dataValid = false;
+        });
     }
 
     ViewInformation::~ViewInformation() {
         EventManager::unsubscribe<EventDataChanged>(this);
         EventManager::unsubscribe<EventRegionSelected>(this);
+        EventManager::unsubscribe<EventFileUnloaded>(this);
     }
 
-    static float calculateEntropy(std::array<ImU64, 256> &valueCounts, size_t numBytes) {
+    static float calculateEntropy(std::array<ImU64, 256> &valueCounts, size_t blockSize) {
         float entropy = 0;
 
-        if (numBytes == 0)
-            return 0.0F;
+        for (auto count : valueCounts) {
+            if (count == 0) continue;
 
-        std::array<float, 256> floatValueCounts{ 0 };
-        std::copy(valueCounts.begin(), valueCounts.end(), floatValueCounts.begin());
+            float probability = static_cast<float>(count) / blockSize;
 
-        for (u16 i = 0; i < 256; i++) {
-            floatValueCounts[i] /= float(numBytes);
-
-            if (floatValueCounts[i] > 0)
-                entropy -= (floatValueCounts[i] * std::log2(floatValueCounts[i]));
+            entropy += probability * std::log2(probability);
         }
 
-        return entropy / 8;
+        return (-entropy) / 8; // log2(256) = 8
     }
 
     void ViewInformation::analyze() {
@@ -82,13 +82,16 @@ namespace hex {
 
                 for (u64 i = 0; i < provider->getSize(); i += this->m_blockSize) {
                     std::array<ImU64, 256> blockValueCounts = { 0 };
-                    provider->readRelative(i, buffer.data(), std::min(u64(this->m_blockSize), provider->getSize() - i));
+                    provider->read(i + provider->getBaseAddress(), buffer.data(), std::min(u64(this->m_blockSize), provider->getSize() - i));
 
                     for (size_t j = 0; j < this->m_blockSize; j++) {
                         blockValueCounts[buffer[j]]++;
                         this->m_valueCounts[buffer[j]]++;
                     }
+
                     this->m_blockEntropy.push_back(calculateEntropy(blockValueCounts, this->m_blockSize));
+
+                    this->m_bytesAnalyzed = i;
                 }
 
                 this->m_averageEntropy = calculateEntropy(this->m_valueCounts, provider->getSize());
@@ -108,64 +111,67 @@ namespace hex {
     }
 
     void ViewInformation::drawContent() {
-        if (ImGui::Begin(View::toWindowName("hex.view.information.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
+        if (ImGui::Begin(View::toWindowName("hex.builtin.view.information.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
             if (ImGui::BeginChild("##scrolling", ImVec2(0, 0), false, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoNav)) {
 
 
                 auto provider = ImHexApi::Provider::get();
                 if (ImHexApi::Provider::isValid() && provider->isReadable()) {
-                    ImGui::TextUnformatted("hex.view.information.control"_lang);
+                    ImGui::TextUnformatted("hex.builtin.view.information.control"_lang);
                     ImGui::Separator();
 
                     ImGui::Disabled([this] {
-                        if (ImGui::Button("hex.view.information.analyze"_lang))
+                        if (ImGui::Button("hex.builtin.view.information.analyze"_lang))
                             this->analyze();
                     }, this->m_analyzing);
 
                     if (this->m_analyzing) {
-                        ImGui::SameLine();
-                        ImGui::TextSpinner("hex.view.information.analyzing"_lang);
+                        ImGui::TextSpinner("hex.builtin.view.information.analyzing"_lang);
+                        ImGui::ProgressBar(this->m_bytesAnalyzed / static_cast<double>(provider->getSize()));
+                    } else {
+                        ImGui::NewLine();
+                        ImGui::NewLine();
+                    }
+
+                    ImGui::NewLine();
+                    ImGui::TextUnformatted("hex.builtin.view.information.region"_lang);
+                    ImGui::Separator();
+
+                    for (auto &[name, value] : provider->getDataInformation()) {
+                        ImGui::LabelText(name.c_str(), "%s", value.c_str());
                     }
 
                     if (this->m_dataValid) {
 
-                        ImGui::NewLine();
-                        ImGui::TextUnformatted("hex.view.information.region"_lang);
-                        ImGui::Separator();
-
-                        for (auto &[name, value] : provider->getDataInformation()) {
-                            ImGui::LabelText(name.c_str(), "%s", value.c_str());
-                        }
-
-                        ImGui::LabelText("hex.view.information.region"_lang, "0x%llx - 0x%llx", this->m_analyzedRegion.first, this->m_analyzedRegion.second);
+                        ImGui::LabelText("hex.builtin.view.information.region"_lang, "0x%llx - 0x%llx", this->m_analyzedRegion.first, this->m_analyzedRegion.second);
 
                         ImGui::NewLine();
 
                         if (!this->m_fileDescription.empty() || !this->m_mimeType.empty()) {
-                            ImGui::TextUnformatted("hex.view.information.magic"_lang);
+                            ImGui::TextUnformatted("hex.builtin.view.information.magic"_lang);
                             ImGui::Separator();
                         }
 
                         if (!this->m_fileDescription.empty()) {
-                            ImGui::TextUnformatted("hex.view.information.description"_lang);
+                            ImGui::TextUnformatted("hex.builtin.view.information.description"_lang);
                             ImGui::TextWrapped("%s", this->m_fileDescription.c_str());
                             ImGui::NewLine();
                         }
 
                         if (!this->m_mimeType.empty()) {
-                            ImGui::TextUnformatted("hex.view.information.mime"_lang);
+                            ImGui::TextUnformatted("hex.builtin.view.information.mime"_lang);
                             ImGui::TextWrapped("%s", this->m_mimeType.c_str());
                             ImGui::NewLine();
                         }
 
-                        ImGui::TextUnformatted("hex.view.information.info_analysis"_lang);
+                        ImGui::TextUnformatted("hex.builtin.view.information.info_analysis"_lang);
                         ImGui::Separator();
 
                         ImGui::PushStyleColor(ImGuiCol_FrameBg, ImGui::GetColorU32(ImGuiCol_WindowBg));
 
-                        ImGui::TextUnformatted("hex.view.information.distribution"_lang);
-                        ImPlot::SetNextPlotLimits(0, 256, 0, float(*std::max_element(this->m_valueCounts.begin(), this->m_valueCounts.end())) * 1.1F, ImGuiCond_Always);
-                        if (ImPlot::BeginPlot("##distribution", "Address", "Count", ImVec2(-1,0), ImPlotFlags_NoLegend | ImPlotFlags_NoMenus | ImPlotFlags_NoBoxSelect, ImPlotAxisFlags_Lock, ImPlotAxisFlags_Lock))  {
+                        ImGui::TextUnformatted("hex.builtin.view.information.distribution"_lang);
+                        ImPlot::SetNextPlotLimits(0, 256, 0.5, float(*std::max_element(this->m_valueCounts.begin(), this->m_valueCounts.end())) * 1.1F, ImGuiCond_Always);
+                        if (ImPlot::BeginPlot("##distribution", "Address", "Count", ImVec2(-1,0), ImPlotFlags_NoLegend | ImPlotFlags_NoMenus | ImPlotFlags_NoBoxSelect, ImPlotAxisFlags_Lock, ImPlotAxisFlags_Lock | ImPlotAxisFlags_LogScale))  {
                             static auto x = []{
                                 std::array<ImU64, 256> result{ 0 };
                                 std::iota(result.begin(), result.end(), 0);
@@ -180,10 +186,10 @@ namespace hex {
 
                         ImGui::NewLine();
 
-                        ImGui::TextUnformatted("hex.view.information.entropy"_lang);
+                        ImGui::TextUnformatted("hex.builtin.view.information.entropy"_lang);
 
                         ImPlot::SetNextPlotLimits(0, this->m_blockEntropy.size(), -0.1, 1.1, ImGuiCond_Always);
-                        if (ImPlot::BeginPlot("##entropy", "Address", "Entropy", ImVec2(-1,0), ImPlotFlags_CanvasOnly, ImPlotAxisFlags_Lock | ImPlotAxisFlags_NoTickLabels, ImPlotAxisFlags_Lock)) {
+                        if (ImPlot::BeginPlot("##entropy", "Address", "Entropy", ImVec2(-1,0), ImPlotFlags_CanvasOnly | ImPlotFlags_AntiAliased, ImPlotAxisFlags_Lock | ImPlotAxisFlags_NoTickLabels, ImPlotAxisFlags_Lock)) {
                             ImPlot::PlotLine("##entropy_line", this->m_blockEntropy.data(), this->m_blockEntropy.size());
 
                             if (ImPlot::DragLineX("Position", &this->m_entropyHandlePosition, false)) {
@@ -199,13 +205,13 @@ namespace hex {
 
                         ImGui::NewLine();
 
-                        ImGui::LabelText("hex.view.information.block_size"_lang, "%s", hex::format("hex.view.information.block_size.desc"_lang, this->m_blockEntropy.size(), this->m_blockSize).c_str());
-                        ImGui::LabelText("hex.view.information.file_entropy"_lang, "%.8f", this->m_averageEntropy);
-                        ImGui::LabelText("hex.view.information.highest_entropy"_lang, "%.8f", this->m_highestBlockEntropy);
+                        ImGui::LabelText("hex.builtin.view.information.block_size"_lang, "%s", hex::format("hex.builtin.view.information.block_size.desc"_lang, this->m_blockEntropy.size(), this->m_blockSize).c_str());
+                        ImGui::LabelText("hex.builtin.view.information.file_entropy"_lang, "%.8f", this->m_averageEntropy);
+                        ImGui::LabelText("hex.builtin.view.information.highest_entropy"_lang, "%.8f", this->m_highestBlockEntropy);
 
                         if (this->m_averageEntropy > 0.83 && this->m_highestBlockEntropy > 0.9) {
                             ImGui::NewLine();
-                            ImGui::TextColored(ImVec4(0.92F, 0.25F, 0.2F, 1.0F), "%s", static_cast<const char*>("hex.view.information.encrypted"_lang));
+                            ImGui::TextColored(ImVec4(0.92F, 0.25F, 0.2F, 1.0F), "%s", static_cast<const char*>("hex.builtin.view.information.encrypted"_lang));
                         }
 
                     }

plugins/builtin/source/content/views/view_patches.cpp

@@ -1,16 +1,16 @@
-#include "views/view_patches.hpp"
+#include "content/views/view_patches.hpp"
 
 #include <hex/providers/provider.hpp>
 
-#include "helpers/project_file_handler.hpp"
+#include <hex/helpers/project_file_handler.hpp>
 
 #include <string>
 
 using namespace std::literals::string_literals;
 
-namespace hex {
+namespace hex::plugin::builtin {
 
-    ViewPatches::ViewPatches() : View("hex.view.patches.name") {
+    ViewPatches::ViewPatches() : View("hex.builtin.view.patches.name") {
         EventManager::subscribe<EventProjectFileStore>(this, []{
             auto provider = ImHexApi::Provider::get();
             if (ImHexApi::Provider::isValid())
@@ -30,7 +30,7 @@ namespace hex {
     }
 
     void ViewPatches::drawContent() {
-        if (ImGui::Begin(View::toWindowName("hex.view.patches.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
+        if (ImGui::Begin(View::toWindowName("hex.builtin.view.patches.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
             auto provider = ImHexApi::Provider::get();
 
             if (ImHexApi::Provider::isValid() && provider->isReadable()) {
@@ -38,9 +38,9 @@ namespace hex {
                 if (ImGui::BeginTable("##patchesTable", 3, ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable | ImGuiTableFlags_Sortable |
                                                         ImGuiTableFlags_Reorderable | ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY)) {
                     ImGui::TableSetupScrollFreeze(0, 1);
-                    ImGui::TableSetupColumn("hex.view.patches.offset"_lang);
-                    ImGui::TableSetupColumn("hex.view.patches.orig"_lang);
-                    ImGui::TableSetupColumn("hex.view.patches.patch"_lang);
+                    ImGui::TableSetupColumn("hex.builtin.view.patches.offset"_lang);
+                    ImGui::TableSetupColumn("hex.builtin.view.patches.orig"_lang);
+                    ImGui::TableSetupColumn("hex.builtin.view.patches.patch"_lang);
 
                     ImGui::TableHeadersRow();
 
@@ -71,7 +71,7 @@ namespace hex {
                     }
 
                     if (ImGui::BeginPopup("PatchContextMenu")) {
-                        if (ImGui::MenuItem("hex.view.patches.remove"_lang)) {
+                        if (ImGui::MenuItem("hex.builtin.view.patches.remove"_lang)) {
                             patches.erase(this->m_selectedPatch);
                             ProjectFile::markDirty();
                         }

plugins/builtin/source/content/views/view_pattern_data.cpp

@@ -1,11 +1,11 @@
-#include "views/view_pattern_data.hpp"
+#include "content/views/view_pattern_data.hpp"
 
 #include <hex/providers/provider.hpp>
 #include <hex/pattern_language/pattern_data.hpp>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
-    ViewPatternData::ViewPatternData() : View("hex.view.pattern_data.name") {
+    ViewPatternData::ViewPatternData() : View("hex.builtin.view.pattern_data.name") {
 
         EventManager::subscribe<EventPatternChanged>(this, [this]() {
             this->m_sortedPatternData.clear();
@@ -19,12 +19,12 @@ namespace hex {
     static bool beginPatternDataTable(prv::Provider* &provider, const std::vector<pl::PatternData*> &patterns, std::vector<pl::PatternData*> &sortedPatterns) {
         if (ImGui::BeginTable("##patterndatatable", 6, ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable | ImGuiTableFlags_Sortable | ImGuiTableFlags_Reorderable | ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY)) {
             ImGui::TableSetupScrollFreeze(0, 1);
-            ImGui::TableSetupColumn("hex.view.pattern_data.var_name"_lang, 0, -1, ImGui::GetID("name"));
-            ImGui::TableSetupColumn("hex.view.pattern_data.color"_lang, 0, -1, ImGui::GetID("color"));
-            ImGui::TableSetupColumn("hex.view.pattern_data.offset"_lang, 0, -1, ImGui::GetID("offset"));
-            ImGui::TableSetupColumn("hex.view.pattern_data.size"_lang, 0, -1, ImGui::GetID("size"));
-            ImGui::TableSetupColumn("hex.view.pattern_data.type"_lang, 0, -1, ImGui::GetID("type"));
-            ImGui::TableSetupColumn("hex.view.pattern_data.value"_lang, 0, -1, ImGui::GetID("value"));
+            ImGui::TableSetupColumn("hex.builtin.view.pattern_data.var_name"_lang, 0, -1, ImGui::GetID("name"));
+            ImGui::TableSetupColumn("hex.builtin.view.pattern_data.color"_lang, 0, -1, ImGui::GetID("color"));
+            ImGui::TableSetupColumn("hex.builtin.view.pattern_data.offset"_lang, 0, -1, ImGui::GetID("offset"));
+            ImGui::TableSetupColumn("hex.builtin.view.pattern_data.size"_lang, 0, -1, ImGui::GetID("size"));
+            ImGui::TableSetupColumn("hex.builtin.view.pattern_data.type"_lang, 0, -1, ImGui::GetID("type"));
+            ImGui::TableSetupColumn("hex.builtin.view.pattern_data.value"_lang, 0, -1, ImGui::GetID("value"));
 
             auto sortSpecs = ImGui::TableGetSortSpecs();
 
@@ -48,7 +48,7 @@ namespace hex {
     }
 
     void ViewPatternData::drawContent() {
-        if (ImGui::Begin(View::toWindowName("hex.view.pattern_data.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
+        if (ImGui::Begin(View::toWindowName("hex.builtin.view.pattern_data.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
             auto provider = ImHexApi::Provider::get();
             if (ImHexApi::Provider::isValid() && provider->isReadable()) {
 

plugins/builtin/source/content/views/view_pattern_editor.cpp

@@ -1,6 +1,6 @@
-#include "views/view_pattern_editor.hpp"
+#include "content/views/view_pattern_editor.hpp"
 
-#include "helpers/project_file_handler.hpp"
+#include <hex/helpers/project_file_handler.hpp>
 #include <hex/pattern_language/preprocessor.hpp>
 #include <hex/pattern_language/pattern_data.hpp>
 #include <hex/helpers/paths.hpp>
@@ -14,7 +14,7 @@
 
 #include <nlohmann/json.hpp>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     using namespace hex::literals;
     namespace fs = std::filesystem;
@@ -82,12 +82,14 @@ namespace hex {
     }
 
 
-    ViewPatternEditor::ViewPatternEditor() : View("hex.view.pattern.name") {
+    ViewPatternEditor::ViewPatternEditor() : View("hex.builtin.view.pattern_editor.name") {
         this->m_patternLanguageRuntime = new pl::PatternLanguage();
 
         this->m_textEditor.SetLanguageDefinition(PatternLanguage());
         this->m_textEditor.SetShowWhitespaces(false);
 
+        this->m_envVarEntries = { { "", s128(0), EnvVarType::Integer } };
+
         EventManager::subscribe<EventProjectFileStore>(this, [this]() {
             ProjectFile::setPattern(this->m_textEditor.GetText());
         });
@@ -147,11 +149,16 @@ namespace hex {
 
             if (!this->m_possiblePatternFiles.empty()) {
                 this->m_selectedPatternFile = 0;
-                EventManager::post<RequestOpenPopup>("hex.view.pattern.accept_pattern"_lang);
+                EventManager::post<RequestOpenPopup>("hex.builtin.view.pattern_editor.accept_pattern"_lang);
                 this->m_acceptPatternWindowOpen = true;
             }
         });
 
+        EventManager::subscribe<EventFileUnloaded>(this, [this]{
+            this->m_textEditor.SetText("");
+            this->m_patternLanguageRuntime->abort();
+        });
+
         /* Settings */
         {
 
@@ -181,11 +188,15 @@ namespace hex {
         EventManager::unsubscribe<RequestSetPatternLanguageCode>(this);
         EventManager::unsubscribe<EventFileLoaded>(this);
         EventManager::unsubscribe<RequestChangeTheme>(this);
+        EventManager::unsubscribe<EventFileUnloaded>(this);
     }
 
     void ViewPatternEditor::drawMenu() {
         if (ImGui::BeginMenu("hex.menu.file"_lang)) {
-            if (ImGui::MenuItem("hex.view.pattern.menu.file.load_pattern"_lang)) {
+
+            ImGui::Separator();
+
+            if (ImGui::MenuItem("hex.builtin.view.pattern_editor.menu.file.load_pattern"_lang)) {
 
                 this->m_selectedPatternFile = 0;
                 this->m_possiblePatternFiles.clear();
@@ -200,21 +211,30 @@ namespace hex {
                     }
                 }
 
-                View::doLater([]{ ImGui::OpenPopup("hex.view.pattern.menu.file.load_pattern"_lang); });
+                View::doLater([]{ ImGui::OpenPopup("hex.builtin.view.pattern_editor.menu.file.load_pattern"_lang); });
             }
+
+            if (ImGui::MenuItem("hex.builtin.view.pattern_editor.menu.file.save_pattern"_lang)) {
+                hex::openFileBrowser("hex.builtin.view.pattern_editor.menu.file.save_pattern"_lang, DialogMode::Save, { { "Pattern", "hexpat" }}, [this](const std::string &path) {
+                    File file(path, File::Mode::Create);
+
+                    file.write(this->m_textEditor.GetText());
+                });
+            }
+
             ImGui::EndMenu();
         }
     }
 
     void ViewPatternEditor::drawContent() {
-        if (ImGui::Begin(View::toWindowName("hex.view.pattern.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_None | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse)) {
+        if (ImGui::Begin(View::toWindowName("hex.builtin.view.pattern_editor.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_None | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse)) {
             auto provider = ImHexApi::Provider::get();
 
             if (ImHexApi::Provider::isValid() && provider->isAvailable()) {
                 auto textEditorSize = ImGui::GetContentRegionAvail();
                 textEditorSize.y *= 4.0/5.0;
                 textEditorSize.y -= ImGui::GetTextLineHeightWithSpacing();
-                this->m_textEditor.Render("hex.view.pattern.name"_lang, textEditorSize, true);
+                this->m_textEditor.Render("hex.builtin.view.pattern_editor.name"_lang, textEditorSize, true);
 
                 auto consoleSize = ImGui::GetContentRegionAvail();
                 consoleSize.y -= ImGui::GetTextLineHeightWithSpacing();
@@ -262,9 +282,9 @@ namespace hex {
 
                 ImGui::SameLine();
                 if (this->m_evaluatorRunning)
-                    ImGui::TextSpinner("hex.view.pattern.evaluating"_lang);
+                    ImGui::TextSpinner("hex.builtin.view.pattern_editor.evaluating"_lang);
                 else {
-                    if (ImGui::Checkbox("hex.view.pattern.auto"_lang, &this->m_runAutomatically)) {
+                    if (ImGui::Checkbox("hex.builtin.view.pattern_editor.auto"_lang, &this->m_runAutomatically)) {
                         if (this->m_runAutomatically)
                             this->m_hasUnevaluatedChanges = true;
                     }
@@ -278,6 +298,71 @@ namespace hex {
                                                        this->m_patternLanguageRuntime->getMaximumPatternCount()
                                                        ).c_str()
                                            );
+
+                    ImGui::SameLine();
+
+                    if (ImGui::IconButton(ICON_VS_GLOBE, ImGui::GetStyleColorVec4(ImGuiCol_Text)))
+                        ImGui::OpenPopup("env_vars");
+
+                    if (ImGui::BeginPopup("env_vars")) {
+                        ImGui::TextUnformatted("hex.builtin.view.pattern_editor.env_vars"_lang);
+                        ImGui::SameLine();
+                        if (ImGui::IconButton(ICON_VS_ADD, ImGui::GetStyleColorVec4(ImGuiCol_Text))) this->m_envVarEntries.push_back({ "", s128(0), EnvVarType::Integer });
+                        ImGui::Separator();
+
+                        int index = 0;
+                        for (auto &[name, value, type] : this->m_envVarEntries) {
+                            ImGui::PushID(index++);
+
+                            ImGui::PushItemWidth(ImGui::GetTextLineHeightWithSpacing() * 2);
+                            constexpr const char* Types[] = { "I", "F", "S", "B" };
+                            if (ImGui::BeginCombo("", Types[static_cast<int>(type)])) {
+                                for (auto i = 0; i < IM_ARRAYSIZE(Types); i++) {
+                                    if (ImGui::Selectable(Types[i]))
+                                        type = static_cast<EnvVarType>(i);
+                                }
+
+                                ImGui::EndCombo();
+                            }
+                            ImGui::PopItemWidth();
+
+                            ImGui::SameLine();
+
+                            ImGui::InputText("###name",  name.data(), name.capacity(), ImGuiInputTextFlags_CallbackResize, ImGui::UpdateStringSizeCallback, &name);
+                            ImGui::SameLine();
+
+                            switch (type) {
+                                case EnvVarType::Integer: {
+                                    s64 displayValue = hex::get_or<s128>(value, 0);
+                                    ImGui::InputScalar("###value",  ImGuiDataType_S64, &displayValue);
+                                    value = s128(displayValue);
+                                    break;
+                                }
+                                case EnvVarType::Float: {
+                                    auto displayValue = hex::get_or<double>(value, 0.0);
+                                    ImGui::InputDouble("###value", &displayValue);
+                                    value = displayValue;
+                                    break;
+                                }
+                                case EnvVarType::Bool: {
+                                    auto displayValue = hex::get_or<bool>(value, false);
+                                    ImGui::Checkbox("###value", &displayValue);
+                                    value = displayValue;
+                                    break;
+                                }
+                                case EnvVarType::String: {
+                                    auto displayValue = hex::get_or<std::string>(value, "");
+                                    ImGui::InputText("###value",  displayValue.data(), displayValue.capacity(), ImGuiInputTextFlags_CallbackResize, ImGui::UpdateStringSizeCallback, &displayValue);
+                                    value = displayValue;
+                                    break;
+                                }
+                            }
+
+                            ImGui::PopID();
+                        }
+
+                        ImGui::EndPopup();
+                    }
                 }
 
                 if (this->m_textEditor.IsTextChanged()) {
@@ -299,8 +384,8 @@ namespace hex {
     }
 
     void ViewPatternEditor::drawAlwaysVisible() {
-        if (ImGui::BeginPopupModal("hex.view.pattern.accept_pattern"_lang, &this->m_acceptPatternWindowOpen, ImGuiWindowFlags_AlwaysAutoResize)) {
-            ImGui::TextWrapped("%s", static_cast<const char *>("hex.view.pattern.accept_pattern.desc"_lang));
+        if (ImGui::BeginPopupModal("hex.builtin.view.pattern_editor.accept_pattern"_lang, &this->m_acceptPatternWindowOpen, ImGuiWindowFlags_AlwaysAutoResize)) {
+            ImGui::TextWrapped("%s", static_cast<const char *>("hex.builtin.view.pattern_editor.accept_pattern.desc"_lang));
 
             std::vector<std::string> entries;
             entries.resize(this->m_possiblePatternFiles.size());
@@ -322,7 +407,7 @@ namespace hex {
             }
 
             ImGui::NewLine();
-            ImGui::Text("%s", static_cast<const char *>("hex.view.pattern.accept_pattern.question"_lang));
+            ImGui::Text("%s", static_cast<const char *>("hex.builtin.view.pattern_editor.accept_pattern.question"_lang));
 
             confirmButtons("hex.common.yes"_lang, "hex.common.no"_lang, [this]{
                 this->loadPatternFile(this->m_possiblePatternFiles[this->m_selectedPatternFile].string());
@@ -338,7 +423,7 @@ namespace hex {
         }
 
         bool opened = true;
-        if (ImGui::BeginPopupModal("hex.view.pattern.menu.file.load_pattern"_lang, &opened, ImGuiWindowFlags_AlwaysAutoResize)) {
+        if (ImGui::BeginPopupModal("hex.builtin.view.pattern_editor.menu.file.load_pattern"_lang, &opened, ImGuiWindowFlags_AlwaysAutoResize)) {
 
             if (ImGui::BeginListBox("##patterns", ImVec2(-FLT_MIN, 0))) {
 
@@ -360,7 +445,7 @@ namespace hex {
             ImGui::SameLine();
 
             if (ImGui::Button("hex.common.browse"_lang)) {
-                hex::openFileBrowser("hex.view.pattern.open_pattern"_lang, DialogMode::Open, { { "Pattern File", "hexpat" } }, [this](auto path) {
+                hex::openFileBrowser("hex.builtin.view.pattern_editor.open_pattern"_lang, DialogMode::Open, { { "Pattern File", "hexpat" } }, [this](auto path) {
                     this->loadPatternFile(path);
                     ImGui::CloseCurrentPopup();
                 });
@@ -412,7 +497,11 @@ namespace hex {
         EventManager::post<EventPatternChanged>();
 
         std::thread([this, buffer = std::string(buffer)] {
-            auto result = this->m_patternLanguageRuntime->executeString(ImHexApi::Provider::get(), buffer);
+            std::map<std::string, pl::Token::Literal> envVars;
+            for (const auto &[name, value, type] : this->m_envVarEntries)
+                envVars.insert({ name, value });
+
+            auto result = this->m_patternLanguageRuntime->executeString(ImHexApi::Provider::get(), buffer, envVars);
 
             auto error = this->m_patternLanguageRuntime->getError();
             if (error.has_value()) {

plugins/builtin/source/content/views/view_provider_settings.cpp

@@ -0,0 +1,65 @@
+#include "content/views/view_provider_settings.hpp"
+
+namespace hex::plugin::builtin {
+
+    ViewProviderSettings::ViewProviderSettings() : hex::View("hex.builtin.view.provider_settings.name") {
+        EventManager::subscribe<EventProviderCreated>(this, [](hex::prv::Provider *provider){
+            if (provider->hasLoadInterface())
+                EventManager::post<RequestOpenPopup>(View::toWindowName("hex.builtin.view.provider_settings.load_popup"));
+        });
+    }
+
+    ViewProviderSettings::~ViewProviderSettings() {
+        EventManager::unsubscribe<EventProviderCreated>(this);
+    }
+
+    void ViewProviderSettings::drawContent() {
+        if (ImGui::Begin(View::toWindowName("hex.builtin.view.provider_settings.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
+            auto provider = hex::ImHexApi::Provider::get();
+
+            if (provider != nullptr)
+                provider->drawInterface();
+        }
+        ImGui::End();
+    }
+
+    void ViewProviderSettings::drawAlwaysVisible() {
+        ImGui::SetNextWindowPos(ImGui::GetMainViewport()->GetCenter(), ImGuiCond_Appearing, ImVec2(0.5F, 0.5F));
+        if (ImGui::BeginPopupModal(View::toWindowName("hex.builtin.view.provider_settings.load_popup").c_str(), nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
+
+            auto provider = hex::ImHexApi::Provider::get();
+
+            if (provider != nullptr) {
+                provider->drawLoadInterface();
+
+                ImGui::NewLine();
+                ImGui::Separator();
+
+                if (ImGui::Button("hex.common.open"_lang)) {
+                    if (provider->open())
+                        ImGui::CloseCurrentPopup();
+                }
+
+                ImGui::SameLine();
+
+                if (ImGui::Button("hex.common.cancel"_lang)) {
+                    ImHexApi::Provider::remove(provider);
+                    ImGui::CloseCurrentPopup();
+                }
+            }
+
+            ImGui::EndPopup();
+        }
+    }
+
+    bool ViewProviderSettings::hasViewMenuItemEntry() {
+        return this->isAvailable();
+    }
+
+    bool ViewProviderSettings::isAvailable() {
+        auto provider = hex::ImHexApi::Provider::get();
+
+        return provider != nullptr && provider->hasInterface();
+    }
+
+}

plugins/builtin/source/content/views/view_settings.cpp

@@ -1,15 +1,15 @@
-#include "views/view_settings.hpp"
+#include "content/views/view_settings.hpp"
 
 #include <hex/api/content_registry.hpp>
 
 #include <nlohmann/json.hpp>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
-    ViewSettings::ViewSettings() : View("hex.view.settings.name") {
+    ViewSettings::ViewSettings() : View("hex.builtin.view.settings.name") {
         EventManager::subscribe<RequestOpenWindow>(this, [this](const std::string &name) {
             if (name == "Settings") {
-                View::doLater([]{ ImGui::OpenPopup(View::toWindowName("hex.view.settings.name").c_str()); });
+                View::doLater([]{ ImGui::OpenPopup(View::toWindowName("hex.builtin.view.settings.name").c_str()); });
                 this->getWindowOpenState() = true;
             }
         });
@@ -21,9 +21,8 @@ namespace hex {
 
     void ViewSettings::drawContent() {
 
-        ImGui::SetNextWindowSizeConstraints(ImVec2(0, 0), ImVec2(FLT_MAX, FLT_MAX));
-
-        if (ImGui::BeginPopupModal(View::toWindowName("hex.view.settings.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_AlwaysAutoResize)) {
+        ImGui::SetNextWindowSize(ImVec2(500, 300) * SharedData::globalScale, ImGuiCond_Always);
+        if (ImGui::BeginPopupModal(View::toWindowName("hex.builtin.view.settings.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoResize)) {
             if (ImGui::BeginTabBar("settings")) {
                 for (auto &[category, entries] : ContentRegistry::Settings::getEntries()) {
                     if (ImGui::BeginTabItem(LangEntry(category))) {
@@ -49,8 +48,11 @@ namespace hex {
 
     void ViewSettings::drawMenu() {
         if (ImGui::BeginMenu("hex.menu.help"_lang)) {
-            if (ImGui::MenuItem("hex.view.settings.name"_lang)) {
-                View::doLater([]{ ImGui::OpenPopup(View::toWindowName("hex.view.settings.name").c_str()); });
+
+            ImGui::Separator();
+
+            if (ImGui::MenuItem("hex.builtin.view.settings.name"_lang)) {
+                View::doLater([]{ ImGui::OpenPopup(View::toWindowName("hex.builtin.view.settings.name").c_str()); });
                 this->getWindowOpenState() = true;
             }
 

plugins/builtin/source/content/views/view_store.cpp

@@ -1,4 +1,4 @@
-#include "views/view_store.hpp"
+#include "content/views/view_store.hpp"
 
 #include <imgui.h>
 #define IMGUI_DEFINE_MATH_OPERATORS
@@ -16,23 +16,23 @@
 #include <microtar.h>
 #include <hex/helpers/file.hpp>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     using namespace std::literals::string_literals;
     using namespace std::literals::chrono_literals;
     
     namespace fs = std::filesystem;
 
-    ViewStore::ViewStore() : View("hex.view.store.name") {
+    ViewStore::ViewStore() : View("hex.builtin.view.store.name") {
         this->refresh();
     }
 
     ViewStore::~ViewStore() { }
 
     void ViewStore::drawStore() {
-        ImGui::Header("hex.view.store.desc"_lang, true);
+        ImGui::Header("hex.builtin.view.store.desc"_lang, true);
 
-        if (ImGui::Button("hex.view.store.reload"_lang)) {
+        if (ImGui::Button("hex.builtin.view.store.reload"_lang)) {
             this->refresh();
         }
 
@@ -40,8 +40,8 @@ namespace hex {
             if (ImGui::BeginTabItem(title)) {
                 if (ImGui::BeginTable("##pattern_language", 3, ImGuiTableFlags_ScrollY | ImGuiTableFlags_Borders | ImGuiTableFlags_SizingStretchSame | ImGuiTableFlags_RowBg)) {
                     ImGui::TableSetupScrollFreeze(0, 1);
-                    ImGui::TableSetupColumn("hex.view.store.row.name"_lang, ImGuiTableColumnFlags_WidthFixed);
-                    ImGui::TableSetupColumn("hex.view.store.row.description"_lang, ImGuiTableColumnFlags_None);
+                    ImGui::TableSetupColumn("hex.builtin.view.store.row.name"_lang, ImGuiTableColumnFlags_WidthFixed);
+                    ImGui::TableSetupColumn("hex.builtin.view.store.row.description"_lang, ImGuiTableColumnFlags_None);
                     ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthFixed);
 
                     ImGui::TableHeadersRow();
@@ -109,17 +109,17 @@ namespace hex {
                                 }
 
                             } else if (entry.hasUpdate) {
-                                if (ImGui::Button("hex.view.store.update"_lang)) {
+                                if (ImGui::Button("hex.builtin.view.store.update"_lang)) {
                                     this->download(pathType, entry.fileName, entry.link, true);
                                     entry.downloading = true;
                                 }
                             } else if (!entry.installed) {
-                                if (ImGui::Button("hex.view.store.download"_lang)) {
+                                if (ImGui::Button("hex.builtin.view.store.download"_lang)) {
                                     this->download(pathType, entry.fileName, entry.link, false);
                                     entry.downloading = true;
                                 }
                             } else {
-                                if (ImGui::Button("hex.view.store.remove"_lang)) {
+                                if (ImGui::Button("hex.builtin.view.store.remove"_lang)) {
                                     this->remove(pathType, entry.fileName);
                                     entry.installed = false;
                                 }
@@ -141,13 +141,13 @@ namespace hex {
 
             };
 
-            drawTab("hex.view.store.tab.patterns"_lang, ImHexPath::Patterns, this->m_patterns, [](auto){});
-            drawTab("hex.view.store.tab.libraries"_lang, ImHexPath::PatternsInclude, this->m_includes, [](auto){});
-            drawTab("hex.view.store.tab.magics"_lang, ImHexPath::Magic, this->m_magics, [](auto){
+            drawTab("hex.builtin.view.store.tab.patterns"_lang, ImHexPath::Patterns, this->m_patterns, [](auto){});
+            drawTab("hex.builtin.view.store.tab.libraries"_lang, ImHexPath::PatternsInclude, this->m_includes, [](auto){});
+            drawTab("hex.builtin.view.store.tab.magics"_lang, ImHexPath::Magic, this->m_magics, [](auto){
                 magic::compile();
             });
-            drawTab("hex.view.store.tab.constants"_lang, ImHexPath::Constants, this->m_constants, [](auto){});
-            drawTab("hex.view.store.tab.yara"_lang, ImHexPath::Yara, this->m_yara, [](auto){});
+            drawTab("hex.builtin.view.store.tab.constants"_lang, ImHexPath::Constants, this->m_constants, [](auto){});
+            drawTab("hex.builtin.view.store.tab.yara"_lang, ImHexPath::Yara, this->m_yara, [](auto){});
 
             ImGui::EndTabBar();
         }
@@ -219,10 +219,10 @@ namespace hex {
 
     void ViewStore::drawContent() {
         ImGui::SetNextWindowSizeConstraints(ImVec2(600, 400) * SharedData::globalScale, ImVec2(FLT_MAX, FLT_MAX));
-        if (ImGui::BeginPopupModal(View::toWindowName("hex.view.store.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_AlwaysAutoResize)) {
+        if (ImGui::BeginPopupModal(View::toWindowName("hex.builtin.view.store.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_AlwaysAutoResize)) {
             if (this->m_apiRequest.valid()) {
                 if (this->m_apiRequest.wait_for(0s) != std::future_status::ready)
-                    ImGui::TextSpinner("hex.view.store.loading"_lang);
+                    ImGui::TextSpinner("hex.builtin.view.store.loading"_lang);
                 else
                     this->parseResponse();
             }
@@ -237,8 +237,8 @@ namespace hex {
 
     void ViewStore::drawMenu() {
         if (ImGui::BeginMenu("hex.menu.help"_lang)) {
-            if (ImGui::MenuItem("hex.view.store.name"_lang)) {
-                View::doLater([]{ ImGui::OpenPopup(View::toWindowName("hex.view.store.name").c_str()); });
+            if (ImGui::MenuItem("hex.builtin.view.store.name"_lang)) {
+                View::doLater([]{ ImGui::OpenPopup(View::toWindowName("hex.builtin.view.store.name").c_str()); });
                 this->getWindowOpenState() = true;
             }
 

plugins/builtin/source/content/views/view_strings.cpp

@@ -1,4 +1,4 @@
-#include "views/view_strings.hpp"
+#include "content/views/view_strings.hpp"
 
 #include <hex/providers/provider.hpp>
 #include <hex/helpers/fmt.hpp>
@@ -12,19 +12,24 @@
 
 using namespace std::literals::string_literals;
 
-namespace hex {
+namespace hex::plugin::builtin {
 
-    ViewStrings::ViewStrings() : View("hex.view.strings.name") {
+    ViewStrings::ViewStrings() : View("hex.builtin.view.strings.name") {
         EventManager::subscribe<EventDataChanged>(this, [this]() {
             this->m_foundStrings.clear();
         });
 
         this->m_filter.reserve(0xFFFF);
         std::memset(this->m_filter.data(), 0x00, this->m_filter.capacity());
+
+        EventManager::subscribe<EventFileUnloaded>(this, [this]{
+            this->m_foundStrings.clear();
+        });
     }
 
     ViewStrings::~ViewStrings() {
         EventManager::unsubscribe<EventDataChanged>(this);
+        EventManager::unsubscribe<EventFileUnloaded>(this);
     }
 
     std::string readString(const FoundString &foundString) {
@@ -40,14 +45,14 @@ namespace hex {
             this->m_selectedString = readString(foundString);
         }
         if (ImGui::BeginPopup("StringContextMenu")) {
-            if (ImGui::MenuItem("hex.view.strings.copy"_lang)) {
+            if (ImGui::MenuItem("hex.builtin.view.strings.copy"_lang)) {
                 ImGui::SetClipboardText(this->m_selectedString.c_str());
             }
             ImGui::Separator();
-            if (ImGui::MenuItem("hex.view.strings.demangle"_lang)) {
+            if (ImGui::MenuItem("hex.builtin.view.strings.demangle"_lang)) {
                 this->m_demangledName = llvm::demangle(this->m_selectedString);
                 if (!this->m_demangledName.empty())
-                    View::doLater([]{ ImGui::OpenPopup("hex.view.strings.demangle.name"_lang); });
+                    View::doLater([]{ ImGui::OpenPopup("hex.builtin.view.strings.demangle.name"_lang); });
             }
             ImGui::EndPopup();
         }
@@ -66,7 +71,7 @@ namespace hex {
 
             for (u64 offset = 0; offset < provider->getSize(); offset += buffer.size()) {
                 size_t readSize = std::min(u64(buffer.size()), provider->getSize() - offset);
-                provider->readRelative(offset,  buffer.data(), readSize);
+                provider->read(offset + provider->getBaseAddress(),  buffer.data(), readSize);
 
                 for (u32 i = 0; i < readSize; i++) {
                     if (buffer[i] >= ' ' && buffer[i] <= '~' && offset < provider->getSize() - 1)
@@ -95,15 +100,15 @@ namespace hex {
     void ViewStrings::drawContent() {
         auto provider = ImHexApi::Provider::get();
 
-        if (ImGui::Begin(View::toWindowName("hex.view.strings.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
+        if (ImGui::Begin(View::toWindowName("hex.builtin.view.strings.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
             if (ImHexApi::Provider::isValid() && provider->isReadable()) {
                 ImGui::Disabled([this]{
-                    if (ImGui::InputInt("hex.view.strings.min_length"_lang, &this->m_minimumLength, 1, 0))
+                    if (ImGui::InputInt("hex.builtin.view.strings.min_length"_lang, &this->m_minimumLength, 1, 0))
                         this->m_foundStrings.clear();
 
                     ImGui::Checkbox("Regex", &this->m_regex);
 
-                    ImGui::InputText("hex.view.strings.filter"_lang, this->m_filter.data(), this->m_filter.capacity(), ImGuiInputTextFlags_CallbackEdit, [](ImGuiInputTextCallbackData *data) {
+                    ImGui::InputText("hex.builtin.view.strings.filter"_lang, this->m_filter.data(), this->m_filter.capacity(), ImGuiInputTextFlags_CallbackEdit, [](ImGuiInputTextCallbackData *data) {
                         auto &view = *static_cast<ViewStrings*>(data->UserData);
                         view.m_filter.resize(data->BufTextLen);
                         view.m_filterIndices.clear();
@@ -128,20 +133,20 @@ namespace hex {
                         return 0;
                     }, this);
                     if (this->m_regex && !this->m_pattern_parsed) {
-                        ImGui::TextColored(ImVec4(1.0f, 0.0f, 0.0f, 1.0f), "hex.view.strings.regex_error"_lang);
+                        ImGui::TextColored(ImVec4(1.0f, 0.0f, 0.0f, 1.0f), "hex.builtin.view.strings.regex_error"_lang);
                     }
 
-                    if (ImGui::Button("hex.view.strings.extract"_lang))
+                    if (ImGui::Button("hex.builtin.view.strings.extract"_lang))
                         this->searchStrings();
                 }, this->m_searching);
 
                 if (this->m_searching) {
                     ImGui::SameLine();
-                    ImGui::TextSpinner("hex.view.strings.searching"_lang);
+                    ImGui::TextSpinner("hex.builtin.view.strings.searching"_lang);
                 }
                 else if (this->m_foundStrings.size() > 0) {
                     ImGui::SameLine();
-                    ImGui::TextUnformatted(hex::format("hex.view.strings.results"_lang, this->m_filterIndices.size()).c_str());
+                    ImGui::TextUnformatted(hex::format("hex.builtin.view.strings.results"_lang, this->m_filterIndices.size()).c_str());
                 }
 
 
@@ -152,9 +157,9 @@ namespace hex {
                                       ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable | ImGuiTableFlags_Sortable |
                                       ImGuiTableFlags_Reorderable | ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY)) {
                     ImGui::TableSetupScrollFreeze(0, 1);
-                    ImGui::TableSetupColumn("hex.view.strings.offset"_lang, 0, -1, ImGui::GetID("offset"));
-                    ImGui::TableSetupColumn("hex.view.strings.size"_lang, 0, -1, ImGui::GetID("size"));
-                    ImGui::TableSetupColumn("hex.view.strings.string"_lang, 0, -1, ImGui::GetID("string"));
+                    ImGui::TableSetupColumn("hex.builtin.view.strings.offset"_lang, 0, -1, ImGui::GetID("offset"));
+                    ImGui::TableSetupColumn("hex.builtin.view.strings.size"_lang, 0, -1, ImGui::GetID("size"));
+                    ImGui::TableSetupColumn("hex.builtin.view.strings.string"_lang, 0, -1, ImGui::GetID("string"));
 
                     auto sortSpecs = ImGui::TableGetSortSpecs();
 
@@ -219,13 +224,13 @@ namespace hex {
         }
         ImGui::End();
 
-        if (ImGui::BeginPopup("hex.view.strings.demangle.title"_lang)) {
+        if (ImGui::BeginPopup("hex.builtin.view.strings.demangle.title"_lang)) {
             if (ImGui::BeginChild("##scrolling", ImVec2(500, 150))) {
-                ImGui::TextUnformatted("hex.view.strings.demangle.title"_lang);
+                ImGui::TextUnformatted("hex.builtin.view.strings.demangle.title"_lang);
                 ImGui::Separator();
                 ImGui::TextWrapped("%s", this->m_demangledName.c_str());
                 ImGui::NewLine();
-                if (ImGui::Button("hex.view.strings.demangle.copy"_lang))
+                if (ImGui::Button("hex.builtin.view.strings.demangle.copy"_lang))
                     ImGui::SetClipboardText(this->m_demangledName.c_str());
 
             }

plugins/builtin/source/content/views/view_tools.cpp

@@ -1,15 +1,15 @@
-#include "views/view_tools.hpp"
+#include "content/views/view_tools.hpp"
 
 #include <hex/providers/provider.hpp>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
-    ViewTools::ViewTools() : View("hex.view.tools.name") { }
+    ViewTools::ViewTools() : View("hex.builtin.view.tools.name") { }
 
     ViewTools::~ViewTools() { }
 
     void ViewTools::drawContent() {
-        if (ImGui::Begin(View::toWindowName("hex.view.tools.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
+        if (ImGui::Begin(View::toWindowName("hex.builtin.view.tools.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
             for (const auto& [name, function] : ContentRegistry::Tools::getEntries()) {
                 if (ImGui::CollapsingHeader(LangEntry(name))) {
                     function();

plugins/builtin/source/content/views/view_yara.cpp

@@ -1,4 +1,4 @@
-#include "views/view_yara.hpp"
+#include "content/views/view_yara.hpp"
 
 #include <hex/providers/provider.hpp>
 #include <hex/helpers/utils.hpp>
@@ -12,11 +12,11 @@
 #include <imgui_imhex_extensions.h>
 #include <hex/helpers/paths.hpp>
 
-namespace hex {
+namespace hex::plugin::builtin {
 
     namespace fs = std::filesystem;
 
-    ViewYara::ViewYara() : View("hex.view.yara.name") {
+    ViewYara::ViewYara() : View("hex.builtin.view.yara.name") {
         yr_initialize();
 
         this->reloadRules();
@@ -27,23 +27,23 @@ namespace hex {
     }
 
     void ViewYara::drawContent() {
-        if (ImGui::Begin(View::toWindowName("hex.view.yara.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
+        if (ImGui::Begin(View::toWindowName("hex.builtin.view.yara.name").c_str(), &this->getWindowOpenState(), ImGuiWindowFlags_NoCollapse)) {
 
             if (!this->m_matching && !this->m_errorMessage.empty()) {
-                View::showErrorPopup("hex.view.yara.error"_lang + this->m_errorMessage.data());
+                View::showErrorPopup("hex.builtin.view.yara.error"_lang + this->m_errorMessage.data());
                 this->m_errorMessage.clear();
             }
 
-            ImGui::TextUnformatted("hex.view.yara.header.rules"_lang);
+            ImGui::TextUnformatted("hex.builtin.view.yara.header.rules"_lang);
             ImGui::Separator();
 
             if (this->m_rules.empty()) {
-                ImGui::TextColored(ImVec4(0.92F, 0.25F, 0.2F, 1.0F), "%s", static_cast<const char*>("hex.view.yara.no_rules"_lang));
+                ImGui::TextColored(ImVec4(0.92F, 0.25F, 0.2F, 1.0F), "%s", static_cast<const char*>("hex.builtin.view.yara.no_rules"_lang));
 
-                if (ImGui::Button("hex.view.yara.reload"_lang)) this->reloadRules();
+                if (ImGui::Button("hex.builtin.view.yara.reload"_lang)) this->reloadRules();
             } else {
                 ImGui::Disabled([this]{
-                    if (ImGui::BeginCombo("hex.view.yara.header.rules"_lang, this->m_rules[this->m_selectedRule].first.c_str())) {
+                    if (ImGui::BeginCombo("hex.builtin.view.yara.header.rules"_lang, this->m_rules[this->m_selectedRule].first.c_str())) {
                         for (u32 i = 0; i < this->m_rules.size(); i++) {
                             const bool selected = (this->m_selectedRule == i);
                             if (ImGui::Selectable(this->m_rules[i].first.c_str(), selected))
@@ -55,24 +55,24 @@ namespace hex {
                         ImGui::EndCombo();
                     }
                     ImGui::SameLine();
-                    if (ImGui::Button("hex.view.yara.reload"_lang)) this->reloadRules();
-                    if (ImGui::Button("hex.view.yara.match"_lang)) this->applyRules();
+                    if (ImGui::Button("hex.builtin.view.yara.reload"_lang)) this->reloadRules();
+                    if (ImGui::Button("hex.builtin.view.yara.match"_lang)) this->applyRules();
                 }, this->m_matching);
 
                 if (this->m_matching) {
                     ImGui::SameLine();
-                    ImGui::TextSpinner("hex.view.yara.matching"_lang);
+                    ImGui::TextSpinner("hex.builtin.view.yara.matching"_lang);
                 }
             }
 
             ImGui::NewLine();
-            ImGui::TextUnformatted("hex.view.yara.header.matches"_lang);
+            ImGui::TextUnformatted("hex.builtin.view.yara.header.matches"_lang);
             ImGui::Separator();
 
             if (ImGui::BeginTable("matches", 4, ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable | ImGuiTableFlags_Sortable | ImGuiTableFlags_Reorderable | ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY)) {
                 ImGui::TableSetupScrollFreeze(0, 1);
-                ImGui::TableSetupColumn("hex.view.yara.matches.identifier"_lang);
-                ImGui::TableSetupColumn("hex.view.yara.matches.variable"_lang);
+                ImGui::TableSetupColumn("hex.builtin.view.yara.matches.identifier"_lang);
+                ImGui::TableSetupColumn("hex.builtin.view.yara.matches.variable"_lang);
                 ImGui::TableSetupColumn("hex.common.address"_lang);
                 ImGui::TableSetupColumn("hex.common.size"_lang);
 
@@ -103,7 +103,7 @@ namespace hex {
                             ImGui::Text("0x%lX", size);
                         } else {
                             ImGui::TableNextColumn();
-                            ImGui::TextColored(ImVec4(0.92F, 0.25F, 0.2F, 1.0F), "%s", static_cast<const char*>("hex.view.yara.whole_data"_lang));
+                            ImGui::TextColored(ImVec4(0.92F, 0.25F, 0.2F, 1.0F), "%s", static_cast<const char*>("hex.builtin.view.yara.whole_data"_lang));
                             ImGui::TableNextColumn();
                             ImGui::TextUnformatted("");
                         }
@@ -203,16 +203,18 @@ namespace hex {
 
                 auto provider = ImHexApi::Provider::get();
 
-                context.buffer.resize(std::min<u64>(0xF'FFFF, provider->getSize() - context.currBlock.base));
+                context.buffer.resize(context.currBlock.size);
 
                 if (context.buffer.empty()) return nullptr;
 
-                provider->readRelative(context.currBlock.base, context.buffer.data(), context.buffer.size());
+                block->size = context.currBlock.size;
+
+                provider->read(context.currBlock.base + provider->getBaseAddress(), context.buffer.data(), context.buffer.size());
 
                 return context.buffer.data();
             };
             iterator.file_size = [](auto *iterator) -> u64 {
-                return ImHexApi::Provider::get()->getSize();
+                return ImHexApi::Provider::get()->getActualSize();
             };
 
             iterator.context = &context;
@@ -233,7 +235,7 @@ namespace hex {
 
                 iterator->last_error = ERROR_SUCCESS;
                 context.currBlock.base = address;
-                context.currBlock.size = std::min<u64>(0xF'FFFF, ImHexApi::Provider::get()->getSize() - address);
+                context.currBlock.size = ImHexApi::Provider::get()->getActualSize() - address;
                 context.currBlock.context = &context;
 
                 if (context.currBlock.size == 0) return nullptr;

plugins/builtin/source/lang/de_DE.cpp

@@ -23,6 +23,7 @@ namespace hex::plugin::builtin {
                     { "hex.welcome.start.open_file", "Datei Öffnen" },
                     { "hex.welcome.start.open_project", "Projekt Öffnen" },
                     { "hex.welcome.start.recent", "Kürzlich geöffnet" },
+                    { "hex.welcome.start.open_other", "Andere Provider" },
                 { "hex.welcome.header.help", "Hilfe" },
                     { "hex.welcome.help.repo", "GitHub Repository" },
                         { "hex.welcome.help.repo.link", "https://github.com/WerWolv/ImHex" },
@@ -86,250 +87,257 @@ namespace hex::plugin::builtin {
                 { "hex.message.yara_rule_added", "Yara Regel hinzugefügt!" },
                 { "hex.message.magic_db_added", "Magic Datenbank hinzugefügt!" },
 
-                { "hex.view.bookmarks.name", "Lesezeichen" },
-                    { "hex.view.bookmarks.default_title", "Lesezeichen [0x{0:X} - 0x{1:X}]" },
-                    { "hex.view.bookmarks.no_bookmarks", "Noch kein Lesezeichen erstellt. Füge eines hinzu mit Bearbeiten -> Lesezeichen erstellen" },
-                    { "hex.view.bookmarks.title.info", "Informationen" },
-                    { "hex.view.bookmarks.address", "0x{0:X} : 0x{1:X} ({2} bytes)" },
-                    { "hex.view.bookmarks.button.jump", "Springen" },
-                    { "hex.view.bookmarks.button.remove", "Entfernen" },
-                    { "hex.view.bookmarks.header.name", "Name" },
-                    { "hex.view.bookmarks.header.color", "Farbe" },
-                    { "hex.view.bookmarks.header.comment", "Kommentar" },
+                /* Builtin plugin features */
 
-                { "hex.view.command_palette.name", "Befehlspalette" },
+                { "hex.builtin.view.bookmarks.name", "Lesezeichen" },
+                    { "hex.builtin.view.bookmarks.default_title", "Lesezeichen [0x{0:X} - 0x{1:X}]" },
+                    { "hex.builtin.view.bookmarks.no_bookmarks", "Noch kein Lesezeichen erstellt. Füge eines hinzu mit Bearbeiten -> Lesezeichen erstellen" },
+                    { "hex.builtin.view.bookmarks.title.info", "Informationen" },
+                    { "hex.builtin.view.bookmarks.address", "0x{0:X} : 0x{1:X} ({2} bytes)" },
+                    { "hex.builtin.view.bookmarks.button.jump", "Springen" },
+                    { "hex.builtin.view.bookmarks.button.remove", "Entfernen" },
+                    { "hex.builtin.view.bookmarks.header.name", "Name" },
+                    { "hex.builtin.view.bookmarks.header.color", "Farbe" },
+                    { "hex.builtin.view.bookmarks.header.comment", "Kommentar" },
 
-                { "hex.view.data_inspector.name", "Dateninspektor" },
-                    { "hex.view.data_inspector.table.name", "Name" },
-                    { "hex.view.data_inspector.table.value", "Wert" },
-                    { "hex.view.data_inspector.no_data", "Keine bytes angewählt"},
+                { "hex.builtin.view.command_palette.name", "Befehlspalette" },
 
-                { "hex.view.data_processor.name", "Datenprozessor" },
-                    { "hex.view.data_processor.menu.remove_selection", "Auswahl entfernen" },
-                    { "hex.view.data_processor.menu.remove_node", "Knoten entfernen" },
-                    { "hex.view.data_processor.menu.remove_link", "Link entfernen" },
+                { "hex.builtin.view.data_inspector.name", "Dateninspektor" },
+                    { "hex.builtin.view.data_inspector.table.name", "Name" },
+                    { "hex.builtin.view.data_inspector.table.value", "Wert" },
+                    { "hex.builtin.view.data_inspector.no_data", "Keine bytes angewählt"},
 
-                { "hex.view.disassembler.name", "Disassembler" },
-                    { "hex.view.disassembler.position", "Position" },
-                    { "hex.view.disassembler.base", "Basisadresse" },
-                    { "hex.view.disassembler.region", "Code Region" },
-                    { "hex.view.disassembler.settings.header", "Einstellungen" },
-                    { "hex.view.disassembler.arch", "Architektur" },
-                        { "hex.view.disassembler.arm.arm", "ARM Modus" },
-                        { "hex.view.disassembler.arm.thumb", "Thumb Modus" },
-                        { "hex.view.disassembler.arm.default", "Standard Modus" },
-                        { "hex.view.disassembler.arm.cortex_m", "Cortex-M Modus" },
-                        { "hex.view.disassembler.arm.armv8", "ARMv8 Modus" },
+                { "hex.builtin.view.data_processor.name", "Datenprozessor" },
+                    { "hex.builtin.view.data_processor.menu.remove_selection", "Auswahl entfernen" },
+                    { "hex.builtin.view.data_processor.menu.remove_node", "Knoten entfernen" },
+                    { "hex.builtin.view.data_processor.menu.remove_link", "Link entfernen" },
 
-                        { "hex.view.disassembler.mips.mips32", "MIPS32 Modus" },
-                        { "hex.view.disassembler.mips.mips64", "MIPS64 Modus" },
-                        { "hex.view.disassembler.mips.mips32R6", "MIPS32R6 Modus" },
-                        { "hex.view.disassembler.mips.micro", "Micro Modus" },
+                { "hex.builtin.view.disassembler.name", "Disassembler" },
+                    { "hex.builtin.view.disassembler.position", "Position" },
+                    { "hex.builtin.view.disassembler.base", "Basisadresse" },
+                    { "hex.builtin.view.disassembler.region", "Code Region" },
+                    { "hex.builtin.view.disassembler.settings.header", "Einstellungen" },
+                    { "hex.builtin.view.disassembler.arch", "Architektur" },
+                        { "hex.builtin.view.disassembler.arm.arm", "ARM Modus" },
+                        { "hex.builtin.view.disassembler.arm.thumb", "Thumb Modus" },
+                        { "hex.builtin.view.disassembler.arm.default", "Standard Modus" },
+                        { "hex.builtin.view.disassembler.arm.cortex_m", "Cortex-M Modus" },
+                        { "hex.builtin.view.disassembler.arm.armv8", "ARMv8 Modus" },
 
-                        { "hex.view.disassembler.x86.16bit", "16-bit Modus" },
-                        { "hex.view.disassembler.x86.32bit", "32-bit Modus" },
-                        { "hex.view.disassembler.x86.64bit", "64-bit Modus" },
+                        { "hex.builtin.view.disassembler.mips.mips32", "MIPS32 Modus" },
+                        { "hex.builtin.view.disassembler.mips.mips64", "MIPS64 Modus" },
+                        { "hex.builtin.view.disassembler.mips.mips32R6", "MIPS32R6 Modus" },
+                        { "hex.builtin.view.disassembler.mips.micro", "Micro Modus" },
 
-                        { "hex.view.disassembler.ppc.32bit", "32-bit Modus" },
-                        { "hex.view.disassembler.ppc.64bit", "64-bit Modus" },
+                        { "hex.builtin.view.disassembler.x86.16bit", "16-bit Modus" },
+                        { "hex.builtin.view.disassembler.x86.32bit", "32-bit Modus" },
+                        { "hex.builtin.view.disassembler.x86.64bit", "64-bit Modus" },
 
-                        { "hex.view.disassembler.sparc.v9", "Sparc V9 Modus" },
+                        { "hex.builtin.view.disassembler.ppc.32bit", "32-bit Modus" },
+                        { "hex.builtin.view.disassembler.ppc.64bit", "64-bit Modus" },
 
-                    { "hex.view.disassembler.disassemble", "Disassemble" },
-                    { "hex.view.disassembler.disassembling", "Disassemblen..." },
-                    { "hex.view.disassembler.disassembly.title", "Disassembly" },
-                        { "hex.view.disassembler.disassembly.address", "Adresse" },
-                        { "hex.view.disassembler.disassembly.offset", "Offset" },
-                        { "hex.view.disassembler.disassembly.bytes", "Byte" },
+                        { "hex.builtin.view.disassembler.sparc.v9", "Sparc V9 Modus" },
 
-                { "hex.view.hashes.name", "Hashes" },
-                    { "hex.view.hashes.settings", "Einstellungen" },
-                    { "hex.view.hashes.function", "Hash Funktion" },
-                    { "hex.view.hashes.iv", "Startwert" },
-                    { "hex.view.hashes.poly", "Polynomial" },
-                    { "hex.view.hashes.result", "Resultat" },
+                    { "hex.builtin.view.disassembler.disassemble", "Disassemble" },
+                    { "hex.builtin.view.disassembler.disassembling", "Disassemblen..." },
+                    { "hex.builtin.view.disassembler.disassembly.title", "Disassembly" },
+                        { "hex.builtin.view.disassembler.disassembly.address", "Adresse" },
+                        { "hex.builtin.view.disassembler.disassembly.offset", "Offset" },
+                        { "hex.builtin.view.disassembler.disassembly.bytes", "Byte" },
 
-                { "hex.view.help.name", "Hilfe" },
-                    { "hex.view.help.about.name", "Über ImHex" },
-                        { "hex.view.help.about.translator", "Von WerWolv übersetzt" },
-                        { "hex.view.help.about.source", "Quellcode auf GitHub verfügbar:" },
-                        { "hex.view.help.about.donations", "Spenden" },
-                        { "hex.view.help.about.thanks", "Wenn dir meine Arbeit gefällt, bitte ziehe eine Spende in Betracht, um das Projekt am Laufen zu halten. Vielen Dank <3" },
-                        { "hex.view.help.about.libs", "Benutzte Libraries" },
-                        { "hex.view.help.about.paths", "ImHex Ordner" },
-                    { "hex.view.help.documentation", "ImHex Dokumentation" },
-                    { "hex.view.help.pattern_cheat_sheet", "Pattern Language Cheat Sheet"},
-                    { "hex.view.help.calc_cheat_sheet", "Rechner Cheat Sheet" },
+                { "hex.builtin.view.hashes.name", "Hashes" },
+                    { "hex.builtin.view.hashes.settings", "Einstellungen" },
+                    { "hex.builtin.view.hashes.function", "Hash Funktion" },
+                    { "hex.builtin.view.hashes.iv", "Startwert" },
+                    { "hex.builtin.view.hashes.poly", "Polynomial" },
+                    { "hex.builtin.view.hashes.result", "Resultat" },
 
-                { "hex.view.hexeditor.name", "Hex editor" },
-                    { "hex.view.hexeditor.create_file", "Neu" },
-                    { "hex.view.hexeditor.open_file", "Öffnen" },
-                    { "hex.view.hexeditor.open_project", "Projekt öffnen" },
-                    { "hex.view.hexeditor.save_project", "Projekt speichern" },
-                    { "hex.view.hexeditor.save_data", "Daten speichern" },
-                    { "hex.view.hexeditor.open_base64", "Base64 Datei öffnen" },
-                    { "hex.view.hexeditor.load_enconding_file", "Custom encoding Datei laden" },
-                    { "hex.view.hexeditor.page", "Seite {0} / {1}" },
-                    { "hex.view.hexeditor.save_as", "Speichern unter" },
-                    { "hex.view.hexeditor.exit_application.title", "Applikation verlassen?" },
-                    { "hex.view.hexeditor.exit_application.desc", "Es wurden ungespeicherte Änderungen an diesem Projekt vorgenommen\nBist du sicher, dass du ImHex schliessen willst?" },
-                    { "hex.view.hexeditor.script.title", "Datei mit Loader Skript laden" },
-                    { "hex.view.hexeditor.script.desc", "Lade eine Datei mit Hilfe eines Python Skriptes" },
-                    { "hex.view.hexeditor.script.script", "Skript" },
-                        { "hex.view.hexeditor.script.script.title", "Loader Script: Skript öffnen" },
-                    { "hex.view.hexeditor.script.file", "Datei" },
-                    { "hex.view.hexeditor.script.file.title", "Loader Script: Datei öffnen" },
+                { "hex.builtin.view.help.name", "Hilfe" },
+                    { "hex.builtin.view.help.about.name", "Über ImHex" },
+                        { "hex.builtin.view.help.about.translator", "Von WerWolv übersetzt" },
+                        { "hex.builtin.view.help.about.source", "Quellcode auf GitHub verfügbar:" },
+                        { "hex.builtin.view.help.about.donations", "Spenden" },
+                        { "hex.builtin.view.help.about.thanks", "Wenn dir meine Arbeit gefällt, bitte ziehe eine Spende in Betracht, um das Projekt am Laufen zu halten. Vielen Dank <3" },
+                        { "hex.builtin.view.help.about.contributor", "Mitwirkende" },
+                        { "hex.builtin.view.help.about.libs", "Benutzte Libraries" },
+                        { "hex.builtin.view.help.about.paths", "ImHex Ordner" },
+                    { "hex.builtin.view.help.documentation", "ImHex Dokumentation" },
+                    { "hex.builtin.view.help.pattern_cheat_sheet", "Pattern Language Cheat Sheet"},
+                    { "hex.builtin.view.help.calc_cheat_sheet", "Rechner Cheat Sheet" },
 
-                    { "hex.view.hexeditor.menu.file.open_file", "Datei öffnen..." },
-                    { "hex.view.hexeditor.menu.file.open_recent", "Kürzlich geöffnete Dateien"},
-                    { "hex.view.hexeditor.menu.file.save", "Speichern" },
-                    { "hex.view.hexeditor.menu.file.save_as", "Speichern unter..." },
-                    { "hex.view.hexeditor.menu.file.close", "Schliessen" },
-                    { "hex.view.hexeditor.menu.file.quit", "ImHex Beenden" },
-                    { "hex.view.hexeditor.menu.file.open_project", "Projekt öffnen..." },
-                    { "hex.view.hexeditor.menu.file.save_project", "Projekt speichern..." },
-                    { "hex.view.hexeditor.menu.file.load_encoding_file", "Custom encoding laden..." },
-                    { "hex.view.hexeditor.menu.file.import", "Importieren..." },
-                        { "hex.view.hexeditor.menu.file.import.base64", "Base64 Datei" },
-                        { "hex.view.hexeditor.base64.import_error", "Datei ist nicht in einem korrekten Base64 Format!" },
-                        { "hex.view.hexeditor.file_open_error", "Öffnen der Datei fehlgeschlagen!" },
-                        { "hex.view.hexeditor.menu.file.import.ips", "IPS Patch" },
-                        { "hex.view.hexeditor.menu.file.import.ips32", "IPS32 Patch" },
-                        { "hex.view.hexeditor.menu.file.import.script", "Datei mit Loader Script" },
+                { "hex.builtin.view.hexeditor.name", "Hex editor" },
+                    { "hex.builtin.view.hexeditor.create_file", "Neu" },
+                    { "hex.builtin.view.hexeditor.open_file", "Öffnen" },
+                    { "hex.builtin.view.hexeditor.open_project", "Projekt öffnen" },
+                    { "hex.builtin.view.hexeditor.save_project", "Projekt speichern" },
+                    { "hex.builtin.view.hexeditor.save_data", "Daten speichern" },
+                    { "hex.builtin.view.hexeditor.open_base64", "Base64 Datei öffnen" },
+                    { "hex.builtin.view.hexeditor.load_enconding_file", "Custom encoding Datei laden" },
+                    { "hex.builtin.view.hexeditor.page", "Seite {0} / {1}" },
+                    { "hex.builtin.view.hexeditor.save_as", "Speichern unter" },
+                    { "hex.builtin.view.hexeditor.exit_application.title", "Applikation verlassen?" },
+                    { "hex.builtin.view.hexeditor.exit_application.desc", "Es wurden ungespeicherte Änderungen an diesem Projekt vorgenommen\nBist du sicher, dass du ImHex schliessen willst?" },
+                    { "hex.builtin.view.hexeditor.script.title", "Datei mit Loader Skript laden" },
+                    { "hex.builtin.view.hexeditor.script.desc", "Lade eine Datei mit Hilfe eines Python Skriptes" },
+                    { "hex.builtin.view.hexeditor.script.script", "Skript" },
+                        { "hex.builtin.view.hexeditor.script.script.title", "Loader Script: Skript öffnen" },
+                    { "hex.builtin.view.hexeditor.script.file", "Datei" },
+                    { "hex.builtin.view.hexeditor.script.file.title", "Loader Script: Datei öffnen" },
 
-                    { "hex.view.hexeditor.menu.file.export", "Exportieren..." },
-                        { "hex.view.hexeditor.menu.file.export.title", "Datei exportieren" },
-                        { "hex.view.hexeditor.menu.file.export.ips", "IPS Patch" },
-                        { "hex.view.hexeditor.menu.file.export.ips32", "IPS32 Patch" },
-                    { "hex.view.hexeditor.menu.file.search", "Suchen" },
-                        { "hex.view.hexeditor.search.string", "String" },
-                        { "hex.view.hexeditor.search.hex", "Hex" },
-                        { "hex.view.hexeditor.search.find", "Suchen" },
-                        { "hex.view.hexeditor.search.find_next", "Nächstes" },
-                        { "hex.view.hexeditor.search.find_prev", "Vorheriges" },
-                    { "hex.view.hexeditor.menu.file.goto", "Sprung" },
-                        { "hex.view.hexeditor.goto.offset.absolute", "Absolut" },
-                        { "hex.view.hexeditor.goto.offset.current", "Momentan" },
-                        { "hex.view.hexeditor.goto.offset.begin", "Beginn" },
-                        { "hex.view.hexeditor.goto.offset.end", "Ende" },
-                    { "hex.view.hexeditor.error.read_only", "Schreibzugriff konnte nicht erlangt werden. Datei wurde im Lesemodus geöffnet." },
-                    { "hex.view.hexeditor.error.open", "Öffnen der Datei fehlgeschlagen!" },
-                    { "hex.view.hexeditor.error.create", "Erstellen der neuen Datei fehlgeschlagen!" },
-                    { "hex.view.hexeditor.menu.edit.undo", "Rückgängig" },
-                    { "hex.view.hexeditor.menu.edit.redo", "Wiederholen" },
-                    { "hex.view.hexeditor.menu.edit.copy", "Kopieren" },
-                    { "hex.view.hexeditor.menu.edit.copy_as", "Kopieren als..." },
-                        { "hex.view.hexeditor.copy.hex", "String" },
-                        { "hex.view.hexeditor.copy.c", "C Array" },
-                        { "hex.view.hexeditor.copy.cpp", "C++ Array" },
-                        { "hex.view.hexeditor.copy.csharp", "C# Array" },
-                        { "hex.view.hexeditor.copy.rust", "Rust Array" },
-                        { "hex.view.hexeditor.copy.python", "Python Array" },
-                        { "hex.view.hexeditor.copy.java", "Java Array" },
-                        { "hex.view.hexeditor.copy.js", "JavaScript Array" },
-                        { "hex.view.hexeditor.copy.ascii", "ASCII Art" },
-                        { "hex.view.hexeditor.copy.html", "HTML" },
-                    { "hex.view.hexeditor.menu.edit.paste", "Einfügen" },
-                    { "hex.view.hexeditor.menu.edit.select_all", "Alles auswählen" },
-                    { "hex.view.hexeditor.menu.edit.bookmark", "Lesezeichen erstellen" },
-                    { "hex.view.hexeditor.menu.edit.set_base", "Basisadresse setzen" },
-                    { "hex.view.hexeditor.menu.edit.resize", "Grösse ändern" },
+                    { "hex.builtin.view.hexeditor.menu.file.open_file", "Datei öffnen..." },
+                    { "hex.builtin.view.hexeditor.menu.file.open_recent", "Kürzlich geöffnete Dateien" },
+                    { "hex.builtin.view.hexeditor.menu.file.open_other", "Provider öffnen..." },
+                    { "hex.builtin.view.hexeditor.menu.file.save", "Speichern" },
+                    { "hex.builtin.view.hexeditor.menu.file.save_as", "Speichern unter..." },
+                    { "hex.builtin.view.hexeditor.menu.file.close", "Schliessen" },
+                    { "hex.builtin.view.hexeditor.menu.file.quit", "ImHex Beenden" },
+                    { "hex.builtin.view.hexeditor.menu.file.open_project", "Projekt öffnen..." },
+                    { "hex.builtin.view.hexeditor.menu.file.save_project", "Projekt speichern..." },
+                    { "hex.builtin.view.hexeditor.menu.file.load_encoding_file", "Custom encoding laden..." },
+                    { "hex.builtin.view.hexeditor.menu.file.import", "Importieren..." },
+                        { "hex.builtin.view.hexeditor.menu.file.import.base64", "Base64 Datei" },
+                        { "hex.builtin.view.hexeditor.base64.import_error", "Datei ist nicht in einem korrekten Base64 Format!" },
+                        { "hex.builtin.view.hexeditor.file_open_error", "Öffnen der Datei fehlgeschlagen!" },
+                        { "hex.builtin.view.hexeditor.menu.file.import.ips", "IPS Patch" },
+                        { "hex.builtin.view.hexeditor.menu.file.import.ips32", "IPS32 Patch" },
+                        { "hex.builtin.view.hexeditor.menu.file.import.script", "Datei mit Loader Script" },
 
-                { "hex.view.information.name", "Dateninformationen" },
-                    { "hex.view.information.control", "Einstellungen" },
-                    { "hex.view.information.analyze", "Seite analysieren" },
-                    { "hex.view.information.analyzing", "Analysieren..." },
-                    { "hex.view.information.region", "Analysierte Region" },
-                    { "hex.view.information.magic", "Magic Informationen" },
-                    { "hex.view.information.description", "Beschreibung:" },
-                    { "hex.view.information.mime", "MIME Typ:" },
-                    { "hex.view.information.info_analysis", "Informationsanalysis" },
-                    { "hex.view.information.distribution", "Byte Verteilung" },
-                    { "hex.view.information.entropy", "Entropie" },
-                    { "hex.view.information.block_size", "Blockgrösse" },
-                    { "hex.view.information.block_size.desc", "{0} Blöcke min {1} bytes" },
-                    { "hex.view.information.file_entropy", "Dateientropie" },
-                    { "hex.view.information.highest_entropy", "Höchste Blockentropie" },
-                    { "hex.view.information.encrypted", "Diese Daten sind vermutlich verschlüsselt oder komprimiert!" },
+                    { "hex.builtin.view.hexeditor.menu.file.export", "Exportieren..." },
+                        { "hex.builtin.view.hexeditor.menu.file.export.title", "Datei exportieren" },
+                        { "hex.builtin.view.hexeditor.menu.file.export.ips", "IPS Patch" },
+                        { "hex.builtin.view.hexeditor.menu.file.export.ips32", "IPS32 Patch" },
+                    { "hex.builtin.view.hexeditor.menu.file.search", "Suchen" },
+                        { "hex.builtin.view.hexeditor.search.string", "String" },
+                        { "hex.builtin.view.hexeditor.search.hex", "Hex" },
+                        { "hex.builtin.view.hexeditor.search.find", "Suchen" },
+                        { "hex.builtin.view.hexeditor.search.find_next", "Nächstes" },
+                        { "hex.builtin.view.hexeditor.search.find_prev", "Vorheriges" },
+                    { "hex.builtin.view.hexeditor.menu.file.goto", "Sprung" },
+                        { "hex.builtin.view.hexeditor.goto.offset.absolute", "Absolut" },
+                        { "hex.builtin.view.hexeditor.goto.offset.current", "Momentan" },
+                        { "hex.builtin.view.hexeditor.goto.offset.begin", "Beginn" },
+                        { "hex.builtin.view.hexeditor.goto.offset.end", "Ende" },
+                    { "hex.builtin.view.hexeditor.error.read_only", "Schreibzugriff konnte nicht erlangt werden. Datei wurde im Lesemodus geöffnet." },
+                    { "hex.builtin.view.hexeditor.error.open", "Öffnen der Datei fehlgeschlagen!" },
+                    { "hex.builtin.view.hexeditor.error.create", "Erstellen der neuen Datei fehlgeschlagen!" },
+                    { "hex.builtin.view.hexeditor.menu.edit.undo", "Rückgängig" },
+                    { "hex.builtin.view.hexeditor.menu.edit.redo", "Wiederholen" },
+                    { "hex.builtin.view.hexeditor.menu.edit.copy", "Kopieren" },
+                    { "hex.builtin.view.hexeditor.menu.edit.copy_as", "Kopieren als..." },
+                        { "hex.builtin.view.hexeditor.copy.hex", "String" },
+                        { "hex.builtin.view.hexeditor.copy.c", "C Array" },
+                        { "hex.builtin.view.hexeditor.copy.cpp", "C++ Array" },
+                        { "hex.builtin.view.hexeditor.copy.csharp", "C# Array" },
+                        { "hex.builtin.view.hexeditor.copy.rust", "Rust Array" },
+                        { "hex.builtin.view.hexeditor.copy.python", "Python Array" },
+                        { "hex.builtin.view.hexeditor.copy.java", "Java Array" },
+                        { "hex.builtin.view.hexeditor.copy.js", "JavaScript Array" },
+                        { "hex.builtin.view.hexeditor.copy.ascii", "ASCII Art" },
+                        { "hex.builtin.view.hexeditor.copy.html", "HTML" },
+                    { "hex.builtin.view.hexeditor.menu.edit.paste", "Einfügen" },
+                    { "hex.builtin.view.hexeditor.menu.edit.select_all", "Alles auswählen" },
+                    { "hex.builtin.view.hexeditor.menu.edit.bookmark", "Lesezeichen erstellen" },
+                    { "hex.builtin.view.hexeditor.menu.edit.set_base", "Basisadresse setzen" },
+                    { "hex.builtin.view.hexeditor.menu.edit.resize", "Grösse ändern" },
 
-                { "hex.view.patches.name", "Patches" },
-                    { "hex.view.patches.offset", "Offset" },
-                    { "hex.view.patches.orig", "Originalwert" },
-                    { "hex.view.patches.patch", "Patchwert"},
-                    { "hex.view.patches.remove", "Patch entfernen" },
+                { "hex.builtin.view.information.name", "Dateninformationen" },
+                    { "hex.builtin.view.information.control", "Einstellungen" },
+                    { "hex.builtin.view.information.analyze", "Seite analysieren" },
+                    { "hex.builtin.view.information.analyzing", "Analysieren..." },
+                    { "hex.builtin.view.information.region", "Analysierte Region" },
+                    { "hex.builtin.view.information.magic", "Magic Informationen" },
+                    { "hex.builtin.view.information.description", "Beschreibung:" },
+                    { "hex.builtin.view.information.mime", "MIME Typ:" },
+                    { "hex.builtin.view.information.info_analysis", "Informationsanalysis" },
+                    { "hex.builtin.view.information.distribution", "Byte Verteilung" },
+                    { "hex.builtin.view.information.entropy", "Entropie" },
+                    { "hex.builtin.view.information.block_size", "Blockgrösse" },
+                    { "hex.builtin.view.information.block_size.desc", "{0} Blöcke min {1} bytes" },
+                    { "hex.builtin.view.information.file_entropy", "Dateientropie" },
+                    { "hex.builtin.view.information.highest_entropy", "Höchste Blockentropie" },
+                    { "hex.builtin.view.information.encrypted", "Diese Daten sind vermutlich verschlüsselt oder komprimiert!" },
 
-                { "hex.view.pattern.name", "Pattern Editor" },
-                { "hex.view.pattern.accept_pattern", "Pattern akzeptieren" },
-                    { "hex.view.pattern.accept_pattern.desc", "Ein oder mehrere kompatible Pattern wurden für diesen Dateityp gefunden" },
-                    { "hex.view.pattern.accept_pattern.pattern_language", "Pattern" },
-                    { "hex.view.pattern.accept_pattern.question", "Ausgewähltes Pattern anwenden?" },
-                { "hex.view.pattern.menu.file.load_pattern", "Pattern laden..." },
-                { "hex.view.pattern.open_pattern", "Pattern öffnen" },
-                { "hex.view.pattern.evaluating", "Evaluieren..." },
-                { "hex.view.pattern.auto", "Auto evaluieren" },
+                { "hex.builtin.view.patches.name", "Patches" },
+                    { "hex.builtin.view.patches.offset", "Offset" },
+                    { "hex.builtin.view.patches.orig", "Originalwert" },
+                    { "hex.builtin.view.patches.patch", "Patchwert"},
+                    { "hex.builtin.view.patches.remove", "Patch entfernen" },
 
-                { "hex.view.pattern_data.name", "Pattern Daten" },
-                    { "hex.view.pattern_data.var_name", "Name" },
-                    { "hex.view.pattern_data.color", "Farbe" },
-                    { "hex.view.pattern_data.offset", "Offset" },
-                    { "hex.view.pattern_data.size", "Grösse" },
-                    { "hex.view.pattern_data.type", "Typ" },
-                    { "hex.view.pattern_data.value", "Wert" },
+                { "hex.builtin.view.pattern_editor.name", "Pattern Editor" },
+                { "hex.builtin.view.pattern_editor.accept_pattern", "Pattern akzeptieren" },
+                    { "hex.builtin.view.pattern_editor.accept_pattern.desc", "Ein oder mehrere kompatible Pattern wurden für diesen Dateityp gefunden" },
+                    { "hex.builtin.view.pattern_editor.accept_pattern.pattern_language", "Pattern" },
+                    { "hex.builtin.view.pattern_editor.accept_pattern.question", "Ausgewähltes Pattern anwenden?" },
+                { "hex.builtin.view.pattern_editor.menu.file.load_pattern", "Pattern laden..." },
+                { "hex.builtin.view.pattern_editor.menu.file.save_pattern", "Pattern speichern..." },
+                { "hex.builtin.view.pattern_editor.open_pattern", "Pattern öffnen" },
+                { "hex.builtin.view.pattern_editor.evaluating", "Evaluieren..." },
+                { "hex.builtin.view.pattern_editor.auto", "Auto evaluieren" },
+                { "hex.builtin.view.pattern_editor.env_vars", "Umgebungsvariablen" },
 
-                { "hex.view.settings.name", "Einstellungen" },
+                { "hex.builtin.view.pattern_data.name", "Pattern Daten" },
+                    { "hex.builtin.view.pattern_data.var_name", "Name" },
+                    { "hex.builtin.view.pattern_data.color", "Farbe" },
+                    { "hex.builtin.view.pattern_data.offset", "Offset" },
+                    { "hex.builtin.view.pattern_data.size", "Grösse" },
+                    { "hex.builtin.view.pattern_data.type", "Typ" },
+                    { "hex.builtin.view.pattern_data.value", "Wert" },
 
-                { "hex.view.strings.name", "Strings" },
-                    { "hex.view.strings.copy", "String kopieren" },
-                    { "hex.view.strings.demangle", "Demangle" },
-                    { "hex.view.strings.min_length", "Minimallänge" },
-                    { "hex.view.strings.filter", "Filter" },
-                    { "hex.view.strings.extract", "Extrahieren" },
-                    { "hex.view.strings.regex_error", "Ungültiges Regex" },
-                    { "hex.view.strings.results", "{0} Ergebnisse" },
-                    { "hex.view.strings.searching", "Suchen..." },
-                    { "hex.view.strings.offset", "Offset" },
-                    { "hex.view.strings.size", "Grösse" },
-                    { "hex.view.strings.string", "String" },
-                    { "hex.view.strings.demangle.title", "Demangled Namen" },
-                    { "hex.view.strings.demangle.copy", "Kopieren" },
+                { "hex.builtin.view.settings.name", "Einstellungen" },
 
-                { "hex.view.tools.name", "Werkzeuge" },
+                { "hex.builtin.view.strings.name", "Strings" },
+                    { "hex.builtin.view.strings.copy", "String kopieren" },
+                    { "hex.builtin.view.strings.demangle", "Demangle" },
+                    { "hex.builtin.view.strings.min_length", "Minimallänge" },
+                    { "hex.builtin.view.strings.filter", "Filter" },
+                    { "hex.builtin.view.strings.extract", "Extrahieren" },
+                    { "hex.builtin.view.strings.regex_error", "Ungültiges Regex" },
+                    { "hex.builtin.view.strings.results", "{0} Ergebnisse" },
+                    { "hex.builtin.view.strings.searching", "Suchen..." },
+                    { "hex.builtin.view.strings.offset", "Offset" },
+                    { "hex.builtin.view.strings.size", "Grösse" },
+                    { "hex.builtin.view.strings.string", "String" },
+                    { "hex.builtin.view.strings.demangle.title", "Demangled Namen" },
+                    { "hex.builtin.view.strings.demangle.copy", "Kopieren" },
 
-                { "hex.view.yara.name", "Yara Regeln" },
-                    { "hex.view.yara.header.rules", "Regeln" },
-                        { "hex.view.yara.reload", "Neu laden" },
-                        { "hex.view.yara.match", "Regeln anwenden" },
-                        { "hex.view.yara.matching", "Anwenden..." },
-                        { "hex.view.yara.error", "Yara Kompilerfehler: " },
-                    { "hex.view.yara.header.matches", "Funde" },
-                        { "hex.view.yara.matches.identifier", "Kennung" },
-                        { "hex.view.yara.matches.variable", "Variabel" },
-                        { "hex.view.yara.whole_data", "Gesammte Daten Übereinstimmung!" },
-                        { "hex.view.yara.no_rules", "Keine Yara Regeln gefunden. Platziere sie in ImHex's 'yara' Ordner" },
+                { "hex.builtin.view.tools.name", "Werkzeuge" },
 
-                { "hex.view.constants.name", "Konstanten" },
-                    { "hex.view.constants.row.category", "Kategorie" },
-                    { "hex.view.constants.row.name", "Name" },
-                    { "hex.view.constants.row.desc", "Beschreibung" },
-                    { "hex.view.constants.row.value", "Wert" },
+                { "hex.builtin.view.yara.name", "Yara Regeln" },
+                    { "hex.builtin.view.yara.header.rules", "Regeln" },
+                        { "hex.builtin.view.yara.reload", "Neu laden" },
+                        { "hex.builtin.view.yara.match", "Regeln anwenden" },
+                        { "hex.builtin.view.yara.matching", "Anwenden..." },
+                        { "hex.builtin.view.yara.error", "Yara Kompilerfehler: " },
+                    { "hex.builtin.view.yara.header.matches", "Funde" },
+                        { "hex.builtin.view.yara.matches.identifier", "Kennung" },
+                        { "hex.builtin.view.yara.matches.variable", "Variable" },
+                        { "hex.builtin.view.yara.whole_data", "Gesammte Daten Übereinstimmung!" },
+                        { "hex.builtin.view.yara.no_rules", "Keine Yara Regeln gefunden. Platziere sie in ImHex's 'yara' Ordner" },
 
-                { "hex.view.store.name", "Content Store" },
-                    { "hex.view.store.desc", "Downloade zusätzlichen Content von ImHex's online Datenbank" },
-                    { "hex.view.store.reload", "Neu laden" },
-                    { "hex.view.store.row.name", "Name" },
-                    { "hex.view.store.row.description", "Beschreibung" },
-                    { "hex.view.store.download", "Download" },
-                    { "hex.view.store.update", "Update" },
-                    { "hex.view.store.remove", "Entfernen" },
-                    { "hex.view.store.tab.patterns", "Patterns" },
-                    { "hex.view.store.tab.libraries", "Libraries" },
-                    { "hex.view.store.tab.magics", "Magic Files" },
-                    { "hex.view.store.tab.constants", "Konstanten" },
-                    { "hex.view.store.tab.yara", "Yara Rules" },
-                    { "hex.view.store.loading", "Store inhalt wird geladen..." },
-                { "hex.view.diff.name", "Diffing" },
+                { "hex.builtin.view.constants.name", "Konstanten" },
+                    { "hex.builtin.view.constants.row.category", "Kategorie" },
+                    { "hex.builtin.view.constants.row.name", "Name" },
+                    { "hex.builtin.view.constants.row.desc", "Beschreibung" },
+                    { "hex.builtin.view.constants.row.value", "Wert" },
 
-            /* Builtin plugin features */
+                { "hex.builtin.view.store.name", "Content Store" },
+                    { "hex.builtin.view.store.desc", "Downloade zusätzlichen Content von ImHex's online Datenbank" },
+                    { "hex.builtin.view.store.reload", "Neu laden" },
+                    { "hex.builtin.view.store.row.name", "Name" },
+                    { "hex.builtin.view.store.row.description", "Beschreibung" },
+                    { "hex.builtin.view.store.download", "Download" },
+                    { "hex.builtin.view.store.update", "Update" },
+                    { "hex.builtin.view.store.remove", "Entfernen" },
+                    { "hex.builtin.view.store.tab.patterns", "Patterns" },
+                    { "hex.builtin.view.store.tab.libraries", "Libraries" },
+                    { "hex.builtin.view.store.tab.magics", "Magic Files" },
+                    { "hex.builtin.view.store.tab.constants", "Konstanten" },
+                    { "hex.builtin.view.store.tab.yara", "Yara Rules" },
+                    { "hex.builtin.view.store.loading", "Store inhalt wird geladen..." },
+                { "hex.builtin.view.diff.name", "Diffing" },
+
+                { "hex.builtin.view.provider_settings.name", "Provider Einstellungen" },
+                    { "hex.builtin.view.provider_settings.load_popup", "Provider öffnen" },
 
                 { "hex.builtin.command.calc.desc", "Rechner" },
                 { "hex.builtin.command.cmd.desc", "Command" },
@@ -665,6 +673,18 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.provider.file.creation", "Erstellungszeit" },
                 { "hex.builtin.provider.file.access", "Letzte Zugriffszeit" },
                 { "hex.builtin.provider.file.modification", "Letzte Modifikationszeit" },
+
+                { "hex.builtin.provider.file", "Datei Provider" },
+                { "hex.builtin.provider.gdb", "GDB Server Provider" },
+                    { "hex.builtin.provider.gdb.name", "GDB Server <{0}:{1}>" },
+                    { "hex.builtin.provider.gdb.server", "Server" },
+                    { "hex.builtin.provider.gdb.ip", "IP Adresse" },
+                    { "hex.builtin.provider.gdb.port", "Port" },
+                { "hex.builtin.provider.disk", "Datenträger Provider" },
+                    { "hex.builtin.provider.disk.selected_disk", "Datenträger" },
+                    { "hex.builtin.provider.disk.disk_size", "Datenträgergrösse" },
+                    { "hex.builtin.provider.disk.sector_size", "Sektorgrösse" },
+                    { "hex.builtin.provider.disk.reload", "Neu laden" },
         });
     }
 

plugins/builtin/source/lang/en_US.cpp

@@ -23,6 +23,7 @@ namespace hex::plugin::builtin {
                     { "hex.welcome.start.open_file", "Open File" },
                     { "hex.welcome.start.open_project", "Open Project" },
                     { "hex.welcome.start.recent", "Recent Files" },
+                    { "hex.welcome.start.open_other", "Other Providers" },
                 { "hex.welcome.header.help", "Help" },
                     { "hex.welcome.help.repo", "GitHub Repository" },
                         { "hex.welcome.help.repo.link", "https://github.com/WerWolv/ImHex" },
@@ -86,254 +87,260 @@ namespace hex::plugin::builtin {
                 { "hex.message.yara_rule_added", "Yara rule added!" },
                 { "hex.message.magic_db_added", "Magic database added!" },
 
-                { "hex.view.bookmarks.name", "Bookmarks" },
-                    { "hex.view.bookmarks.default_title", "Bookmark [0x{0:X} - 0x{1:X}]" },
-                    { "hex.view.bookmarks.no_bookmarks", "No bookmarks created yet. Add one with Edit -> Create Bookmark" },
-                    { "hex.view.bookmarks.title.info", "Information" },
-                    { "hex.view.bookmarks.address", "0x{0:X} : 0x{1:X} ({2} bytes)" },
-                    { "hex.view.bookmarks.button.jump", "Jump to" },
-                    { "hex.view.bookmarks.button.remove", "Remove" },
-                    { "hex.view.bookmarks.header.name", "Name" },
-                    { "hex.view.bookmarks.header.color", "Color" },
-                    { "hex.view.bookmarks.header.comment", "Comment" },
+                /* Builtin plugin features */
 
-                { "hex.view.command_palette.name", "Command Palette" },
+                { "hex.builtin.view.bookmarks.name", "Bookmarks" },
+                    { "hex.builtin.view.bookmarks.default_title", "Bookmark [0x{0:X} - 0x{1:X}]" },
+                    { "hex.builtin.view.bookmarks.no_bookmarks", "No bookmarks created yet. Add one with Edit -> Create Bookmark" },
+                    { "hex.builtin.view.bookmarks.title.info", "Information" },
+                    { "hex.builtin.view.bookmarks.address", "0x{0:X} : 0x{1:X} ({2} bytes)" },
+                    { "hex.builtin.view.bookmarks.button.jump", "Jump to" },
+                    { "hex.builtin.view.bookmarks.button.remove", "Remove" },
+                    { "hex.builtin.view.bookmarks.header.name", "Name" },
+                    { "hex.builtin.view.bookmarks.header.color", "Color" },
+                    { "hex.builtin.view.bookmarks.header.comment", "Comment" },
 
-                { "hex.view.data_inspector.name", "Data Inspector" },
-                    { "hex.view.data_inspector.table.name", "Name" },
-                    { "hex.view.data_inspector.table.value", "Value" },
-                    { "hex.view.data_inspector.no_data", "No bytes selected"},
+                { "hex.builtin.view.command_palette.name", "Command Palette" },
 
-                { "hex.view.data_processor.name", "Data Processor" },
-                    { "hex.view.data_processor.menu.remove_selection", "Remove Selected" },
-                    { "hex.view.data_processor.menu.remove_node", "Remove Node" },
-                    { "hex.view.data_processor.menu.remove_link", "Remove Link" },
+                { "hex.builtin.view.data_inspector.name", "Data Inspector" },
+                    { "hex.builtin.view.data_inspector.table.name", "Name" },
+                    { "hex.builtin.view.data_inspector.table.value", "Value" },
+                    { "hex.builtin.view.data_inspector.no_data", "No bytes selected"},
 
-                { "hex.view.disassembler.name", "Disassembler" },
-                    { "hex.view.disassembler.position", "Position" },
-                    { "hex.view.disassembler.base", "Base address" },
-                    { "hex.view.disassembler.region", "Code region" },
-                    { "hex.view.disassembler.settings.header", "Settings" },
-                    { "hex.view.disassembler.arch", "Architecture" },
-                        { "hex.view.disassembler.arm.arm", "ARM mode" },
-                        { "hex.view.disassembler.arm.thumb", "Thumb mode" },
-                        { "hex.view.disassembler.arm.default", "Default mode" },
-                        { "hex.view.disassembler.arm.cortex_m", "Cortex-M mode" },
-                        { "hex.view.disassembler.arm.armv8", "ARMv8 mode" },
+                { "hex.builtin.view.data_processor.name", "Data Processor" },
+                    { "hex.builtin.view.data_processor.menu.remove_selection", "Remove Selected" },
+                    { "hex.builtin.view.data_processor.menu.remove_node", "Remove Node" },
+                    { "hex.builtin.view.data_processor.menu.remove_link", "Remove Link" },
 
-                        { "hex.view.disassembler.mips.mips32", "MIPS32 mode" },
-                        { "hex.view.disassembler.mips.mips64", "MIPS64 mode" },
-                        { "hex.view.disassembler.mips.mips32R6", "MIPS32R6 mode" },
-                        { "hex.view.disassembler.mips.micro", "Micro mode" },
+                { "hex.builtin.view.disassembler.name", "Disassembler" },
+                    { "hex.builtin.view.disassembler.position", "Position" },
+                    { "hex.builtin.view.disassembler.base", "Base address" },
+                    { "hex.builtin.view.disassembler.region", "Code region" },
+                    { "hex.builtin.view.disassembler.settings.header", "Settings" },
+                    { "hex.builtin.view.disassembler.arch", "Architecture" },
+                        { "hex.builtin.view.disassembler.arm.arm", "ARM mode" },
+                        { "hex.builtin.view.disassembler.arm.thumb", "Thumb mode" },
+                        { "hex.builtin.view.disassembler.arm.default", "Default mode" },
+                        { "hex.builtin.view.disassembler.arm.cortex_m", "Cortex-M mode" },
+                        { "hex.builtin.view.disassembler.arm.armv8", "ARMv8 mode" },
 
-                        { "hex.view.disassembler.x86.16bit", "16-bit mode" },
-                        { "hex.view.disassembler.x86.32bit", "32-bit mode" },
-                        { "hex.view.disassembler.x86.64bit", "64-bit mode" },
+                        { "hex.builtin.view.disassembler.mips.mips32", "MIPS32 mode" },
+                        { "hex.builtin.view.disassembler.mips.mips64", "MIPS64 mode" },
+                        { "hex.builtin.view.disassembler.mips.mips32R6", "MIPS32R6 mode" },
+                        { "hex.builtin.view.disassembler.mips.micro", "Micro mode" },
 
-                        { "hex.view.disassembler.ppc.32bit", "32-bit mode" },
-                        { "hex.view.disassembler.ppc.64bit", "64-bit mode" },
+                        { "hex.builtin.view.disassembler.x86.16bit", "16-bit mode" },
+                        { "hex.builtin.view.disassembler.x86.32bit", "32-bit mode" },
+                        { "hex.builtin.view.disassembler.x86.64bit", "64-bit mode" },
 
-                        { "hex.view.disassembler.sparc.v9", "Sparc V9 mode" },
+                        { "hex.builtin.view.disassembler.ppc.32bit", "32-bit mode" },
+                        { "hex.builtin.view.disassembler.ppc.64bit", "64-bit mode" },
 
-                    { "hex.view.disassembler.disassemble", "Disassemble" },
-                    { "hex.view.disassembler.disassembling", "Disassembling..." },
-                    { "hex.view.disassembler.disassembly.title", "Disassembly" },
-                        { "hex.view.disassembler.disassembly.address", "Address" },
-                        { "hex.view.disassembler.disassembly.offset", "Offset" },
-                        { "hex.view.disassembler.disassembly.bytes", "Byte" },
+                        { "hex.builtin.view.disassembler.sparc.v9", "Sparc V9 mode" },
 
-                { "hex.view.hashes.name", "Hashes" },
-                    { "hex.view.hashes.settings", "Settings" },
-                    { "hex.view.hashes.function", "Hash function" },
-                    { "hex.view.hashes.iv", "Initial value" },
-                    { "hex.view.hashes.xorout", "Final XOR value" },
+                    { "hex.builtin.view.disassembler.disassemble", "Disassemble" },
+                    { "hex.builtin.view.disassembler.disassembling", "Disassembling..." },
+                    { "hex.builtin.view.disassembler.disassembly.title", "Disassembly" },
+                        { "hex.builtin.view.disassembler.disassembly.address", "Address" },
+                        { "hex.builtin.view.disassembler.disassembly.offset", "Offset" },
+                        { "hex.builtin.view.disassembler.disassembly.bytes", "Byte" },
+
+                { "hex.builtin.view.hashes.name", "Hashes" },
+                    { "hex.builtin.view.hashes.settings", "Settings" },
+                    { "hex.builtin.view.hashes.function", "Hash function" },
+                    { "hex.builtin.view.hashes.iv", "Initial value" },
+                    { "hex.builtin.view.hashes.xorout", "Final XOR value" },
                     { "hex.common.reflectIn", "Reflect input" },
                     { "hex.common.reflectOut", "Reflect output" },
-                    { "hex.view.hashes.poly", "Polynomial" },
-                    { "hex.view.hashes.result", "Result" },
+                    { "hex.builtin.view.hashes.poly", "Polynomial" },
+                    { "hex.builtin.view.hashes.result", "Result" },
 
-                { "hex.view.help.name", "Help" },
-                    { "hex.view.help.about.name", "About" },
-                        { "hex.view.help.about.translator", "Translated by WerWolv" },
-                        { "hex.view.help.about.source", "Source code available on GitHub:" },
-                        { "hex.view.help.about.donations", "Donations" },
-                        { "hex.view.help.about.thanks", "If you like my work, please consider donating to keep the project going. Thanks a lot <3" },
-                        { "hex.view.help.about.libs", "Libraries used" },
-                        { "hex.view.help.about.paths", "ImHex Directories" },
-                    { "hex.view.help.documentation", "ImHex Documentation" },
-                    { "hex.view.help.pattern_cheat_sheet", "Pattern Language Cheat Sheet"},
-                    { "hex.view.help.calc_cheat_sheet", "Calculator Cheat Sheet" },
+                { "hex.builtin.view.help.name", "Help" },
+                    { "hex.builtin.view.help.about.name", "About" },
+                        { "hex.builtin.view.help.about.translator", "Translated by WerWolv" },
+                        { "hex.builtin.view.help.about.source", "Source code available on GitHub:" },
+                        { "hex.builtin.view.help.about.donations", "Donations" },
+                        { "hex.builtin.view.help.about.thanks", "If you like my work, please consider donating to keep the project going. Thanks a lot <3" },
+                        { "hex.builtin.view.help.about.contributor", "Contributors" },
+                        { "hex.builtin.view.help.about.libs", "Libraries used" },
+                        { "hex.builtin.view.help.about.paths", "ImHex Directories" },
+                    { "hex.builtin.view.help.documentation", "ImHex Documentation" },
+                    { "hex.builtin.view.help.pattern_cheat_sheet", "Pattern Language Cheat Sheet"},
+                    { "hex.builtin.view.help.calc_cheat_sheet", "Calculator Cheat Sheet" },
 
-                { "hex.view.hexeditor.name", "Hex editor" },
-                    { "hex.view.hexeditor.create_file", "New" },
-                    { "hex.view.hexeditor.open_file", "Open" },
-                    { "hex.view.hexeditor.open_project", "Open Project" },
-                    { "hex.view.hexeditor.save_project", "Save Project" },
-                    { "hex.view.hexeditor.save_data", "Save Data" },
-                    { "hex.view.hexeditor.open_base64", "Open Base64 File" },
-                    { "hex.view.hexeditor.load_enconding_file", "Load custom encoding File" },
-                    { "hex.view.hexeditor.page", "Page {0} / {1}" },
-                    { "hex.view.hexeditor.save_as", "Save As" },
-                    { "hex.view.hexeditor.exit_application.title", "Exit Application?" },
-                    { "hex.view.hexeditor.exit_application.desc", "You have unsaved changes made to your Project.\nAre you sure you want to exit?" },
-                    { "hex.view.hexeditor.script.title", "Load File with Loader Script" },
-                    { "hex.view.hexeditor.script.desc", "Load a file using a Python loader script." },
-                    { "hex.view.hexeditor.script.script", "Script" },
-                        { "hex.view.hexeditor.script.script.title", "Loader Script: Open Script" },
-                    { "hex.view.hexeditor.script.file", "File" },
-                    { "hex.view.hexeditor.script.file.title", "Loader Script: Open File" },
+                { "hex.builtin.view.hexeditor.name", "Hex editor" },
+                    { "hex.builtin.view.hexeditor.create_file", "New" },
+                    { "hex.builtin.view.hexeditor.open_file", "Open" },
+                    { "hex.builtin.view.hexeditor.open_project", "Open Project" },
+                    { "hex.builtin.view.hexeditor.save_project", "Save Project" },
+                    { "hex.builtin.view.hexeditor.save_data", "Save Data" },
+                    { "hex.builtin.view.hexeditor.open_base64", "Open Base64 File" },
+                    { "hex.builtin.view.hexeditor.load_enconding_file", "Load custom encoding File" },
+                    { "hex.builtin.view.hexeditor.page", "Page {0} / {1}" },
+                    { "hex.builtin.view.hexeditor.save_as", "Save As" },
+                    { "hex.builtin.view.hexeditor.exit_application.title", "Exit Application?" },
+                    { "hex.builtin.view.hexeditor.exit_application.desc", "You have unsaved changes made to your Project.\nAre you sure you want to exit?" },
+                    { "hex.builtin.view.hexeditor.script.title", "Load File with Loader Script" },
+                    { "hex.builtin.view.hexeditor.script.desc", "Load a file using a Python loader script." },
+                    { "hex.builtin.view.hexeditor.script.script", "Script" },
+                        { "hex.builtin.view.hexeditor.script.script.title", "Loader Script: Open Script" },
+                    { "hex.builtin.view.hexeditor.script.file", "File" },
+                    { "hex.builtin.view.hexeditor.script.file.title", "Loader Script: Open File" },
 
-                    { "hex.view.hexeditor.menu.file.open_file", "Open File..." },
-                    { "hex.view.hexeditor.menu.file.open_recent", "Open Recent"},
-                    { "hex.view.hexeditor.menu.file.save", "Save" },
-                    { "hex.view.hexeditor.menu.file.save_as", "Save As..." },
-                    { "hex.view.hexeditor.menu.file.close", "Close" },
-                    { "hex.view.hexeditor.menu.file.quit", "Quit ImHex" },
-                    { "hex.view.hexeditor.menu.file.open_project", "Open Project..." },
-                    { "hex.view.hexeditor.menu.file.save_project", "Save Project..." },
-                    { "hex.view.hexeditor.menu.file.load_encoding_file", "Load custom encoding..." },
-                    { "hex.view.hexeditor.menu.file.import", "Import..." },
-                        { "hex.view.hexeditor.menu.file.import.base64", "Base64 File" },
-                        { "hex.view.hexeditor.base64.import_error", "File is not in a valid Base64 format!" },
-                        { "hex.view.hexeditor.file_open_error", "Failed to open file!" },
-                        { "hex.view.hexeditor.menu.file.import.ips", "IPS Patch" },
-                        { "hex.view.hexeditor.menu.file.import.ips32", "IPS32 Patch" },
-                        { "hex.view.hexeditor.menu.file.import.script", "File with Loader Script" },
+                    { "hex.builtin.view.hexeditor.menu.file.open_file", "Open File..." },
+                    { "hex.builtin.view.hexeditor.menu.file.open_recent", "Open Recent" },
+                    { "hex.builtin.view.hexeditor.menu.file.open_other", "Open Other..." },
+                    { "hex.builtin.view.hexeditor.menu.file.save", "Save" },
+                    { "hex.builtin.view.hexeditor.menu.file.save_as", "Save As..." },
+                    { "hex.builtin.view.hexeditor.menu.file.close", "Close" },
+                    { "hex.builtin.view.hexeditor.menu.file.quit", "Quit ImHex" },
+                    { "hex.builtin.view.hexeditor.menu.file.open_project", "Open Project..." },
+                    { "hex.builtin.view.hexeditor.menu.file.save_project", "Save Project..." },
+                    { "hex.builtin.view.hexeditor.menu.file.load_encoding_file", "Load custom encoding..." },
+                    { "hex.builtin.view.hexeditor.menu.file.import", "Import..." },
+                        { "hex.builtin.view.hexeditor.menu.file.import.base64", "Base64 File" },
+                        { "hex.builtin.view.hexeditor.base64.import_error", "File is not in a valid Base64 format!" },
+                        { "hex.builtin.view.hexeditor.file_open_error", "Failed to open file!" },
+                        { "hex.builtin.view.hexeditor.menu.file.import.ips", "IPS Patch" },
+                        { "hex.builtin.view.hexeditor.menu.file.import.ips32", "IPS32 Patch" },
+                        { "hex.builtin.view.hexeditor.menu.file.import.script", "File with Loader Script" },
 
-                    { "hex.view.hexeditor.menu.file.export", "Export..." },
-                        { "hex.view.hexeditor.menu.file.export.title", "Export File" },
-                        { "hex.view.hexeditor.menu.file.export.ips", "IPS Patch" },
-                        { "hex.view.hexeditor.menu.file.export.ips32", "IPS32 Patch" },
-                    { "hex.view.hexeditor.menu.file.search", "Search" },
-                        { "hex.view.hexeditor.search.string", "String" },
-                        { "hex.view.hexeditor.search.hex", "Hex" },
-                        { "hex.view.hexeditor.search.find", "Find" },
-                        { "hex.view.hexeditor.search.find_next", "Find next" },
-                        { "hex.view.hexeditor.search.find_prev", "Find previous" },
-                    { "hex.view.hexeditor.menu.file.goto", "Goto" },
-                        { "hex.view.hexeditor.goto.offset.absolute", "Absolute" },
-                        { "hex.view.hexeditor.goto.offset.current", "Current" },
-                        { "hex.view.hexeditor.goto.offset.begin", "Begin" },
-                        { "hex.view.hexeditor.goto.offset.end", "End" },
-                    { "hex.view.hexeditor.error.read_only", "Couldn't get write access. File opened in read-only mode." },
-                    { "hex.view.hexeditor.error.open", "Failed to open file!" },
-                    { "hex.view.hexeditor.error.create", "Failed to create new file!" },
-                    { "hex.view.hexeditor.menu.edit.undo", "Undo" },
-                    { "hex.view.hexeditor.menu.edit.redo", "Redo" },
-                    { "hex.view.hexeditor.menu.edit.copy", "Copy" },
-                    { "hex.view.hexeditor.menu.edit.copy_as", "Copy as..." },
-                        { "hex.view.hexeditor.copy.hex", "String" },
-                        { "hex.view.hexeditor.copy.c", "C Array" },
-                        { "hex.view.hexeditor.copy.cpp", "C++ Array" },
-                        { "hex.view.hexeditor.copy.csharp", "C# Array" },
-                        { "hex.view.hexeditor.copy.rust", "Rust Array" },
-                        { "hex.view.hexeditor.copy.python", "Python Array" },
-                        { "hex.view.hexeditor.copy.java", "Java Array" },
-                        { "hex.view.hexeditor.copy.js", "JavaScript Array" },
-                        { "hex.view.hexeditor.copy.ascii", "ASCII Art" },
-                        { "hex.view.hexeditor.copy.html", "HTML" },
-                    { "hex.view.hexeditor.menu.edit.paste", "Paste" },
-                    { "hex.view.hexeditor.menu.edit.select_all", "Select all" },
-                    { "hex.view.hexeditor.menu.edit.bookmark", "Create bookmark" },
-                    { "hex.view.hexeditor.menu.edit.set_base", "Set base address" },
-                    { "hex.view.hexeditor.menu.edit.resize", "Resize" },
+                    { "hex.builtin.view.hexeditor.menu.file.export", "Export..." },
+                        { "hex.builtin.view.hexeditor.menu.file.export.title", "Export File" },
+                        { "hex.builtin.view.hexeditor.menu.file.export.ips", "IPS Patch" },
+                        { "hex.builtin.view.hexeditor.menu.file.export.ips32", "IPS32 Patch" },
+                    { "hex.builtin.view.hexeditor.menu.file.search", "Search" },
+                        { "hex.builtin.view.hexeditor.search.string", "String" },
+                        { "hex.builtin.view.hexeditor.search.hex", "Hex" },
+                        { "hex.builtin.view.hexeditor.search.find", "Find" },
+                        { "hex.builtin.view.hexeditor.search.find_next", "Find next" },
+                        { "hex.builtin.view.hexeditor.search.find_prev", "Find previous" },
+                    { "hex.builtin.view.hexeditor.menu.file.goto", "Goto" },
+                        { "hex.builtin.view.hexeditor.goto.offset.absolute", "Absolute" },
+                        { "hex.builtin.view.hexeditor.goto.offset.current", "Current" },
+                        { "hex.builtin.view.hexeditor.goto.offset.begin", "Begin" },
+                        { "hex.builtin.view.hexeditor.goto.offset.end", "End" },
+                    { "hex.builtin.view.hexeditor.error.read_only", "Couldn't get write access. File opened in read-only mode." },
+                    { "hex.builtin.view.hexeditor.error.open", "Failed to open file!" },
+                    { "hex.builtin.view.hexeditor.error.create", "Failed to create new file!" },
+                    { "hex.builtin.view.hexeditor.menu.edit.undo", "Undo" },
+                    { "hex.builtin.view.hexeditor.menu.edit.redo", "Redo" },
+                    { "hex.builtin.view.hexeditor.menu.edit.copy", "Copy" },
+                    { "hex.builtin.view.hexeditor.menu.edit.copy_as", "Copy as..." },
+                        { "hex.builtin.view.hexeditor.copy.hex", "String" },
+                        { "hex.builtin.view.hexeditor.copy.c", "C Array" },
+                        { "hex.builtin.view.hexeditor.copy.cpp", "C++ Array" },
+                        { "hex.builtin.view.hexeditor.copy.csharp", "C# Array" },
+                        { "hex.builtin.view.hexeditor.copy.rust", "Rust Array" },
+                        { "hex.builtin.view.hexeditor.copy.python", "Python Array" },
+                        { "hex.builtin.view.hexeditor.copy.java", "Java Array" },
+                        { "hex.builtin.view.hexeditor.copy.js", "JavaScript Array" },
+                        { "hex.builtin.view.hexeditor.copy.ascii", "ASCII Art" },
+                        { "hex.builtin.view.hexeditor.copy.html", "HTML" },
+                    { "hex.builtin.view.hexeditor.menu.edit.paste", "Paste" },
+                    { "hex.builtin.view.hexeditor.menu.edit.select_all", "Select all" },
+                    { "hex.builtin.view.hexeditor.menu.edit.bookmark", "Create bookmark" },
+                    { "hex.builtin.view.hexeditor.menu.edit.set_base", "Set base address" },
+                    { "hex.builtin.view.hexeditor.menu.edit.resize", "Resize" },
 
-                { "hex.view.information.name", "Data Information" },
-                    { "hex.view.information.control", "Control" },
-                    { "hex.view.information.analyze", "Analyze page" },
-                    { "hex.view.information.analyzing", "Analyzing..." },
-                    { "hex.view.information.region", "Analyzed region" },
-                    { "hex.view.information.magic", "Magic information" },
-                    { "hex.view.information.description", "Description:" },
-                    { "hex.view.information.mime", "MIME Type:" },
-                    { "hex.view.information.info_analysis", "Information analysis" },
-                    { "hex.view.information.distribution", "Byte distribution" },
-                    { "hex.view.information.entropy", "Entropy" },
-                    { "hex.view.information.block_size", "Block size" },
-                    { "hex.view.information.block_size.desc", "{0} blocks of {1} bytes" },
-                    { "hex.view.information.file_entropy", "File entropy" },
-                    { "hex.view.information.highest_entropy", "Highest entropy block" },
-                    { "hex.view.information.encrypted", "This data is most likely encrypted or compressed!" },
+                { "hex.builtin.view.information.name", "Data Information" },
+                    { "hex.builtin.view.information.control", "Control" },
+                    { "hex.builtin.view.information.analyze", "Analyze page" },
+                    { "hex.builtin.view.information.analyzing", "Analyzing..." },
+                    { "hex.builtin.view.information.region", "Analyzed region" },
+                    { "hex.builtin.view.information.magic", "Magic information" },
+                    { "hex.builtin.view.information.description", "Description:" },
+                    { "hex.builtin.view.information.mime", "MIME Type:" },
+                    { "hex.builtin.view.information.info_analysis", "Information analysis" },
+                    { "hex.builtin.view.information.distribution", "Byte distribution" },
+                    { "hex.builtin.view.information.entropy", "Entropy" },
+                    { "hex.builtin.view.information.block_size", "Block size" },
+                    { "hex.builtin.view.information.block_size.desc", "{0} blocks of {1} bytes" },
+                    { "hex.builtin.view.information.file_entropy", "File entropy" },
+                    { "hex.builtin.view.information.highest_entropy", "Highest entropy block" },
+                    { "hex.builtin.view.information.encrypted", "This data is most likely encrypted or compressed!" },
 
-                { "hex.view.patches.name", "Patches" },
-                    { "hex.view.patches.offset", "Offset" },
-                    { "hex.view.patches.orig", "Original value" },
-                    { "hex.view.patches.patch", "Patched value"},
-                    { "hex.view.patches.remove", "Remove patch" },
+                { "hex.builtin.view.patches.name", "Patches" },
+                    { "hex.builtin.view.patches.offset", "Offset" },
+                    { "hex.builtin.view.patches.orig", "Original value" },
+                    { "hex.builtin.view.patches.patch", "Patched value"},
+                    { "hex.builtin.view.patches.remove", "Remove patch" },
 
-                { "hex.view.pattern.name", "Pattern editor" },
-                { "hex.view.pattern.accept_pattern", "Accept pattern" },
-                    { "hex.view.pattern.accept_pattern.desc", "One or more pattern_language compatible with this data type has been found" },
-                    { "hex.view.pattern.accept_pattern.pattern_language", "Patterns" },
-                    { "hex.view.pattern.accept_pattern.question", "Do you want to apply the selected pattern?" },
-                { "hex.view.pattern.menu.file.load_pattern", "Load pattern..." },
-                { "hex.view.pattern.open_pattern", "Open pattern" },
-                { "hex.view.pattern.evaluating", "Evaluating..." },
-                { "hex.view.pattern.auto", "Auto evaluate" },
+                { "hex.builtin.view.pattern_editor.name", "Pattern editor" },
+                { "hex.builtin.view.pattern_editor.accept_pattern", "Accept pattern" },
+                    { "hex.builtin.view.pattern_editor.accept_pattern.desc", "One or more pattern_language compatible with this data type has been found" },
+                    { "hex.builtin.view.pattern_editor.accept_pattern.pattern_language", "Patterns" },
+                    { "hex.builtin.view.pattern_editor.accept_pattern.question", "Do you want to apply the selected pattern?" },
+                { "hex.builtin.view.pattern_editor.menu.file.load_pattern", "Load pattern..." },
+                { "hex.builtin.view.pattern_editor.menu.file.save_pattern", "Save pattern..." },
+                { "hex.builtin.view.pattern_editor.open_pattern", "Open pattern" },
+                { "hex.builtin.view.pattern_editor.evaluating", "Evaluating..." },
+                { "hex.builtin.view.pattern_editor.auto", "Auto evaluate" },
+                { "hex.builtin.view.pattern_editor.env_vars", "Environment Variables" },
 
-                { "hex.view.pattern_data.name", "Pattern Data" },
-                    { "hex.view.pattern_data.var_name", "Name" },
-                    { "hex.view.pattern_data.color", "Color" },
-                    { "hex.view.pattern_data.offset", "Offset" },
-                    { "hex.view.pattern_data.size", "Size" },
-                    { "hex.view.pattern_data.type", "Type" },
-                    { "hex.view.pattern_data.value", "Value" },
+                { "hex.builtin.view.pattern_data.name", "Pattern Data" },
+                    { "hex.builtin.view.pattern_data.var_name", "Name" },
+                    { "hex.builtin.view.pattern_data.color", "Color" },
+                    { "hex.builtin.view.pattern_data.offset", "Offset" },
+                    { "hex.builtin.view.pattern_data.size", "Size" },
+                    { "hex.builtin.view.pattern_data.type", "Type" },
+                    { "hex.builtin.view.pattern_data.value", "Value" },
 
-                { "hex.view.settings.name", "Settings" },
+                { "hex.builtin.view.settings.name", "Settings" },
 
-                { "hex.view.strings.name", "Strings" },
-                    { "hex.view.strings.copy", "Copy string" },
-                    { "hex.view.strings.demangle", "Demangle" },
-                    { "hex.view.strings.min_length", "Minimum length" },
-                    { "hex.view.strings.filter", "Filter" },
-                    { "hex.view.strings.extract", "Extract" },
-                    { "hex.view.strings.regex_error", "Invalid regex" },
-                    { "hex.view.strings.results", "Found {0} occurrences" },
-                    { "hex.view.strings.searching", "Searching..." },
-                    { "hex.view.strings.offset", "Offset" },
-                    { "hex.view.strings.size", "Size" },
-                    { "hex.view.strings.string", "String" },
-                    { "hex.view.strings.demangle.title", "Demangled name" },
-                    { "hex.view.strings.demangle.copy", "Copy" },
+                { "hex.builtin.view.strings.name", "Strings" },
+                    { "hex.builtin.view.strings.copy", "Copy string" },
+                    { "hex.builtin.view.strings.demangle", "Demangle" },
+                    { "hex.builtin.view.strings.min_length", "Minimum length" },
+                    { "hex.builtin.view.strings.filter", "Filter" },
+                    { "hex.builtin.view.strings.extract", "Extract" },
+                    { "hex.builtin.view.strings.regex_error", "Invalid regex" },
+                    { "hex.builtin.view.strings.results", "Found {0} occurrences" },
+                    { "hex.builtin.view.strings.searching", "Searching..." },
+                    { "hex.builtin.view.strings.offset", "Offset" },
+                    { "hex.builtin.view.strings.size", "Size" },
+                    { "hex.builtin.view.strings.string", "String" },
+                    { "hex.builtin.view.strings.demangle.title", "Demangled name" },
+                    { "hex.builtin.view.strings.demangle.copy", "Copy" },
 
-                { "hex.view.tools.name", "Tools" },
+                { "hex.builtin.view.tools.name", "Tools" },
 
-                { "hex.view.yara.name", "Yara Rules" },
-                    { "hex.view.yara.header.rules", "Rules" },
-                        { "hex.view.yara.reload", "Reload" },
-                        { "hex.view.yara.match", "Match Rules" },
-                        { "hex.view.yara.matching", "Matching..." },
-                        { "hex.view.yara.error", "Yara Compiler error: " },
-                    { "hex.view.yara.header.matches", "Matches" },
-                        { "hex.view.yara.matches.identifier", "Identifier" },
-                        { "hex.view.yara.matches.variable", "Variable" },
-                        { "hex.view.yara.whole_data", "Whole file matches!" },
-                        { "hex.view.yara.no_rules", "No YARA rules found. Put them in ImHex's 'yara' folder" },
+                { "hex.builtin.view.yara.name", "Yara Rules" },
+                    { "hex.builtin.view.yara.header.rules", "Rules" },
+                        { "hex.builtin.view.yara.reload", "Reload" },
+                        { "hex.builtin.view.yara.match", "Match Rules" },
+                        { "hex.builtin.view.yara.matching", "Matching..." },
+                        { "hex.builtin.view.yara.error", "Yara Compiler error: " },
+                    { "hex.builtin.view.yara.header.matches", "Matches" },
+                        { "hex.builtin.view.yara.matches.identifier", "Identifier" },
+                        { "hex.builtin.view.yara.matches.variable", "Variable" },
+                        { "hex.builtin.view.yara.whole_data", "Whole file matches!" },
+                        { "hex.builtin.view.yara.no_rules", "No YARA rules found. Put them in ImHex's 'yara' folder" },
 
-                { "hex.view.constants.name", "Constants" },
-                    { "hex.view.constants.row.category", "Category" },
-                    { "hex.view.constants.row.name", "Name" },
-                    { "hex.view.constants.row.desc", "Description" },
-                    { "hex.view.constants.row.value", "Value" },
+                { "hex.builtin.view.constants.name", "Constants" },
+                    { "hex.builtin.view.constants.row.category", "Category" },
+                    { "hex.builtin.view.constants.row.name", "Name" },
+                    { "hex.builtin.view.constants.row.desc", "Description" },
+                    { "hex.builtin.view.constants.row.value", "Value" },
 
-                { "hex.view.store.name", "Content Store" },
-                    { "hex.view.store.desc", "Download new content from ImHex's online database" },
-                    { "hex.view.store.reload", "Reload" },
-                    { "hex.view.store.row.name", "Name" },
-                    { "hex.view.store.row.description", "Description" },
-                    { "hex.view.store.download", "Download" },
-                    { "hex.view.store.update", "Update" },
-                    { "hex.view.store.remove", "Remove" },
-                    { "hex.view.store.tab.patterns", "Patterns" },
-                    { "hex.view.store.tab.libraries", "Libraries" },
-                    { "hex.view.store.tab.magics", "Magic Files" },
-                    { "hex.view.store.tab.constants", "Constants" },
-                    { "hex.view.store.tab.yara", "Yara Rules" },
-                    { "hex.view.store.loading", "Loading store content..." },
-                { "hex.view.diff.name", "Diffing" },
+                { "hex.builtin.view.store.name", "Content Store" },
+                    { "hex.builtin.view.store.desc", "Download new content from ImHex's online database" },
+                    { "hex.builtin.view.store.reload", "Reload" },
+                    { "hex.builtin.view.store.row.name", "Name" },
+                    { "hex.builtin.view.store.row.description", "Description" },
+                    { "hex.builtin.view.store.download", "Download" },
+                    { "hex.builtin.view.store.update", "Update" },
+                    { "hex.builtin.view.store.remove", "Remove" },
+                    { "hex.builtin.view.store.tab.patterns", "Patterns" },
+                    { "hex.builtin.view.store.tab.libraries", "Libraries" },
+                    { "hex.builtin.view.store.tab.magics", "Magic Files" },
+                    { "hex.builtin.view.store.tab.constants", "Constants" },
+                    { "hex.builtin.view.store.tab.yara", "Yara Rules" },
+                    { "hex.builtin.view.store.loading", "Loading store content..." },
+                { "hex.builtin.view.diff.name", "Diffing" },
 
-
-            /* Builtin plugin features */
+                { "hex.builtin.view.provider_settings.name", "Provider Settings" },
+                    { "hex.builtin.view.provider_settings.load_popup", "Open Provider" },
 
                 { "hex.builtin.command.calc.desc", "Calculator" },
                 { "hex.builtin.command.cmd.desc", "Command" },
@@ -669,6 +676,18 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.provider.file.creation", "Creation time" },
                 { "hex.builtin.provider.file.access", "Last access time" },
                 { "hex.builtin.provider.file.modification", "Last modification time" },
+
+                { "hex.builtin.provider.file", "File Provider" },
+                { "hex.builtin.provider.gdb", "GDB Server Provider" },
+                    { "hex.builtin.provider.gdb.name", "GDB Server <{0}:{1}>" },
+                    { "hex.builtin.provider.gdb.server", "Server" },
+                    { "hex.builtin.provider.gdb.ip", "IP Address" },
+                    { "hex.builtin.provider.gdb.port", "Port" },
+                { "hex.builtin.provider.disk", "Raw Disk Provider" },
+                    { "hex.builtin.provider.disk.selected_disk", "Disk" },
+                    { "hex.builtin.provider.disk.disk_size", "Disk Size" },
+                    { "hex.builtin.provider.disk.sector_size", "Sector Size" },
+                    { "hex.builtin.provider.disk.reload", "Reload" },
         });
     }
 

plugins/builtin/source/lang/it_IT.cpp

@@ -23,6 +23,7 @@ namespace hex::plugin::builtin {
                     { "hex.welcome.start.open_file", "Apri un File" },
                     { "hex.welcome.start.open_project", "Apri un Progetto" },
                     { "hex.welcome.start.recent", "File recenti" },
+                    //{ "hex.welcome.start.open_other", "Other Providers" },
                 { "hex.welcome.header.help", "Aiuto" },
                     { "hex.welcome.help.repo", "Repo GitHub" },
                         { "hex.welcome.help.repo.link", "https://github.com/WerWolv/ImHex" },
@@ -85,248 +86,255 @@ namespace hex::plugin::builtin {
                 //{ "hex.message.yara_rule_added", "Yara rule added!" },
                 //{ "hex.message.magic_db_added", "Magic database added!" },
 
-                { "hex.view.bookmarks.name", "Segnalibri" },
-                    { "hex.view.bookmarks.default_title", "Segnalibro [0x{0:X} - 0x{1:X}]" },
-                    { "hex.view.bookmarks.no_bookmarks", "Non è stato creato alcun segnalibro. Aggiungine uno andando su Modifica -> Crea Segnalibro" },
-                    { "hex.view.bookmarks.title.info", "Informazioni" },
-                    { "hex.view.bookmarks.address", "0x{0:X} : 0x{1:X} ({2} bytes)" },
-                    { "hex.view.bookmarks.button.jump", "Vai a" },
-                    { "hex.view.bookmarks.button.remove", "Rimuovi" },
-                    { "hex.view.bookmarks.header.name", "Nome" },
-                    { "hex.view.bookmarks.header.color", "Colore" },
-                    { "hex.view.bookmarks.header.comment", "Commento" },
+                /* Builtin plugin features */
 
-                { "hex.view.command_palette.name", "Tavola dei Comandi" },
+                { "hex.builtin.view.bookmarks.name", "Segnalibri" },
+                    { "hex.builtin.view.bookmarks.default_title", "Segnalibro [0x{0:X} - 0x{1:X}]" },
+                    { "hex.builtin.view.bookmarks.no_bookmarks", "Non è stato creato alcun segnalibro. Aggiungine uno andando su Modifica -> Crea Segnalibro" },
+                    { "hex.builtin.view.bookmarks.title.info", "Informazioni" },
+                    { "hex.builtin.view.bookmarks.address", "0x{0:X} : 0x{1:X} ({2} bytes)" },
+                    { "hex.builtin.view.bookmarks.button.jump", "Vai a" },
+                    { "hex.builtin.view.bookmarks.button.remove", "Rimuovi" },
+                    { "hex.builtin.view.bookmarks.header.name", "Nome" },
+                    { "hex.builtin.view.bookmarks.header.color", "Colore" },
+                    { "hex.builtin.view.bookmarks.header.comment", "Commento" },
 
-                { "hex.view.data_inspector.name", "Ispezione Dati" },
-                    { "hex.view.data_inspector.table.name", "Nome" },
-                    { "hex.view.data_inspector.table.value", "Valore" },
-                    //{ "hex.view.data_inspector.no_data", "No bytes selected"},
+                { "hex.builtin.view.command_palette.name", "Tavola dei Comandi" },
+
+                { "hex.builtin.view.data_inspector.name", "Ispezione Dati" },
+                    { "hex.builtin.view.data_inspector.table.name", "Nome" },
+                    { "hex.builtin.view.data_inspector.table.value", "Valore" },
+                    //{ "hex.builtin.view.data_inspector.no_data", "No bytes selected"},
 
 
-                { "hex.view.data_processor.name", "Processa Dati"  },
-                    { "hex.view.data_processor.menu.remove_selection", "Rimuovi i selezionati" },
-                    { "hex.view.data_processor.menu.remove_node", "Rimuovi Nodo" },
-                    { "hex.view.data_processor.menu.remove_link", "Rimuovi Link" },
+                { "hex.builtin.view.data_processor.name", "Processa Dati"  },
+                    { "hex.builtin.view.data_processor.menu.remove_selection", "Rimuovi i selezionati" },
+                    { "hex.builtin.view.data_processor.menu.remove_node", "Rimuovi Nodo" },
+                    { "hex.builtin.view.data_processor.menu.remove_link", "Rimuovi Link" },
 
-                  { "hex.view.disassembler.name", "Disassembla" },
-                    { "hex.view.disassembler.position", "Posiziona" },
-                    { "hex.view.disassembler.base", "Indirizzo di base" },
-                    { "hex.view.disassembler.region", "Regione del Codice" },
-                    { "hex.view.disassembler.settings.header", "Impostazioni" },
-                    { "hex.view.disassembler.arch", "Architettura" },
-                        { "hex.view.disassembler.arm.arm", "Modalità ARM" },
-                        { "hex.view.disassembler.arm.thumb", "Modalità Thumb" },
-                        { "hex.view.disassembler.arm.default", "Modalità di Default" },
-                        { "hex.view.disassembler.arm.cortex_m", "Modalità Cortex-M" },
-                        { "hex.view.disassembler.arm.armv8", "Modalità ARMv8" },
+                  { "hex.builtin.view.disassembler.name", "Disassembla" },
+                    { "hex.builtin.view.disassembler.position", "Posiziona" },
+                    { "hex.builtin.view.disassembler.base", "Indirizzo di base" },
+                    { "hex.builtin.view.disassembler.region", "Regione del Codice" },
+                    { "hex.builtin.view.disassembler.settings.header", "Impostazioni" },
+                    { "hex.builtin.view.disassembler.arch", "Architettura" },
+                        { "hex.builtin.view.disassembler.arm.arm", "Modalità ARM" },
+                        { "hex.builtin.view.disassembler.arm.thumb", "Modalità Thumb" },
+                        { "hex.builtin.view.disassembler.arm.default", "Modalità di Default" },
+                        { "hex.builtin.view.disassembler.arm.cortex_m", "Modalità Cortex-M" },
+                        { "hex.builtin.view.disassembler.arm.armv8", "Modalità ARMv8" },
 
-                        { "hex.view.disassembler.mips.mips32", "Modalità MIPS32" },
-                        { "hex.view.disassembler.mips.mips64", "Modalità MIPS64" },
-                        { "hex.view.disassembler.mips.mips32R6", "Modalità MIPS32R6" },
-                        { "hex.view.disassembler.mips.micro", "Modalità Micro" },
+                        { "hex.builtin.view.disassembler.mips.mips32", "Modalità MIPS32" },
+                        { "hex.builtin.view.disassembler.mips.mips64", "Modalità MIPS64" },
+                        { "hex.builtin.view.disassembler.mips.mips32R6", "Modalità MIPS32R6" },
+                        { "hex.builtin.view.disassembler.mips.micro", "Modalità Micro" },
 
-                        { "hex.view.disassembler.x86.16bit", "Modalità 16-bit" },
-                        { "hex.view.disassembler.x86.32bit", "Modalità 32-bit" },
-                        { "hex.view.disassembler.x86.64bit", "Modalità 64-bit" },
+                        { "hex.builtin.view.disassembler.x86.16bit", "Modalità 16-bit" },
+                        { "hex.builtin.view.disassembler.x86.32bit", "Modalità 32-bit" },
+                        { "hex.builtin.view.disassembler.x86.64bit", "Modalità 64-bit" },
 
-                        { "hex.view.disassembler.ppc.32bit", "Modalità 32-bit" },
-                        { "hex.view.disassembler.ppc.64bit", "Modalità 64-bit" },
+                        { "hex.builtin.view.disassembler.ppc.32bit", "Modalità 32-bit" },
+                        { "hex.builtin.view.disassembler.ppc.64bit", "Modalità 64-bit" },
 
-                        { "hex.view.disassembler.sparc.v9", "Modalità Sparc V9" },
+                        { "hex.builtin.view.disassembler.sparc.v9", "Modalità Sparc V9" },
 
-                    { "hex.view.disassembler.disassemble", "Disassembla" },
-                    { "hex.view.disassembler.disassembling", "Disassemblaggio..." },
-                    { "hex.view.disassembler.disassembly.title", "Disassembla" },
-                        { "hex.view.disassembler.disassembly.address", "Indirizzo" },
-                        { "hex.view.disassembler.disassembly.offset", "Offset" },
-                        { "hex.view.disassembler.disassembly.bytes", "Byte" },
+                    { "hex.builtin.view.disassembler.disassemble", "Disassembla" },
+                    { "hex.builtin.view.disassembler.disassembling", "Disassemblaggio..." },
+                    { "hex.builtin.view.disassembler.disassembly.title", "Disassembla" },
+                        { "hex.builtin.view.disassembler.disassembly.address", "Indirizzo" },
+                        { "hex.builtin.view.disassembler.disassembly.offset", "Offset" },
+                        { "hex.builtin.view.disassembler.disassembly.bytes", "Byte" },
 
-                { "hex.view.hashes.name", "Hash" },
-                    { "hex.view.hashes.settings", "Impostazioni" },
-                    { "hex.view.hashes.function", "Funzioni di Hash" },
-                    { "hex.view.hashes.iv", "Valore Iniziale" },
-                    { "hex.view.hashes.poly", "Polinomio" },
-                    { "hex.view.hashes.result", "Risultato" },
+                { "hex.builtin.view.hashes.name", "Hash" },
+                    { "hex.builtin.view.hashes.settings", "Impostazioni" },
+                    { "hex.builtin.view.hashes.function", "Funzioni di Hash" },
+                    { "hex.builtin.view.hashes.iv", "Valore Iniziale" },
+                    { "hex.builtin.view.hashes.poly", "Polinomio" },
+                    { "hex.builtin.view.hashes.result", "Risultato" },
 
-                { "hex.view.help.name", "Aiuto" },
-                    { "hex.view.help.about.name", "Riguardo ImHex" },
-                        { "hex.view.help.about.translator", "Tradotto da CrustySeanPro" },
-                        { "hex.view.help.about.source", "Codice Sorgente disponibile su GitHub:" },
-                        { "hex.view.help.about.donations", "Donazioni" },
-                        { "hex.view.help.about.thanks", "Se ti piace il mio lavoro, per favore considera di fare una donazione. Grazie mille <3" },
-                        { "hex.view.help.about.libs", "Librerie usate" },
-                        { "hex.view.help.about.paths", "ImHex cartelle" },
-                    { "hex.view.help.documentation", "Documentazione di ImHex" },
-                    { "hex.view.help.pattern_cheat_sheet", "Pattern Language Cheat Sheet"},
-                    { "hex.view.help.calc_cheat_sheet", "Calcolatrice Cheat Sheet" },
+                { "hex.builtin.view.help.name", "Aiuto" },
+                    { "hex.builtin.view.help.about.name", "Riguardo ImHex" },
+                        { "hex.builtin.view.help.about.translator", "Tradotto da CrustySeanPro" },
+                        { "hex.builtin.view.help.about.source", "Codice Sorgente disponibile su GitHub:" },
+                        { "hex.builtin.view.help.about.donations", "Donazioni" },
+                        { "hex.builtin.view.help.about.thanks", "Se ti piace il mio lavoro, per favore considera di fare una donazione. Grazie mille <3" },
+                        //{ "hex.builtin.view.help.about.contributor", "Contributors" },
+                        { "hex.builtin.view.help.about.libs", "Librerie usate" },
+                        { "hex.builtin.view.help.about.paths", "ImHex cartelle" },
+                    { "hex.builtin.view.help.documentation", "Documentazione di ImHex" },
+                    { "hex.builtin.view.help.pattern_cheat_sheet", "Pattern Language Cheat Sheet"},
+                    { "hex.builtin.view.help.calc_cheat_sheet", "Calcolatrice Cheat Sheet" },
 
-                { "hex.view.hexeditor.name", "Hex editor" },
-                    { "hex.view.hexeditor.create_file", "Nuovo" },
-                    { "hex.view.hexeditor.open_file", "Apri" },
-                    { "hex.view.hexeditor.menu.file.open_recent", "File recenti" },
-                    { "hex.view.hexeditor.open_project", "Apri i Progetti" },
-                    { "hex.view.hexeditor.save_project", "Salva i Progetti" },
-                    { "hex.view.hexeditor.save_data", "Salva i Dati" },
-                    { "hex.view.hexeditor.open_base64", "Apri Base64 File" },
-                    { "hex.view.hexeditor.load_enconding_file", "Carica un File di codfica personalizzato" },
-                    { "hex.view.hexeditor.page", "Pagina {0} / {1}" },
-                    { "hex.view.hexeditor.save_as", "Salva come" },
-                    { "hex.view.hexeditor.exit_application.title", "Uscire dall'applicazione?" },
-                    { "hex.view.hexeditor.exit_application.desc", "Hai delle modifiche non salvate nel tuo progetto.\nSei sicuro di voler uscire?" },
-                    { "hex.view.hexeditor.script.title", "Carica un File tramite il Caricatore di Script" },
-                    { "hex.view.hexeditor.script.desc", "Carica un file tramite il Caricatore di Script di Python." },
-                    { "hex.view.hexeditor.script.script", "Script" },
-                        { "hex.view.hexeditor.script.script.title", "Caricatore Script: Apri Script" },
-                    { "hex.view.hexeditor.script.file", "File" },
-                    { "hex.view.hexeditor.script.file.title", "Caricatore Script: Apri File" },
+                { "hex.builtin.view.hexeditor.name", "Hex editor" },
+                    { "hex.builtin.view.hexeditor.create_file", "Nuovo" },
+                    { "hex.builtin.view.hexeditor.open_file", "Apri" },
+                    { "hex.builtin.view.hexeditor.menu.file.open_recent", "File recenti" },
+                    //{ "hex.builtin.view.hexeditor.menu.file.open_other", "Open Other..." },
+                    { "hex.builtin.view.hexeditor.open_project", "Apri i Progetti" },
+                    { "hex.builtin.view.hexeditor.save_project", "Salva i Progetti" },
+                    { "hex.builtin.view.hexeditor.save_data", "Salva i Dati" },
+                    { "hex.builtin.view.hexeditor.open_base64", "Apri Base64 File" },
+                    { "hex.builtin.view.hexeditor.load_enconding_file", "Carica un File di codfica personalizzato" },
+                    { "hex.builtin.view.hexeditor.page", "Pagina {0} / {1}" },
+                    { "hex.builtin.view.hexeditor.save_as", "Salva come" },
+                    { "hex.builtin.view.hexeditor.exit_application.title", "Uscire dall'applicazione?" },
+                    { "hex.builtin.view.hexeditor.exit_application.desc", "Hai delle modifiche non salvate nel tuo progetto.\nSei sicuro di voler uscire?" },
+                    { "hex.builtin.view.hexeditor.script.title", "Carica un File tramite il Caricatore di Script" },
+                    { "hex.builtin.view.hexeditor.script.desc", "Carica un file tramite il Caricatore di Script di Python." },
+                    { "hex.builtin.view.hexeditor.script.script", "Script" },
+                        { "hex.builtin.view.hexeditor.script.script.title", "Caricatore Script: Apri Script" },
+                    { "hex.builtin.view.hexeditor.script.file", "File" },
+                    { "hex.builtin.view.hexeditor.script.file.title", "Caricatore Script: Apri File" },
 
-                    { "hex.view.hexeditor.menu.file.open_file", "Apri File..." },
-                    { "hex.view.hexeditor.menu.file.save", "Salva" },
-                    { "hex.view.hexeditor.menu.file.save_as", "Salva come..." },
-                    { "hex.view.hexeditor.menu.file.close", "Chiudi" },
-                    { "hex.view.hexeditor.menu.file.quit", "Uscita ImHex" },
-                    { "hex.view.hexeditor.menu.file.open_project", "Apri un Progetto..." },
-                    { "hex.view.hexeditor.menu.file.save_project", "Salva Progetto..." },
-                    { "hex.view.hexeditor.menu.file.load_encoding_file", "Carica una codifica personalizzata..." },
-                    { "hex.view.hexeditor.menu.file.import", "Importa..." },
-                        { "hex.view.hexeditor.menu.file.import.base64", "Base64 File" },
-                        { "hex.view.hexeditor.base64.import_error", "Il file non è in un formato bas64 corretto!" },
-                        { "hex.view.hexeditor.file_open_error", "Impossibile aprire il File!" },
-                        { "hex.view.hexeditor.menu.file.import.ips", "IPS Patch" },
-                        { "hex.view.hexeditor.menu.file.import.ips32", "IPS32 Patch" },
-                        { "hex.view.hexeditor.menu.file.import.script", "File con il Caricatore di Script" },
+                    { "hex.builtin.view.hexeditor.menu.file.open_file", "Apri File..." },
+                    { "hex.builtin.view.hexeditor.menu.file.save", "Salva" },
+                    { "hex.builtin.view.hexeditor.menu.file.save_as", "Salva come..." },
+                    { "hex.builtin.view.hexeditor.menu.file.close", "Chiudi" },
+                    { "hex.builtin.view.hexeditor.menu.file.quit", "Uscita ImHex" },
+                    { "hex.builtin.view.hexeditor.menu.file.open_project", "Apri un Progetto..." },
+                    { "hex.builtin.view.hexeditor.menu.file.save_project", "Salva Progetto..." },
+                    { "hex.builtin.view.hexeditor.menu.file.load_encoding_file", "Carica una codifica personalizzata..." },
+                    { "hex.builtin.view.hexeditor.menu.file.import", "Importa..." },
+                        { "hex.builtin.view.hexeditor.menu.file.import.base64", "Base64 File" },
+                        { "hex.builtin.view.hexeditor.base64.import_error", "Il file non è in un formato bas64 corretto!" },
+                        { "hex.builtin.view.hexeditor.file_open_error", "Impossibile aprire il File!" },
+                        { "hex.builtin.view.hexeditor.menu.file.import.ips", "IPS Patch" },
+                        { "hex.builtin.view.hexeditor.menu.file.import.ips32", "IPS32 Patch" },
+                        { "hex.builtin.view.hexeditor.menu.file.import.script", "File con il Caricatore di Script" },
 
-                    { "hex.view.hexeditor.menu.file.export", "Esporta..." },
-                        { "hex.view.hexeditor.menu.file.export.title", "Esporta File" },
-                        { "hex.view.hexeditor.menu.file.export.ips", "IPS Patch" },
-                        { "hex.view.hexeditor.menu.file.export.ips32", "IPS32 Patch" },
-                    { "hex.view.hexeditor.menu.file.search", "Cerca" },
-                        { "hex.view.hexeditor.search.string", "Stringa" },
-                        { "hex.view.hexeditor.search.hex", "Hex" },
-                        { "hex.view.hexeditor.search.find", "Cerca" },
-                        { "hex.view.hexeditor.search.find_next", "Cerca il prossimo" },
-                        { "hex.view.hexeditor.search.find_prev", "Cerca il precedente" },
-                    { "hex.view.hexeditor.menu.file.goto", "Vai a" },
-                        { "hex.view.hexeditor.goto.offset.absolute", "Assoluto" },
-                        { "hex.view.hexeditor.goto.offset.current", "Corrente" },
-                        { "hex.view.hexeditor.goto.offset.begin", "Inizo" },
-                        { "hex.view.hexeditor.goto.offset.end", "Fine" },
-                    { "hex.view.hexeditor.error.read_only", "Impossibile scrivere sul File. File aperto solo in modalità lettura" },
-                    { "hex.view.hexeditor.error.open", "Impossibile aprire il File!" },
-                    { "hex.view.hexeditor.error.create", "Impossibile creare il nuovo File!" },
-                    { "hex.view.hexeditor.menu.edit.undo", "Annulla" },
-                    { "hex.view.hexeditor.menu.edit.redo", "Ripeti" },
-                    { "hex.view.hexeditor.menu.edit.copy", "Copia" },
-                    { "hex.view.hexeditor.menu.edit.copy_as", "Copia come..." },
-                        { "hex.view.hexeditor.copy.hex", "Stringa" },
-                        { "hex.view.hexeditor.copy.c", "C Array" },
-                        { "hex.view.hexeditor.copy.cpp", "C++ Array" },
-                        { "hex.view.hexeditor.copy.csharp", "C# Array" },
-                        { "hex.view.hexeditor.copy.rust", "Rust Array" },
-                        { "hex.view.hexeditor.copy.python", "Python Array" },
-                        { "hex.view.hexeditor.copy.java", "Java Array" },
-                        { "hex.view.hexeditor.copy.js", "JavaScript Array" },
-                        { "hex.view.hexeditor.copy.ascii", "ASCII Art" },
-                        { "hex.view.hexeditor.copy.html", "HTML" },
-                    { "hex.view.hexeditor.menu.edit.paste", "Incolla" },
-                    { "hex.view.hexeditor.menu.edit.select_all", "Seleziona tutti" },
-                    { "hex.view.hexeditor.menu.edit.bookmark", "Crea segnalibro" },
-                    { "hex.view.hexeditor.menu.edit.set_base", "Imposta indirizzo di base" },
-                    { "hex.view.hexeditor.menu.edit.resize", "Ridimensiona" },
+                    { "hex.builtin.view.hexeditor.menu.file.export", "Esporta..." },
+                        { "hex.builtin.view.hexeditor.menu.file.export.title", "Esporta File" },
+                        { "hex.builtin.view.hexeditor.menu.file.export.ips", "IPS Patch" },
+                        { "hex.builtin.view.hexeditor.menu.file.export.ips32", "IPS32 Patch" },
+                    { "hex.builtin.view.hexeditor.menu.file.search", "Cerca" },
+                        { "hex.builtin.view.hexeditor.search.string", "Stringa" },
+                        { "hex.builtin.view.hexeditor.search.hex", "Hex" },
+                        { "hex.builtin.view.hexeditor.search.find", "Cerca" },
+                        { "hex.builtin.view.hexeditor.search.find_next", "Cerca il prossimo" },
+                        { "hex.builtin.view.hexeditor.search.find_prev", "Cerca il precedente" },
+                    { "hex.builtin.view.hexeditor.menu.file.goto", "Vai a" },
+                        { "hex.builtin.view.hexeditor.goto.offset.absolute", "Assoluto" },
+                        { "hex.builtin.view.hexeditor.goto.offset.current", "Corrente" },
+                        { "hex.builtin.view.hexeditor.goto.offset.begin", "Inizo" },
+                        { "hex.builtin.view.hexeditor.goto.offset.end", "Fine" },
+                    { "hex.builtin.view.hexeditor.error.read_only", "Impossibile scrivere sul File. File aperto solo in modalità lettura" },
+                    { "hex.builtin.view.hexeditor.error.open", "Impossibile aprire il File!" },
+                    { "hex.builtin.view.hexeditor.error.create", "Impossibile creare il nuovo File!" },
+                    { "hex.builtin.view.hexeditor.menu.edit.undo", "Annulla" },
+                    { "hex.builtin.view.hexeditor.menu.edit.redo", "Ripeti" },
+                    { "hex.builtin.view.hexeditor.menu.edit.copy", "Copia" },
+                    { "hex.builtin.view.hexeditor.menu.edit.copy_as", "Copia come..." },
+                        { "hex.builtin.view.hexeditor.copy.hex", "Stringa" },
+                        { "hex.builtin.view.hexeditor.copy.c", "C Array" },
+                        { "hex.builtin.view.hexeditor.copy.cpp", "C++ Array" },
+                        { "hex.builtin.view.hexeditor.copy.csharp", "C# Array" },
+                        { "hex.builtin.view.hexeditor.copy.rust", "Rust Array" },
+                        { "hex.builtin.view.hexeditor.copy.python", "Python Array" },
+                        { "hex.builtin.view.hexeditor.copy.java", "Java Array" },
+                        { "hex.builtin.view.hexeditor.copy.js", "JavaScript Array" },
+                        { "hex.builtin.view.hexeditor.copy.ascii", "ASCII Art" },
+                        { "hex.builtin.view.hexeditor.copy.html", "HTML" },
+                    { "hex.builtin.view.hexeditor.menu.edit.paste", "Incolla" },
+                    { "hex.builtin.view.hexeditor.menu.edit.select_all", "Seleziona tutti" },
+                    { "hex.builtin.view.hexeditor.menu.edit.bookmark", "Crea segnalibro" },
+                    { "hex.builtin.view.hexeditor.menu.edit.set_base", "Imposta indirizzo di base" },
+                    { "hex.builtin.view.hexeditor.menu.edit.resize", "Ridimensiona" },
 
-                { "hex.view.information.name", "Informazione sui Dati" },
-                    { "hex.view.information.control", "Controllo" },
-                    { "hex.view.information.analyze", "Analizza Pagina" },
-                    { "hex.view.information.analyzing", "Sto analizzando..." },
-                    { "hex.view.information.region", "Regione Analizzata" },
-                    { "hex.view.information.magic", "Informazione Magica" },
-                    { "hex.view.information.description", "Descrizione:" },
-                    { "hex.view.information.mime", "Tipo di MIME:" },
-                    { "hex.view.information.info_analysis", "Informazioni dell'analisi" },
-                    { "hex.view.information.distribution", "Distribuzione dei Byte" },
-                    { "hex.view.information.entropy", "Entropia" },
-                    { "hex.view.information.block_size", "Dimensione del Blocco" },
-                    { "hex.view.information.block_size.desc", "{0} blocchi di {1} bytes" },
-                    { "hex.view.information.file_entropy", "Entropia dei File" },
-                    { "hex.view.information.highest_entropy", "Highest entropy block" },
-                    { "hex.view.information.encrypted", "Questi dati sono probabilmente codificati o compressi!" },
+                { "hex.builtin.view.information.name", "Informazione sui Dati" },
+                    { "hex.builtin.view.information.control", "Controllo" },
+                    { "hex.builtin.view.information.analyze", "Analizza Pagina" },
+                    { "hex.builtin.view.information.analyzing", "Sto analizzando..." },
+                    { "hex.builtin.view.information.region", "Regione Analizzata" },
+                    { "hex.builtin.view.information.magic", "Informazione Magica" },
+                    { "hex.builtin.view.information.description", "Descrizione:" },
+                    { "hex.builtin.view.information.mime", "Tipo di MIME:" },
+                    { "hex.builtin.view.information.info_analysis", "Informazioni dell'analisi" },
+                    { "hex.builtin.view.information.distribution", "Distribuzione dei Byte" },
+                    { "hex.builtin.view.information.entropy", "Entropia" },
+                    { "hex.builtin.view.information.block_size", "Dimensione del Blocco" },
+                    { "hex.builtin.view.information.block_size.desc", "{0} blocchi di {1} bytes" },
+                    { "hex.builtin.view.information.file_entropy", "Entropia dei File" },
+                    { "hex.builtin.view.information.highest_entropy", "Highest entropy block" },
+                    { "hex.builtin.view.information.encrypted", "Questi dati sono probabilmente codificati o compressi!" },
 
-                { "hex.view.patches.name", "Patches" },
-                    { "hex.view.patches.offset", "Offset" },
-                    { "hex.view.patches.orig", "Valore Originale" },
-                    { "hex.view.patches.patch", "Valore patchato"},
-                    { "hex.view.patches.remove", "Rimuovi patch" },
+                { "hex.builtin.view.patches.name", "Patches" },
+                    { "hex.builtin.view.patches.offset", "Offset" },
+                    { "hex.builtin.view.patches.orig", "Valore Originale" },
+                    { "hex.builtin.view.patches.patch", "Valore patchato"},
+                    { "hex.builtin.view.patches.remove", "Rimuovi patch" },
 
-                { "hex.view.pattern.name", "Editor dei Pattern" },
-                { "hex.view.pattern.accept_pattern", "Accetta pattern" },
-                    { "hex.view.pattern.accept_pattern.desc", "Uno o più pattern compatibili con questo tipo di dati sono stati trovati!" },
-                    { "hex.view.pattern.accept_pattern.pattern_language", "Pattern" },
-                    { "hex.view.pattern.accept_pattern.question", "Vuoi applicare i patter selezionati" },
-                { "hex.view.pattern.menu.file.load_pattern", "Caricamento dei pattern..." },
-                { "hex.view.pattern.open_pattern", "Apri pattern" },
-                { "hex.view.pattern.evaluating", "Valutazione..." },
-                { "hex.view.pattern.auto", "Auto valutazione" },
+                { "hex.builtin.view.pattern_editor.name", "Editor dei Pattern" },
+                { "hex.builtin.view.pattern_editor.accept_pattern", "Accetta pattern" },
+                    { "hex.builtin.view.pattern_editor.accept_pattern.desc", "Uno o più pattern compatibili con questo tipo di dati sono stati trovati!" },
+                    { "hex.builtin.view.pattern_editor.accept_pattern.pattern_language", "Pattern" },
+                    { "hex.builtin.view.pattern_editor.accept_pattern.question", "Vuoi applicare i patter selezionati" },
+                { "hex.builtin.view.pattern_editor.menu.file.load_pattern", "Caricamento dei pattern..." },
+                //{ "hex.builtin.view.pattern_editor.menu.file.save_pattern", "Save pattern..." },
+                { "hex.builtin.view.pattern_editor.open_pattern", "Apri pattern" },
+                { "hex.builtin.view.pattern_editor.evaluating", "Valutazione..." },
+                { "hex.builtin.view.pattern_editor.auto", "Auto valutazione" },
+                //{ "hex.builtin.view.pattern_editor.env_vars", "Environment Variables" },
 
-                { "hex.view.pattern_data.name", "Dati dei Pattern" },
-                    { "hex.view.pattern_data.var_name", "Nome" },
-                    { "hex.view.pattern_data.color", "Colore" },
-                    { "hex.view.pattern_data.offset", "Offset" },
-                    { "hex.view.pattern_data.size", "Dimensione" },
-                    { "hex.view.pattern_data.type", "Tipo" },
-                    { "hex.view.pattern_data.value", "Valore" },
+                { "hex.builtin.view.pattern_data.name", "Dati dei Pattern" },
+                    { "hex.builtin.view.pattern_data.var_name", "Nome" },
+                    { "hex.builtin.view.pattern_data.color", "Colore" },
+                    { "hex.builtin.view.pattern_data.offset", "Offset" },
+                    { "hex.builtin.view.pattern_data.size", "Dimensione" },
+                    { "hex.builtin.view.pattern_data.type", "Tipo" },
+                    { "hex.builtin.view.pattern_data.value", "Valore" },
 
-                { "hex.view.settings.name", "Impostazioni" },
+                { "hex.builtin.view.settings.name", "Impostazioni" },
 
-                { "hex.view.strings.name", "Stringhe" },
-                    { "hex.view.strings.copy", "Copia stringa" },
-                    { "hex.view.strings.demangle", "Demangle" },
-                    { "hex.view.strings.min_length", "Lunghezza minima" },
-                    { "hex.view.strings.filter", "Filtro" },
-                    { "hex.view.strings.extract", "Estrai" },
-                    { "hex.view.strings.searching", "Sto cercando..." },
-                    { "hex.view.strings.offset", "Offset" },
-                    { "hex.view.strings.size", "Dimensione" },
-                    { "hex.view.strings.string", "Stringa" },
-                    { "hex.view.strings.demangle.title", "Nome Demangled" },
-                    { "hex.view.strings.demangle.copy", "Copia" },
+                { "hex.builtin.view.strings.name", "Stringhe" },
+                    { "hex.builtin.view.strings.copy", "Copia stringa" },
+                    { "hex.builtin.view.strings.demangle", "Demangle" },
+                    { "hex.builtin.view.strings.min_length", "Lunghezza minima" },
+                    { "hex.builtin.view.strings.filter", "Filtro" },
+                    { "hex.builtin.view.strings.extract", "Estrai" },
+                    { "hex.builtin.view.strings.searching", "Sto cercando..." },
+                    { "hex.builtin.view.strings.offset", "Offset" },
+                    { "hex.builtin.view.strings.size", "Dimensione" },
+                    { "hex.builtin.view.strings.string", "Stringa" },
+                    { "hex.builtin.view.strings.demangle.title", "Nome Demangled" },
+                    { "hex.builtin.view.strings.demangle.copy", "Copia" },
 
-                { "hex.view.tools.name", "Strumenti" },
+                { "hex.builtin.view.tools.name", "Strumenti" },
 
-                { "hex.view.yara.name", "Regole di Yara" },
-                    { "hex.view.yara.header.rules", "Regola" },
-                        { "hex.view.yara.reload", "Ricarica" },
-                        { "hex.view.yara.match", "Abbina Regole" },
-                        { "hex.view.yara.matching", "Abbinamento..." },
-                        { "hex.view.yara.error", "Errore compilazione Yara: " },
-                    { "hex.view.yara.header.matches", "Abbinamenti" },
-                        { "hex.view.yara.matches.identifier", "Identificatore" },
-                        //{ "hex.view.yara.matches.variable", "Variable" },
-                        { "hex.view.yara.whole_data", "Tutti i file combaciano!" },
-                        { "hex.view.yara.no_rules", "Nessuna regola di YARA. Aggiungile in nella cartella 'yara' di 'ImHex'" },
+                { "hex.builtin.view.yara.name", "Regole di Yara" },
+                    { "hex.builtin.view.yara.header.rules", "Regola" },
+                        { "hex.builtin.view.yara.reload", "Ricarica" },
+                        { "hex.builtin.view.yara.match", "Abbina Regole" },
+                        { "hex.builtin.view.yara.matching", "Abbinamento..." },
+                        { "hex.builtin.view.yara.error", "Errore compilazione Yara: " },
+                    { "hex.builtin.view.yara.header.matches", "Abbinamenti" },
+                        { "hex.builtin.view.yara.matches.identifier", "Identificatore" },
+                        //{ "hex.builtin.view.yara.matches.variable", "Variable" },
+                        { "hex.builtin.view.yara.whole_data", "Tutti i file combaciano!" },
+                        { "hex.builtin.view.yara.no_rules", "Nessuna regola di YARA. Aggiungile in nella cartella 'yara' di 'ImHex'" },
 
-                { "hex.view.constants.name", "Costanti" },
-                    { "hex.view.constants.row.category", "Categoria" },
-                    { "hex.view.constants.row.name", "Nome" },
-                    { "hex.view.constants.row.desc", "Descrizione" },
-                    { "hex.view.constants.row.value", "Valore" },
-                { "hex.view.store.name", "Content Store" },
-                    { "hex.view.store.desc", "Scarica nuovi contenuti dal database online di ImHex" },
-                    { "hex.view.store.reload", "Ricarica" },
-                    { "hex.view.store.row.name", "Nome" },
-                    { "hex.view.store.row.description", "Descrizione" },
-                    { "hex.view.store.download", "Download" },
-                    { "hex.view.store.update", "Aggiorna" },
-                    { "hex.view.store.remove", "Rimuovi" },
-                    { "hex.view.store.tab.patterns", "Modelli" },
-                    { "hex.view.store.tab.libraries", "Librerie" },
-                    { "hex.view.store.tab.magics", "File Magici" },
-                    { "hex.view.store.tab.constants", "Costanti" },
-                    { "hex.view.store.tab.yara", "Regole di Yara" },
-                    { "hex.view.store.loading", "Caricamento del content store..." },
-                //{ "hex.view.diff.name", "Diffing" },
+                { "hex.builtin.view.constants.name", "Costanti" },
+                    { "hex.builtin.view.constants.row.category", "Categoria" },
+                    { "hex.builtin.view.constants.row.name", "Nome" },
+                    { "hex.builtin.view.constants.row.desc", "Descrizione" },
+                    { "hex.builtin.view.constants.row.value", "Valore" },
+                { "hex.builtin.view.store.name", "Content Store" },
+                    { "hex.builtin.view.store.desc", "Scarica nuovi contenuti dal database online di ImHex" },
+                    { "hex.builtin.view.store.reload", "Ricarica" },
+                    { "hex.builtin.view.store.row.name", "Nome" },
+                    { "hex.builtin.view.store.row.description", "Descrizione" },
+                    { "hex.builtin.view.store.download", "Download" },
+                    { "hex.builtin.view.store.update", "Aggiorna" },
+                    { "hex.builtin.view.store.remove", "Rimuovi" },
+                    { "hex.builtin.view.store.tab.patterns", "Modelli" },
+                    { "hex.builtin.view.store.tab.libraries", "Librerie" },
+                    { "hex.builtin.view.store.tab.magics", "File Magici" },
+                    { "hex.builtin.view.store.tab.constants", "Costanti" },
+                    { "hex.builtin.view.store.tab.yara", "Regole di Yara" },
+                    { "hex.builtin.view.store.loading", "Caricamento del content store..." },
+                //{ "hex.builtin.view.diff.name", "Diffing" },
 
-            /* Builtin plugin features */
+                //{ "hex.builtin.view.provider_settings.name", "Provider Settings" },
+                    //{ "hex.builtin.view.provider_settings.load_popup", "Open Provider" },
 
                 { "hex.builtin.command.calc.desc", "Calcolatrice" },
                 { "hex.builtin.command.cmd.desc", "Comando" },
@@ -662,6 +670,18 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.provider.file.creation", "Data di creazione" },
                 { "hex.builtin.provider.file.access", "Data dell'ultimo accesso" },
                 { "hex.builtin.provider.file.modification", "Data dell'ultima modifica" },
+
+                //{ "hex.builtin.provider.file", "File Provider" },
+                //{ "hex.builtin.provider.gdb", "GDB Server Provider" },
+                    //{ "hex.builtin.provider.gdb.name", "GDB Server <{0}:{1}>" },
+                    //{ "hex.builtin.provider.gdb.server", "Server" },
+                    //{ "hex.builtin.provider.gdb.ip", "IP Address" },
+                    //{ "hex.builtin.provider.gdb.port", "Port" },
+                //{ "hex.builtin.provider.disk", "Raw Disk Provider" },
+                    //{ "hex.builtin.provider.disk.selected_disk", "Disk" },
+                    //{ "hex.builtin.provider.disk.disk_size", "Disk Size" },
+                    //{ "hex.builtin.provider.disk.sector_size", "Sector Size" },
+                    //{ "hex.builtin.provider.disk.reload", "Reload" },
         });
     }
 

plugins/builtin/source/lang/zh_CN.cpp

@@ -23,6 +23,7 @@ namespace hex::plugin::builtin {
                     { "hex.welcome.start.open_file", "打开文件" },
                     { "hex.welcome.start.open_project", "打开工程" },
                     { "hex.welcome.start.recent", "最近文件" },
+                    //{ "hex.welcome.start.open_other", "Other Providers" },
                 { "hex.welcome.header.help", "帮助" },
                     { "hex.welcome.help.repo", "GitHub仓库" },
                         { "hex.welcome.help.repo.link", "https://github.com/WerWolv/ImHex" },
@@ -86,248 +87,255 @@ namespace hex::plugin::builtin {
                 { "hex.message.yara_rule_added", "Yara规则已添加！" },
                 { "hex.message.magic_db_added", "魔术数据库已添加！" },
 
-                { "hex.view.bookmarks.name", "书签" },
-                    { "hex.view.bookmarks.default_title", "书签 [0x{0:X} - 0x{1:X}]" },
-                    { "hex.view.bookmarks.no_bookmarks", "空空如也。通过 编辑->添加书签" },
-                    { "hex.view.bookmarks.title.info", "信息" },
-                    { "hex.view.bookmarks.address", "0x{0:X} : 0x{1:X} ({2} 字节)" },
-                    { "hex.view.bookmarks.button.jump", "转到" },
-                    { "hex.view.bookmarks.button.remove", "移除" },
-                    { "hex.view.bookmarks.header.name", "名称" },
-                    { "hex.view.bookmarks.header.color", "颜色" },
-                    { "hex.view.bookmarks.header.comment", "注释" },
+                /* Builtin plugin features */
 
-                { "hex.view.command_palette.name", "命令栏" },
+                { "hex.builtin.view.bookmarks.name", "书签" },
+                    { "hex.builtin.view.bookmarks.default_title", "书签 [0x{0:X} - 0x{1:X}]" },
+                    { "hex.builtin.view.bookmarks.no_bookmarks", "空空如也。通过 编辑->添加书签" },
+                    { "hex.builtin.view.bookmarks.title.info", "信息" },
+                    { "hex.builtin.view.bookmarks.address", "0x{0:X} : 0x{1:X} ({2} 字节)" },
+                    { "hex.builtin.view.bookmarks.button.jump", "转到" },
+                    { "hex.builtin.view.bookmarks.button.remove", "移除" },
+                    { "hex.builtin.view.bookmarks.header.name", "名称" },
+                    { "hex.builtin.view.bookmarks.header.color", "颜色" },
+                    { "hex.builtin.view.bookmarks.header.comment", "注释" },
 
-                { "hex.view.data_inspector.name", "数据分析器" },
-                    { "hex.view.data_inspector.table.name", "名称" },
-                    { "hex.view.data_inspector.table.value", "值" },
-                    { "hex.view.data_inspector.no_data", "没有选中字节"},
+                { "hex.builtin.view.command_palette.name", "命令栏" },
 
-                { "hex.view.data_processor.name", "数据处理器" },
-                    { "hex.view.data_processor.menu.remove_selection", "移除已选" },
-                    { "hex.view.data_processor.menu.remove_node", "移除节点" },
-                    { "hex.view.data_processor.menu.remove_link", "移除链接" },
+                { "hex.builtin.view.data_inspector.name", "数据分析器" },
+                    { "hex.builtin.view.data_inspector.table.name", "名称" },
+                    { "hex.builtin.view.data_inspector.table.value", "值" },
+                    { "hex.builtin.view.data_inspector.no_data", "没有选中字节"},
 
-                { "hex.view.disassembler.name", "反汇编" },
-                    { "hex.view.disassembler.position", "位置" },
-                    { "hex.view.disassembler.base", "基地址" },
-                    { "hex.view.disassembler.region", "代码范围" },
-                    { "hex.view.disassembler.settings.header", "设置" },
-                    { "hex.view.disassembler.arch", "架构" },
-                        { "hex.view.disassembler.arm.arm", "ARM" },
-                        { "hex.view.disassembler.arm.thumb", "Thumb" },
-                        { "hex.view.disassembler.arm.default", "默认" },
-                        { "hex.view.disassembler.arm.cortex_m", "Cortex-M" },
-                        { "hex.view.disassembler.arm.armv8", "ARMv8" },
+                { "hex.builtin.view.data_processor.name", "数据处理器" },
+                    { "hex.builtin.view.data_processor.menu.remove_selection", "移除已选" },
+                    { "hex.builtin.view.data_processor.menu.remove_node", "移除节点" },
+                    { "hex.builtin.view.data_processor.menu.remove_link", "移除链接" },
 
-                        { "hex.view.disassembler.mips.mips32", "MIPS32" },
-                        { "hex.view.disassembler.mips.mips64", "MIPS64" },
-                        { "hex.view.disassembler.mips.mips32R6", "MIPS32R6" },
-                        { "hex.view.disassembler.mips.micro", "Micro MIPS" },
+                { "hex.builtin.view.disassembler.name", "反汇编" },
+                    { "hex.builtin.view.disassembler.position", "位置" },
+                    { "hex.builtin.view.disassembler.base", "基地址" },
+                    { "hex.builtin.view.disassembler.region", "代码范围" },
+                    { "hex.builtin.view.disassembler.settings.header", "设置" },
+                    { "hex.builtin.view.disassembler.arch", "架构" },
+                        { "hex.builtin.view.disassembler.arm.arm", "ARM" },
+                        { "hex.builtin.view.disassembler.arm.thumb", "Thumb" },
+                        { "hex.builtin.view.disassembler.arm.default", "默认" },
+                        { "hex.builtin.view.disassembler.arm.cortex_m", "Cortex-M" },
+                        { "hex.builtin.view.disassembler.arm.armv8", "ARMv8" },
 
-                        { "hex.view.disassembler.x86.16bit", "16位" },
-                        { "hex.view.disassembler.x86.32bit", "32位" },
-                        { "hex.view.disassembler.x86.64bit", "64位" },
+                        { "hex.builtin.view.disassembler.mips.mips32", "MIPS32" },
+                        { "hex.builtin.view.disassembler.mips.mips64", "MIPS64" },
+                        { "hex.builtin.view.disassembler.mips.mips32R6", "MIPS32R6" },
+                        { "hex.builtin.view.disassembler.mips.micro", "Micro MIPS" },
 
-                        { "hex.view.disassembler.ppc.32bit", "32位" },
-                        { "hex.view.disassembler.ppc.64bit", "64位" },
+                        { "hex.builtin.view.disassembler.x86.16bit", "16位" },
+                        { "hex.builtin.view.disassembler.x86.32bit", "32位" },
+                        { "hex.builtin.view.disassembler.x86.64bit", "64位" },
 
-                        { "hex.view.disassembler.sparc.v9", "Sparc V9" },
+                        { "hex.builtin.view.disassembler.ppc.32bit", "32位" },
+                        { "hex.builtin.view.disassembler.ppc.64bit", "64位" },
 
-                    { "hex.view.disassembler.disassemble", "反汇编" },
-                    { "hex.view.disassembler.disassembling", "反汇编中..." },
-                    { "hex.view.disassembler.disassembly.title", "反汇编" },
-                        { "hex.view.disassembler.disassembly.address", "地址" },
-                        { "hex.view.disassembler.disassembly.offset", "偏移" },
-                        { "hex.view.disassembler.disassembly.bytes", "字节" },
+                        { "hex.builtin.view.disassembler.sparc.v9", "Sparc V9" },
 
-                { "hex.view.hashes.name", "哈希" },
-                    { "hex.view.hashes.settings", "设置" },
-                    { "hex.view.hashes.function", "哈希函数" },
-                    { "hex.view.hashes.iv", "初始值" },
-                    { "hex.view.hashes.poly", "多项式" },
-                    { "hex.view.hashes.result", "结果" },
+                    { "hex.builtin.view.disassembler.disassemble", "反汇编" },
+                    { "hex.builtin.view.disassembler.disassembling", "反汇编中..." },
+                    { "hex.builtin.view.disassembler.disassembly.title", "反汇编" },
+                        { "hex.builtin.view.disassembler.disassembly.address", "地址" },
+                        { "hex.builtin.view.disassembler.disassembly.offset", "偏移" },
+                        { "hex.builtin.view.disassembler.disassembly.bytes", "字节" },
 
-                { "hex.view.help.name", "帮助" },
-                    { "hex.view.help.about.name", "关于" },
-                        { "hex.view.help.about.translator", "由xtexChooser翻译" },
-                        { "hex.view.help.about.source", "源代码位于GitHub:" },
-                        { "hex.view.help.about.donations", "赞助" },
-                        { "hex.view.help.about.thanks", "如果你喜欢我的工作，请赞助以帮助此项目继续前进。非常感谢 <3" },
-                        { "hex.view.help.about.libs", "使用的库" },
-                        { "hex.view.help.about.paths", "ImHex目录" },
-                    { "hex.view.help.documentation", "ImHex文档" },
-                    { "hex.view.help.pattern_cheat_sheet", "模式语言帮助"},
-                    { "hex.view.help.calc_cheat_sheet", "计算器帮助" },
+                { "hex.builtin.view.hashes.name", "哈希" },
+                    { "hex.builtin.view.hashes.settings", "设置" },
+                    { "hex.builtin.view.hashes.function", "哈希函数" },
+                    { "hex.builtin.view.hashes.iv", "初始值" },
+                    { "hex.builtin.view.hashes.poly", "多项式" },
+                    { "hex.builtin.view.hashes.result", "结果" },
 
-                { "hex.view.hexeditor.name", "Hex编辑器" },
-                    { "hex.view.hexeditor.create_file", "新建" },
-                    { "hex.view.hexeditor.open_file", "打开" },
-                    { "hex.view.hexeditor.open_project", "打开项目" },
-                    { "hex.view.hexeditor.save_project", "保存项目" },
-                    { "hex.view.hexeditor.save_data", "保存数据" },
-                    { "hex.view.hexeditor.open_base64", "打开Base64文件" },
-                    { "hex.view.hexeditor.load_enconding_file", "加载自定义编码定义文件" },
-                    { "hex.view.hexeditor.page", "页 {0} / {1}" },
-                    { "hex.view.hexeditor.save_as", "另存为" },
-                    { "hex.view.hexeditor.exit_application.title", "退出？" },
-                    { "hex.view.hexeditor.exit_application.desc", "工程还有为保存的更改。\n确定要退出吗？" },
-                    { "hex.view.hexeditor.script.title", "通过加载器脚本加载文件" },
-                    { "hex.view.hexeditor.script.desc", "通过Python加载器脚本加载文件。" },
-                    { "hex.view.hexeditor.script.script", "脚本" },
-                        { "hex.view.hexeditor.script.script.title", "加载器脚本：打开脚本" },
-                    { "hex.view.hexeditor.script.file", "文件" },
-                    { "hex.view.hexeditor.script.file.title", "加载器脚本：打开文件" },
+                { "hex.builtin.view.help.name", "帮助" },
+                    { "hex.builtin.view.help.about.name", "关于" },
+                        { "hex.builtin.view.help.about.translator", "由xtexChooser翻译" },
+                        { "hex.builtin.view.help.about.source", "源代码位于GitHub:" },
+                        { "hex.builtin.view.help.about.donations", "赞助" },
+                        { "hex.builtin.view.help.about.thanks", "如果你喜欢我的工作，请赞助以帮助此项目继续前进。非常感谢 <3" },
+                        //{ "hex.builtin.view.help.about.contributor", "Contributors" },
+                        { "hex.builtin.view.help.about.libs", "使用的库" },
+                        { "hex.builtin.view.help.about.paths", "ImHex目录" },
+                    { "hex.builtin.view.help.documentation", "ImHex文档" },
+                    { "hex.builtin.view.help.pattern_cheat_sheet", "模式语言帮助"},
+                    { "hex.builtin.view.help.calc_cheat_sheet", "计算器帮助" },
 
-                    { "hex.view.hexeditor.menu.file.open_file", "打开文件..." },
-                    { "hex.view.hexeditor.menu.file.open_recent", "打开最近"},
-                    { "hex.view.hexeditor.menu.file.save", "保存" },
-                    { "hex.view.hexeditor.menu.file.save_as", "另存为..." },
-                    { "hex.view.hexeditor.menu.file.close", "关闭" },
-                    { "hex.view.hexeditor.menu.file.quit", "退出ImHex" },
-                    { "hex.view.hexeditor.menu.file.open_project", "打开项目..." },
-                    { "hex.view.hexeditor.menu.file.save_project", "保存项目..." },
-                    { "hex.view.hexeditor.menu.file.load_encoding_file", "加载自定义编码..." },
-                    { "hex.view.hexeditor.menu.file.import", "导入..." },
-                        { "hex.view.hexeditor.menu.file.import.base64", "Base64文件" },
-                        { "hex.view.hexeditor.base64.import_error", "文件不是有效的Base64格式！" },
-                        { "hex.view.hexeditor.file_open_error", "打开文件失败！" },
-                        { "hex.view.hexeditor.menu.file.import.ips", "IPS补丁" },
-                        { "hex.view.hexeditor.menu.file.import.ips32", "IPS32补丁" },
-                        { "hex.view.hexeditor.menu.file.import.script", "带有加载器脚本的文件" },
+                { "hex.builtin.view.hexeditor.name", "Hex编辑器" },
+                    { "hex.builtin.view.hexeditor.create_file", "新建" },
+                    { "hex.builtin.view.hexeditor.open_file", "打开" },
+                    { "hex.builtin.view.hexeditor.open_project", "打开项目" },
+                    { "hex.builtin.view.hexeditor.save_project", "保存项目" },
+                    { "hex.builtin.view.hexeditor.save_data", "保存数据" },
+                    { "hex.builtin.view.hexeditor.open_base64", "打开Base64文件" },
+                    { "hex.builtin.view.hexeditor.load_enconding_file", "加载自定义编码定义文件" },
+                    { "hex.builtin.view.hexeditor.page", "页 {0} / {1}" },
+                    { "hex.builtin.view.hexeditor.save_as", "另存为" },
+                    { "hex.builtin.view.hexeditor.exit_application.title", "退出？" },
+                    { "hex.builtin.view.hexeditor.exit_application.desc", "工程还有为保存的更改。\n确定要退出吗？" },
+                    { "hex.builtin.view.hexeditor.script.title", "通过加载器脚本加载文件" },
+                    { "hex.builtin.view.hexeditor.script.desc", "通过Python加载器脚本加载文件。" },
+                    { "hex.builtin.view.hexeditor.script.script", "脚本" },
+                        { "hex.builtin.view.hexeditor.script.script.title", "加载器脚本：打开脚本" },
+                    { "hex.builtin.view.hexeditor.script.file", "文件" },
+                    { "hex.builtin.view.hexeditor.script.file.title", "加载器脚本：打开文件" },
 
-                    { "hex.view.hexeditor.menu.file.export", "导出..." },
-                        { "hex.view.hexeditor.menu.file.export.title", "导出文件" },
-                        { "hex.view.hexeditor.menu.file.export.ips", "IPS补丁" },
-                        { "hex.view.hexeditor.menu.file.export.ips32", "IPS32补丁" },
-                    { "hex.view.hexeditor.menu.file.search", "搜索" },
-                        { "hex.view.hexeditor.search.string", "字符串" },
-                        { "hex.view.hexeditor.search.hex", "Hex" },
-                        { "hex.view.hexeditor.search.find", "查找" },
-                        { "hex.view.hexeditor.search.find_next", "查找下一个" },
-                        { "hex.view.hexeditor.search.find_prev", "查找上一个" },
-                    { "hex.view.hexeditor.menu.file.goto", "转到" },
-                        { "hex.view.hexeditor.goto.offset.absolute", "绝对" },
-                        { "hex.view.hexeditor.goto.offset.current", "当前" },
-                        { "hex.view.hexeditor.goto.offset.begin", "起始" },
-                        { "hex.view.hexeditor.goto.offset.end", "末尾" },
-                    { "hex.view.hexeditor.error.read_only", "无法获得写权限，文件以只读方式打开。" },
-                    { "hex.view.hexeditor.error.open", "打开文件失败！" },
-                    { "hex.view.hexeditor.error.create", "创建新文件失败！" },
-                    { "hex.view.hexeditor.menu.edit.undo", "撤销" },
-                    { "hex.view.hexeditor.menu.edit.redo", "重做" },
-                    { "hex.view.hexeditor.menu.edit.copy", "复制" },
-                    { "hex.view.hexeditor.menu.edit.copy_as", "复制为..." },
-                        { "hex.view.hexeditor.copy.hex", "字符串" },
-                        { "hex.view.hexeditor.copy.c", "C数组" },
-                        { "hex.view.hexeditor.copy.cpp", "C++数组" },
-                        { "hex.view.hexeditor.copy.csharp", "C#数组" },
-                        { "hex.view.hexeditor.copy.rust", "Rust数组" },
-                        { "hex.view.hexeditor.copy.python", "Python数组" },
-                        { "hex.view.hexeditor.copy.java", "Java数组" },
-                        { "hex.view.hexeditor.copy.js", "JavaScript数组" },
-                        { "hex.view.hexeditor.copy.ascii", "ASCII Art" },
-                        { "hex.view.hexeditor.copy.html", "HTML" },
-                    { "hex.view.hexeditor.menu.edit.paste", "粘贴" },
-                    { "hex.view.hexeditor.menu.edit.select_all", "全选" },
-                    { "hex.view.hexeditor.menu.edit.bookmark", "添加书签" },
-                    { "hex.view.hexeditor.menu.edit.set_base", "设置基地址" },
-                    { "hex.view.hexeditor.menu.edit.resize", "修改大小" },
+                    { "hex.builtin.view.hexeditor.menu.file.open_file", "打开文件..." },
+                    { "hex.builtin.view.hexeditor.menu.file.open_recent", "打开最近" },
+                    //{ "hex.builtin.view.hexeditor.menu.file.open_other", "Open Other..." },
+                    { "hex.builtin.view.hexeditor.menu.file.save", "保存" },
+                    { "hex.builtin.view.hexeditor.menu.file.save_as", "另存为..." },
+                    { "hex.builtin.view.hexeditor.menu.file.close", "关闭" },
+                    { "hex.builtin.view.hexeditor.menu.file.quit", "退出ImHex" },
+                    { "hex.builtin.view.hexeditor.menu.file.open_project", "打开项目..." },
+                    { "hex.builtin.view.hexeditor.menu.file.save_project", "保存项目..." },
+                    { "hex.builtin.view.hexeditor.menu.file.load_encoding_file", "加载自定义编码..." },
+                    { "hex.builtin.view.hexeditor.menu.file.import", "导入..." },
+                        { "hex.builtin.view.hexeditor.menu.file.import.base64", "Base64文件" },
+                        { "hex.builtin.view.hexeditor.base64.import_error", "文件不是有效的Base64格式！" },
+                        { "hex.builtin.view.hexeditor.file_open_error", "打开文件失败！" },
+                        { "hex.builtin.view.hexeditor.menu.file.import.ips", "IPS补丁" },
+                        { "hex.builtin.view.hexeditor.menu.file.import.ips32", "IPS32补丁" },
+                        { "hex.builtin.view.hexeditor.menu.file.import.script", "带有加载器脚本的文件" },
 
-                { "hex.view.information.name", "数据信息" },
-                    { "hex.view.information.control", "控制" },
-                    { "hex.view.information.analyze", "分析" },
-                    { "hex.view.information.analyzing", "分析中..." },
-                    { "hex.view.information.region", "已分析区域" },
-                    { "hex.view.information.magic", "魔术信息" },
-                    { "hex.view.information.description", "描述:" },
-                    { "hex.view.information.mime", "MIME类型:" },
-                    { "hex.view.information.info_analysis", "信息分析" },
-                    { "hex.view.information.distribution", "字节分布" },
-                    { "hex.view.information.entropy", "熵" },
-                    { "hex.view.information.block_size", "块大小" },
-                    { "hex.view.information.block_size.desc", "{0} 块 × {1} 字节" },
-                    { "hex.view.information.file_entropy", "文件熵" },
-                    { "hex.view.information.highest_entropy", "最高熵" },
-                    { "hex.view.information.encrypted", "此数据似乎经过了加密或压缩！" },
+                    { "hex.builtin.view.hexeditor.menu.file.export", "导出..." },
+                        { "hex.builtin.view.hexeditor.menu.file.export.title", "导出文件" },
+                        { "hex.builtin.view.hexeditor.menu.file.export.ips", "IPS补丁" },
+                        { "hex.builtin.view.hexeditor.menu.file.export.ips32", "IPS32补丁" },
+                    { "hex.builtin.view.hexeditor.menu.file.search", "搜索" },
+                        { "hex.builtin.view.hexeditor.search.string", "字符串" },
+                        { "hex.builtin.view.hexeditor.search.hex", "Hex" },
+                        { "hex.builtin.view.hexeditor.search.find", "查找" },
+                        { "hex.builtin.view.hexeditor.search.find_next", "查找下一个" },
+                        { "hex.builtin.view.hexeditor.search.find_prev", "查找上一个" },
+                    { "hex.builtin.view.hexeditor.menu.file.goto", "转到" },
+                        { "hex.builtin.view.hexeditor.goto.offset.absolute", "绝对" },
+                        { "hex.builtin.view.hexeditor.goto.offset.current", "当前" },
+                        { "hex.builtin.view.hexeditor.goto.offset.begin", "起始" },
+                        { "hex.builtin.view.hexeditor.goto.offset.end", "末尾" },
+                    { "hex.builtin.view.hexeditor.error.read_only", "无法获得写权限，文件以只读方式打开。" },
+                    { "hex.builtin.view.hexeditor.error.open", "打开文件失败！" },
+                    { "hex.builtin.view.hexeditor.error.create", "创建新文件失败！" },
+                    { "hex.builtin.view.hexeditor.menu.edit.undo", "撤销" },
+                    { "hex.builtin.view.hexeditor.menu.edit.redo", "重做" },
+                    { "hex.builtin.view.hexeditor.menu.edit.copy", "复制" },
+                    { "hex.builtin.view.hexeditor.menu.edit.copy_as", "复制为..." },
+                        { "hex.builtin.view.hexeditor.copy.hex", "字符串" },
+                        { "hex.builtin.view.hexeditor.copy.c", "C数组" },
+                        { "hex.builtin.view.hexeditor.copy.cpp", "C++数组" },
+                        { "hex.builtin.view.hexeditor.copy.csharp", "C#数组" },
+                        { "hex.builtin.view.hexeditor.copy.rust", "Rust数组" },
+                        { "hex.builtin.view.hexeditor.copy.python", "Python数组" },
+                        { "hex.builtin.view.hexeditor.copy.java", "Java数组" },
+                        { "hex.builtin.view.hexeditor.copy.js", "JavaScript数组" },
+                        { "hex.builtin.view.hexeditor.copy.ascii", "ASCII Art" },
+                        { "hex.builtin.view.hexeditor.copy.html", "HTML" },
+                    { "hex.builtin.view.hexeditor.menu.edit.paste", "粘贴" },
+                    { "hex.builtin.view.hexeditor.menu.edit.select_all", "全选" },
+                    { "hex.builtin.view.hexeditor.menu.edit.bookmark", "添加书签" },
+                    { "hex.builtin.view.hexeditor.menu.edit.set_base", "设置基地址" },
+                    { "hex.builtin.view.hexeditor.menu.edit.resize", "修改大小" },
 
-                { "hex.view.patches.name", "补丁" },
-                    { "hex.view.patches.offset", "偏移" },
-                    { "hex.view.patches.orig", "原始值" },
-                    { "hex.view.patches.patch", "修改值"},
-                    { "hex.view.patches.remove", "移除补丁" },
+                { "hex.builtin.view.information.name", "数据信息" },
+                    { "hex.builtin.view.information.control", "控制" },
+                    { "hex.builtin.view.information.analyze", "分析" },
+                    { "hex.builtin.view.information.analyzing", "分析中..." },
+                    { "hex.builtin.view.information.region", "已分析区域" },
+                    { "hex.builtin.view.information.magic", "魔术信息" },
+                    { "hex.builtin.view.information.description", "描述:" },
+                    { "hex.builtin.view.information.mime", "MIME类型:" },
+                    { "hex.builtin.view.information.info_analysis", "信息分析" },
+                    { "hex.builtin.view.information.distribution", "字节分布" },
+                    { "hex.builtin.view.information.entropy", "熵" },
+                    { "hex.builtin.view.information.block_size", "块大小" },
+                    { "hex.builtin.view.information.block_size.desc", "{0} 块 × {1} 字节" },
+                    { "hex.builtin.view.information.file_entropy", "文件熵" },
+                    { "hex.builtin.view.information.highest_entropy", "最高熵" },
+                    { "hex.builtin.view.information.encrypted", "此数据似乎经过了加密或压缩！" },
 
-                { "hex.view.pattern.name", "模式编辑器" },
-                { "hex.view.pattern.accept_pattern", "接受模式" },
-                    { "hex.view.pattern.accept_pattern.desc", "一个或多个模式与所找到的数据类型兼容" },
-                    { "hex.view.pattern.accept_pattern.pattern_language", "模式" },
-                    { "hex.view.pattern.accept_pattern.question", "是否应用找到的模式？" },
-                { "hex.view.pattern.menu.file.load_pattern", "加载模式文件..." },
-                { "hex.view.pattern.open_pattern", "打开模式" },
-                { "hex.view.pattern.evaluating", "计算中..." },
-                { "hex.view.pattern.auto", "自动计算" },
+                { "hex.builtin.view.patches.name", "补丁" },
+                    { "hex.builtin.view.patches.offset", "偏移" },
+                    { "hex.builtin.view.patches.orig", "原始值" },
+                    { "hex.builtin.view.patches.patch", "修改值"},
+                    { "hex.builtin.view.patches.remove", "移除补丁" },
 
-                { "hex.view.pattern_data.name", "模式数据" },
-                    { "hex.view.pattern_data.var_name", "名称" },
-                    { "hex.view.pattern_data.color", "颜色" },
-                    { "hex.view.pattern_data.offset", "偏移" },
-                    { "hex.view.pattern_data.size", "大小" },
-                    { "hex.view.pattern_data.type", "类型" },
-                    { "hex.view.pattern_data.value", "值" },
+                { "hex.builtin.view.pattern_editor.name", "模式编辑器" },
+                { "hex.builtin.view.pattern_editor.accept_pattern", "接受模式" },
+                    { "hex.builtin.view.pattern_editor.accept_pattern.desc", "一个或多个模式与所找到的数据类型兼容" },
+                    { "hex.builtin.view.pattern_editor.accept_pattern.pattern_language", "模式" },
+                    { "hex.builtin.view.pattern_editor.accept_pattern.question", "是否应用找到的模式？" },
+                { "hex.builtin.view.pattern_editor.menu.file.load_pattern", "加载模式文件..." },
+                //{ "hex.builtin.view.pattern_editor.menu.file.save_pattern", "Save pattern..." },
+                { "hex.builtin.view.pattern_editor.open_pattern", "打开模式" },
+                { "hex.builtin.view.pattern_editor.evaluating", "计算中..." },
+                { "hex.builtin.view.pattern_editor.auto", "自动计算" },
+                //{ "hex.builtin.view.pattern_editor.env_vars", "Environment Variables" },
 
-                { "hex.view.settings.name", "设置" },
+                { "hex.builtin.view.pattern_data.name", "模式数据" },
+                    { "hex.builtin.view.pattern_data.var_name", "名称" },
+                    { "hex.builtin.view.pattern_data.color", "颜色" },
+                    { "hex.builtin.view.pattern_data.offset", "偏移" },
+                    { "hex.builtin.view.pattern_data.size", "大小" },
+                    { "hex.builtin.view.pattern_data.type", "类型" },
+                    { "hex.builtin.view.pattern_data.value", "值" },
 
-                { "hex.view.strings.name", "字符串" },
-                    { "hex.view.strings.copy", "复制字符串" },
-                    { "hex.view.strings.demangle", "还原" },
-                    { "hex.view.strings.min_length", "最小长度" },
-                    { "hex.view.strings.filter", "过滤" },
-                    { "hex.view.strings.extract", "提取" },
-                    { "hex.view.strings.searching", "搜索中..." },
-                    { "hex.view.strings.offset", "偏移" },
-                    { "hex.view.strings.size", "大小" },
-                    { "hex.view.strings.string", "字符串" },
-                    { "hex.view.strings.demangle.title", "还原名" },
-                    { "hex.view.strings.demangle.copy", "复制" },
+                { "hex.builtin.view.settings.name", "设置" },
 
-                { "hex.view.tools.name", "工具" },
+                { "hex.builtin.view.strings.name", "字符串" },
+                    { "hex.builtin.view.strings.copy", "复制字符串" },
+                    { "hex.builtin.view.strings.demangle", "还原" },
+                    { "hex.builtin.view.strings.min_length", "最小长度" },
+                    { "hex.builtin.view.strings.filter", "过滤" },
+                    { "hex.builtin.view.strings.extract", "提取" },
+                    { "hex.builtin.view.strings.searching", "搜索中..." },
+                    { "hex.builtin.view.strings.offset", "偏移" },
+                    { "hex.builtin.view.strings.size", "大小" },
+                    { "hex.builtin.view.strings.string", "字符串" },
+                    { "hex.builtin.view.strings.demangle.title", "还原名" },
+                    { "hex.builtin.view.strings.demangle.copy", "复制" },
 
-                { "hex.view.yara.name", "Yara规则" },
-                    { "hex.view.yara.header.rules", "规则" },
-                        { "hex.view.yara.reload", "重新加载" },
-                        { "hex.view.yara.match", "匹配规则" },
-                        { "hex.view.yara.matching", "匹配中..." },
-                        { "hex.view.yara.error", "Yara编译器错误: " },
-                    { "hex.view.yara.header.matches", "匹配" },
-                        { "hex.view.yara.matches.identifier", "标识符" },
-                        //{ "hex.view.yara.matches.variable", "Variable" },
-                        { "hex.view.yara.whole_data", "全文件匹配！" },
-                        { "hex.view.yara.no_rules", "没有找到YARA规则。请将规则放到ImHex的'yara'目录下。" },
+                { "hex.builtin.view.tools.name", "工具" },
 
-                { "hex.view.constants.name", "常量" },
-                    { "hex.view.constants.row.category", "分类" },
-                    { "hex.view.constants.row.name", "名称" },
-                    { "hex.view.constants.row.desc", "描述" },
-                    { "hex.view.constants.row.value", "值" },
+                { "hex.builtin.view.yara.name", "Yara规则" },
+                    { "hex.builtin.view.yara.header.rules", "规则" },
+                        { "hex.builtin.view.yara.reload", "重新加载" },
+                        { "hex.builtin.view.yara.match", "匹配规则" },
+                        { "hex.builtin.view.yara.matching", "匹配中..." },
+                        { "hex.builtin.view.yara.error", "Yara编译器错误: " },
+                    { "hex.builtin.view.yara.header.matches", "匹配" },
+                        { "hex.builtin.view.yara.matches.identifier", "标识符" },
+                        //{ "hex.builtin.view.yara.matches.variable", "Variable" },
+                        { "hex.builtin.view.yara.whole_data", "全文件匹配！" },
+                        { "hex.builtin.view.yara.no_rules", "没有找到YARA规则。请将规则放到ImHex的'yara'目录下。" },
 
-                { "hex.view.store.name", "内容仓库" },
-                    { "hex.view.store.desc", "从ImHex在线数据库下载新内容" },
-                    { "hex.view.store.reload", "刷新" },
-                    { "hex.view.store.row.name", "名称" },
-                    { "hex.view.store.row.description", "描述" },
-                    { "hex.view.store.download", "下载" },
-                    { "hex.view.store.update", "更新" },
-                    { "hex.view.store.remove", "移除" },
-                    { "hex.view.store.tab.patterns", "模式" },
-                    { "hex.view.store.tab.libraries", "库" },
-                    { "hex.view.store.tab.magics", "魔术数据库" },
-                    { "hex.view.store.tab.constants", "常量" },
-                    { "hex.view.store.tab.yara", "Yara规则" },
-                { "hex.view.store.loading", "正在加载仓库内容..." },
-                { "hex.view.diff.name", "差异" },
+                { "hex.builtin.view.constants.name", "常量" },
+                    { "hex.builtin.view.constants.row.category", "分类" },
+                    { "hex.builtin.view.constants.row.name", "名称" },
+                    { "hex.builtin.view.constants.row.desc", "描述" },
+                    { "hex.builtin.view.constants.row.value", "值" },
 
-            /* Builtin plugin features */
+                { "hex.builtin.view.store.name", "内容仓库" },
+                    { "hex.builtin.view.store.desc", "从ImHex在线数据库下载新内容" },
+                    { "hex.builtin.view.store.reload", "刷新" },
+                    { "hex.builtin.view.store.row.name", "名称" },
+                    { "hex.builtin.view.store.row.description", "描述" },
+                    { "hex.builtin.view.store.download", "下载" },
+                    { "hex.builtin.view.store.update", "更新" },
+                    { "hex.builtin.view.store.remove", "移除" },
+                    { "hex.builtin.view.store.tab.patterns", "模式" },
+                    { "hex.builtin.view.store.tab.libraries", "库" },
+                    { "hex.builtin.view.store.tab.magics", "魔术数据库" },
+                    { "hex.builtin.view.store.tab.constants", "常量" },
+                    { "hex.builtin.view.store.tab.yara", "Yara规则" },
+                { "hex.builtin.view.store.loading", "正在加载仓库内容..." },
+                { "hex.builtin.view.diff.name", "差异" },
+
+                //{ "hex.builtin.view.provider_settings.name", "Provider Settings" },
+                    //{ "hex.builtin.view.provider_settings.load_popup", "Open Provider" },
 
                 { "hex.builtin.command.calc.desc", "计算器" },
                 { "hex.builtin.command.cmd.desc", "指令" },
@@ -664,6 +672,18 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.provider.file.creation", "创建时间" },
                 { "hex.builtin.provider.file.access", "最后访问时间" },
                 { "hex.builtin.provider.file.modification", "最后更改时间" },
+
+                //{ "hex.builtin.provider.file", "File Provider" },
+                //{ "hex.builtin.provider.gdb", "GDB Server Provider" },
+                    //{ "hex.builtin.provider.gdb.name", "GDB Server <{0}:{1}>" },
+                    //{ "hex.builtin.provider.gdb.server", "Server" },
+                    //{ "hex.builtin.provider.gdb.ip", "IP Address" },
+                    //{ "hex.builtin.provider.gdb.port", "Port" },
+                //{ "hex.builtin.provider.disk", "Raw Disk Provider" },
+                    //{ "hex.builtin.provider.disk.selected_disk", "Disk" },
+                    //{ "hex.builtin.provider.disk.disk_size", "Disk Size" },
+                    //{ "hex.builtin.provider.disk.sector_size", "Sector Size" },
+                    //{ "hex.builtin.provider.disk.reload", "Reload" },
         });
     }
 

plugins/builtin/source/plugin_builtin.cpp

@@ -2,12 +2,14 @@
 
 namespace hex::plugin::builtin {
 
+    void registerViews();
     void registerDataInspectorEntries();
     void registerToolEntries();
     void registerPatternLanguageFunctions();
     void registerCommandPaletteCommands();
     void registerSettings();
     void registerDataProcessorNodes();
+    void registerProviders();
 
     void addFooterItems();
     void addToolbarItems();
@@ -23,12 +25,14 @@ IMHEX_PLUGIN_SETUP("Built-in", "WerWolv", "Default ImHex functionality") {
 
     using namespace hex::plugin::builtin;
 
+    registerViews();
     registerDataInspectorEntries();
     registerToolEntries();
     registerPatternLanguageFunctions();
     registerCommandPaletteCommands();
     registerSettings();
     registerDataProcessorNodes();
+    registerProviders();
 
     addFooterItems();
     addToolbarItems();

plugins/libimhex/CMakeLists.txt

@@ -13,8 +13,11 @@ set(CMAKE_USE_MBEDTLS ON)
 set(BUILD_CURL_EXE OFF)
 set(FPHSA_NAME_MISMATCHED ON CACHE BOOL "")
 
+# Find packages
+find_package(PkgConfig REQUIRED)
+
 if(NOT USE_SYSTEM_NLOHMANN_JSON)
-  add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../../external/nlohmann_json ${CMAKE_CURRENT_BINARY_DIR}/external/nlohmann_json)
+  add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../../external/nlohmann_json ${CMAKE_CURRENT_BINARY_DIR}/external/nlohmann_json EXCLUDE_FROM_ALL)
   set(NLOHMANN_JSON_LIBRARIES nlohmann_json)
 else()
   find_package(nlohmann_json 3.10.2 REQUIRED)
@@ -22,7 +25,7 @@ else()
 endif()
 
 if(NOT USE_SYSTEM_FMT)
-  add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../../external/fmt ${CMAKE_CURRENT_BINARY_DIR}/external/fmt)
+  add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../../external/fmt ${CMAKE_CURRENT_BINARY_DIR}/external/fmt EXCLUDE_FROM_ALL)
   set(FMT_LIBRARIES fmt-header-only)
 else()
   find_package(fmt 8.0.0 REQUIRED)
@@ -52,6 +55,31 @@ else()
     pkg_check_modules(YARA REQUIRED IMPORTED_TARGET yara)
 endif()
 
+if (NOT USE_SYSTEM_CAPSTONE)
+    set(CAPSTONE_BUILD_STATIC_RUNTIME OFF)
+    set(CAPSTONE_BUILD_SHARED OFF)
+    set(CAPSTONE_BUILD_TESTS OFF)
+    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../../external/capstone ${CMAKE_CURRENT_BINARY_DIR}/external/capstone EXCLUDE_FROM_ALL)
+    set_target_properties(capstone-static PROPERTIES POSITION_INDEPENDENT_CODE ON)
+    set(CAPSTONE_LIBRARIES "capstone-static")
+    set(CAPSTONE_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../../external/capstone/include/capstone)
+else()
+    find_package(PkgConfig REQUIRED)
+    pkg_search_module(CAPSTONE 4.0.2 REQUIRED capstone)
+endif()
+
+
+
+find_package(mbedTLS 2.26.0 REQUIRED)
+configurePython()
+
+pkg_search_module(MAGIC libmagic>=5.39)
+if(NOT MAGIC_FOUND)
+    find_library(MAGIC 5.39 magic REQUIRED)
+else()
+    set(MAGIC_INCLUDE_DIRS ${MAGIC_INCLUDEDIR})
+endif()
+
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
 
 if (WIN32)
@@ -77,6 +105,11 @@ set(LIBIMHEX_SOURCES
     source/helpers/lang.cpp
     source/helpers/net.cpp
     source/helpers/file.cpp
+    source/helpers/socket.cpp
+    source/helpers/patches.cpp
+    source/helpers/project_file_handler.cpp
+    source/helpers/encoding_file.cpp
+    source/helpers/loader_script_handler.cpp
 
     source/pattern_language/pattern_language.cpp
     source/pattern_language/preprocessor.cpp
@@ -108,7 +141,7 @@ endif ()
 
 add_library(libimhex SHARED ${LIBIMHEX_SOURCES})
 
-target_include_directories(libimhex PUBLIC include ${MBEDTLS_INCLUDE_DIR} ${XDGPP_INCLUDE_DIRS} ${MBEDTLS_INCLUDE_DIRS} ${CAPSTONE_INCLUDE_DIRS} ${MAGIC_INCLUDE_DIRS} ${Python_INCLUDE_DIRS} ${LLVM_INCLUDE_DIRS} ${FMT_INCLUDE_DIRS} ${CURL_INCLUDE_DIRS} ${YARA_INCLUDE_DIRS})
+target_include_directories(libimhex PUBLIC include ${XDGPP_INCLUDE_DIRS} ${MBEDTLS_INCLUDE_DIRS} ${CAPSTONE_INCLUDE_DIRS} ${MAGIC_INCLUDE_DIRS} ${Python_INCLUDE_DIRS} ${LLVM_INCLUDE_DIRS} ${FMT_INCLUDE_DIRS} ${CURL_INCLUDE_DIRS} ${YARA_INCLUDE_DIRS})
 target_link_directories(libimhex PUBLIC ${MBEDTLS_LIBRARY_DIR} ${CAPSTONE_LIBRARY_DIRS} ${MAGIC_LIBRARY_DIRS})
 
 if (APPLE)
@@ -116,4 +149,4 @@ if (APPLE)
     target_link_libraries(libimhex PUBLIC ${FOUNDATION})
 endif ()
 
-target_link_libraries(libimhex PUBLIC imgui nfd magic capstone LLVMDemangle microtar ${NLOHMANN_JSON_LIBRARIES} ${YARA_LIBRARIES} ${LIBCURL_LIBRARIES} ${MBEDTLS_LIBRARIES} ${FMT_LIBRARIES} ${Python_LIBRARIES})
+target_link_libraries(libimhex PUBLIC imgui nfd magic ${CAPSTONE_LIBRARIES} LLVMDemangle microtar ${NLOHMANN_JSON_LIBRARIES} ${YARA_LIBRARIES} ${LIBCURL_LIBRARIES} ${MBEDTLS_LIBRARIES} ${FMT_LIBRARIES} ${Python_LIBRARIES})

plugins/libimhex/include/hex/api/content_registry.hpp

@@ -3,6 +3,8 @@
 #include <hex.hpp>
 #include <hex/helpers/concepts.hpp>
 #include <hex/pattern_language/token.hpp>
+#include <hex/api/imhex_api.hpp>
+#include <hex/api/event.hpp>
 
 #include <functional>
 #include <map>
@@ -18,6 +20,7 @@ namespace hex {
     class LanguageDefinition;
     namespace pl { class Evaluator; }
     namespace dp { class Node; }
+    namespace prv { class Provider; }
 
     /*
         The Content Registry is the heart of all features in ImHex that are in some way extendable by Plugins.
@@ -52,7 +55,7 @@ namespace hex {
             std::map<std::string, std::vector<Entry>>& getEntries();
             nlohmann::json getSetting(const std::string &unlocalizedCategory, const std::string &unlocalizedName);
             nlohmann::json& getSettingsData();
-        };
+        }
 
         /* Command Palette Command Registry. Allows adding of new commands to the command palette */
         namespace CommandPaletteCommands {
@@ -75,7 +78,7 @@ namespace hex {
 
             void add(Type type, const std::string &command, const std::string &unlocalizedDescription, const DisplayCallback &displayCallback, const ExecuteCallback &executeCallback = [](auto){});
             std::vector<Entry>& getEntries();
-        };
+        }
 
         /* Pattern Language Function Registry. Allows adding of new functions that may be used inside the pattern language */
         namespace PatternLanguageFunctions {
@@ -95,34 +98,45 @@ namespace hex {
 
             void add(const Namespace &ns, const std::string &name, u32 parameterCount, const Callback &func);
             std::map<std::string, ContentRegistry::PatternLanguageFunctions::Function>& getEntries();
-        };
+        }
 
         /* View Registry. Allows adding of new windows */
         namespace Views {
-            void add(View *view);
+
+            namespace impl {
+
+                void add(View *view);
+
+            }
+
 
             template<hex::derived_from<View> T, typename ... Args>
             void add(Args&& ... args) {
-                return add(new T(std::forward<Args>(args)...));
+                return impl::add(new T(std::forward<Args>(args)...));
             }
 
             std::vector<View*>& getEntries();
 
-        };
+        }
 
         /* Tools Registry. Allows adding new entries to the tools window */
         namespace Tools {
-            using Callback = std::function<void()>;
 
-            struct Entry {
-                std::string name;
-                Callback function;
-            };
+            namespace impl {
 
-            void add(const std::string &unlocalizedName, const Callback &function);
+                using Callback = std::function<void()>;
 
-            std::vector<Entry>& getEntries();
-        };
+                struct Entry {
+                    std::string name;
+                    Callback function;
+                };
+
+            }
+
+            void add(const std::string &unlocalizedName, const impl::Callback &function);
+
+            std::vector<impl::Entry>& getEntries();
+        }
 
         /* Data Inspector Registry. Allows adding of new types to the data inspector */
         namespace DataInspector {
@@ -133,35 +147,45 @@ namespace hex {
                 Octal
             };
 
-            using DisplayFunction = std::function<std::string()>;
-            using GeneratorFunction = std::function<DisplayFunction(const std::vector<u8>&, std::endian, NumberDisplayStyle)>;
+            namespace impl {
 
-            struct Entry {
-                std::string unlocalizedName;
-                size_t requiredSize;
-                GeneratorFunction generatorFunction;
-            };
+                using DisplayFunction = std::function<std::string()>;
+                using GeneratorFunction = std::function<DisplayFunction(const std::vector<u8>&, std::endian, NumberDisplayStyle)>;
 
-            void add(const std::string &unlocalizedName, size_t requiredSize, GeneratorFunction function);
+                struct Entry {
+                    std::string unlocalizedName;
+                    size_t requiredSize;
+                    impl::GeneratorFunction generatorFunction;
+                };
 
-            std::vector<Entry>& getEntries();
-        };
+            }
+
+            void add(const std::string &unlocalizedName, size_t requiredSize, impl::GeneratorFunction function);
+
+            std::vector<impl::Entry>& getEntries();
+        }
 
         /* Data Processor Node Registry. Allows adding new processor nodes to be used in the data processor */
         namespace DataProcessorNode {
 
-            using CreatorFunction = std::function<dp::Node*()>;
-            struct Entry {
-                std::string category;
-                std::string name;
-                CreatorFunction creatorFunction;
-            };
+            namespace impl {
+
+                using CreatorFunction = std::function<dp::Node*()>;
+
+                struct Entry {
+                    std::string category;
+                    std::string name;
+                    CreatorFunction creatorFunction;
+                };
+
+                void add(const Entry &entry);
+
+            }
 
-            void add(const Entry &entry);
 
             template<hex::derived_from<dp::Node> T, typename ... Args>
             void add(const std::string &unlocalizedCategory, const std::string &unlocalizedName, Args&& ... args) {
-                add(Entry{ unlocalizedCategory.c_str(), unlocalizedName.c_str(),
+                add(impl::Entry{ unlocalizedCategory.c_str(), unlocalizedName.c_str(),
                    [=]{
                         auto node = new T(std::forward<Args>(args)...);
                         node->setUnlocalizedName(unlocalizedName);
@@ -172,9 +196,9 @@ namespace hex {
 
             void addSeparator();
 
-            std::vector<Entry>& getEntries();
+            std::vector<impl::Entry>& getEntries();
 
-        };
+        }
 
         /* Language Registry. Allows together with the LangEntry class and the _lang user defined literal to add new languages */
         namespace Language {
@@ -183,7 +207,7 @@ namespace hex {
 
             std::map<std::string, std::string>& getLanguages();
             std::map<std::string, std::vector<LanguageDefinition>>& getLanguageDefinitions();
-        };
+        }
 
         /* Interface Registry. Allows adding new items to various interfaces */
         namespace Interface {
@@ -196,7 +220,37 @@ namespace hex {
             std::vector<DrawCallback>& getWelcomeScreenEntries();
             std::vector<DrawCallback>& getFooterItems();
             std::vector<DrawCallback>& getToolbarItems();
-        };
+        }
+
+        /* Provider Registry. Allows adding new data providers to be created from the UI */
+        namespace Provider {
+
+            namespace impl {
+
+                void addProviderName(const std::string &unlocalizedName);
+
+            }
+
+            template<hex::derived_from<hex::prv::Provider> T>
+            void add(const std::string &unlocalizedName, bool addToList = true) {
+                (void) EventManager::subscribe<RequestCreateProvider>([expectedName = unlocalizedName](const std::string &name, hex::prv::Provider **provider){
+                    if (name != expectedName) return;
+
+                    auto newProvider = new T();
+
+                    hex::ImHexApi::Provider::add(newProvider);
+
+                    if (provider != nullptr)
+                        *provider = newProvider;
+                });
+
+                if (addToList)
+                    impl::addProviderName(unlocalizedName);
+            }
+
+            const std::vector<std::string>& getEntries();
+
+        }
     };
 
 }

plugins/libimhex/include/hex/api/event.hpp

@@ -107,6 +107,7 @@ namespace hex {
     EVENT_DEF(EventSettingsChanged);
     EVENT_DEF(EventAbnormalTermination, int);
     EVENT_DEF(EventOSThemeChanged);
+    EVENT_DEF(EventProviderCreated, prv::Provider*);
 
     EVENT_DEF(RequestOpenWindow, std::string);
     EVENT_DEF(RequestSelectionChange, Region);
@@ -117,6 +118,7 @@ namespace hex {
     EVENT_DEF(RequestOpenFile, std::string);
     EVENT_DEF(RequestChangeTheme, u32);
     EVENT_DEF(RequestOpenPopup, std::string);
+    EVENT_DEF(RequestCreateProvider, std::string, hex::prv::Provider **);
 
     EVENT_DEF(QuerySelection, Region&);
 

plugins/libimhex/include/hex/helpers/disassembler.hpp

@@ -22,6 +22,10 @@ namespace hex {
         TMS320C64X,
         M680X,
         EVM,
+        MOS65XX,
+        WASM,
+        BPF,
+        RISCV,
 
         MAX,
         MIN = ARM
@@ -37,7 +41,7 @@ namespace hex {
             return cs_support(toCapstoneArchictecture(architecture));
         }
 
-        constexpr static const char * const ArchitectureNames[] = { "ARM32", "ARM64", "MIPS", "x86", "PowerPC", "Sparc", "SystemZ", "XCore", "68K", "TMS320C64x", "680X", "Ethereum" };
+        constexpr static const char * const ArchitectureNames[] = { "ARM32", "ARM64", "MIPS", "x86", "PowerPC", "Sparc", "SystemZ", "XCore", "68K", "TMS320C64x", "680X", "Ethereum", "MOS65XX", "WebAssembly", "Berkeley Packet Filter", "RISC-V" };
 
         static inline s32 getArchitectureSupportedCount() {
             static s32 supportedCount = -1;

plugins/libimhex/include/hex/helpers/project_file_handler.hpp

@@ -92,14 +92,14 @@ namespace hex {
         }
 
     private:
-        static inline std::string s_currProjectFilePath;
-        static inline bool s_hasUnsavedChanged = false;
+        static std::string s_currProjectFilePath;
+        static bool s_hasUnsavedChanged;
 
-        static inline std::string s_filePath;
-        static inline std::string s_pattern;
-        static inline Patches s_patches;
-        static inline std::list<ImHexApi::Bookmarks::Entry> s_bookmarks;
-        static inline std::string s_dataProcessorContent;
+        static std::string s_filePath;
+        static std::string s_pattern;
+        static Patches s_patches;
+        static std::list<ImHexApi::Bookmarks::Entry> s_bookmarks;
+        static std::string s_dataProcessorContent;
     };
 
 }

plugins/libimhex/include/hex/helpers/shared_data.hpp

@@ -62,8 +62,8 @@ namespace hex {
         static std::vector<ContentRegistry::CommandPaletteCommands::Entry> commandPaletteCommands;
         static std::map<std::string, ContentRegistry::PatternLanguageFunctions::Function> patternLanguageFunctions;
         static std::vector<View*> views;
-        static std::vector<ContentRegistry::Tools::Entry> toolsEntries;
-        static std::vector<ContentRegistry::DataInspector::Entry> dataInspectorEntries;
+        static std::vector<ContentRegistry::Tools::impl::Entry> toolsEntries;
+        static std::vector<ContentRegistry::DataInspector::impl::Entry> dataInspectorEntries;
         static u32 patternPaletteOffset;
         static std::string popupMessage;
         static std::list<ImHexApi::Bookmarks::Entry> bookmarkEntries;
@@ -77,7 +77,9 @@ namespace hex {
         static std::vector<ContentRegistry::Interface::DrawCallback> footerItems;
         static std::vector<ContentRegistry::Interface::DrawCallback> toolbarItems;
 
-        static std::vector<ContentRegistry::DataProcessorNode::Entry> dataProcessorNodes;
+        static std::vector<std::string> providerNames;
+
+        static std::vector<ContentRegistry::DataProcessorNode::impl::Entry> dataProcessorNodes;
         static u32 dataProcessorNodeIdCounter;
         static u32 dataProcessorLinkIdCounter;
         static u32 dataProcessorAttrIdCounter;

plugins/libimhex/include/hex/helpers/socket.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <hex.hpp>
+
+#include <string>
+#include <vector>
+
+#if defined(OS_WINDOWS)
+    #include <winsock2.h>
+    #include <ws2tcpip.h>
+    #include <windows.h>
+
+    #define SOCKET_NONE INVALID_SOCKET
+#else
+    #include <unistd.h>
+    #include <sys/socket.h>
+    #include <netinet/ip.h>
+    #include <arpa/inet.h>
+
+    #define SOCKET_NONE -1
+#endif
+
+namespace hex {
+
+    class Socket {
+    public:
+        Socket() = default;
+        Socket(const Socket&) = delete;
+        Socket(Socket &&other);
+
+        Socket(const std::string &address, u16 port);
+        ~Socket();
+
+        void connect(const std::string &address, u16 port);
+        void disconnect();
+
+        [[nodiscard]]
+        bool isConnected() const;
+
+        std::string readString(size_t size = 0x1000) const;
+        std::vector<u8> readBytes(size_t size = 0x1000) const;
+
+        void writeString(const std::string &string) const;
+        void writeBytes(const std::vector<u8> &bytes) const;
+
+    private:
+        bool m_connected = false;
+        #if defined(OS_WINDOWS)
+            SOCKET m_socket = SOCKET_NONE;
+        #else
+            int m_socket = SOCKET_NONE;
+        #endif
+    };
+
+}

plugins/libimhex/include/hex/helpers/utils.hpp

@@ -14,6 +14,7 @@
 #include <optional>
 #include <string>
 #include <type_traits>
+#include <variant>
 #include <vector>
 
 #include <nfd.hpp>
@@ -227,6 +228,17 @@ namespace hex {
         return iter != a.end();
     }
 
+    template<typename T, typename ... VariantTypes>
+    T get_or(const std::variant<VariantTypes...> &variant, T alt) {
+        const T *value = std::get_if<T>(&variant);
+        if (value == nullptr)
+            return alt;
+        else
+            return *value;
+    }
+
+    bool isProcessElevated();
+
     namespace scope_guard {
 
         #define SCOPE_GUARD ::hex::scope_guard::ScopeGuardOnExit() + [&]()

plugins/libimhex/include/hex/pattern_language/ast_node.hpp

@@ -1090,13 +1090,13 @@ namespace hex::pl {
             offset = evaluator->dataOffset();
 
             {
-                auto pointedAtPattern = this->m_type->createPatterns(evaluator).front();
-
                 u128 pointerAddress = 0;
                 evaluator->getProvider()->read(pattern->getOffset(), &pointerAddress, pattern->getSize());
                 pointerAddress = hex::changeEndianess(pointerAddress, sizePattern->getSize(), sizePattern->getEndian());
 
-                pointedAtPattern->setOffset(pointerAddress);
+                evaluator->dataOffset() = pointerAddress;
+
+                auto pointedAtPattern = this->m_type->createPatterns(evaluator).front();
 
                 pattern->setPointedAtPattern(pointedAtPattern);
                 pattern->setEndian(sizePattern->getEndian());
@@ -1647,9 +1647,9 @@ namespace hex::pl {
                                     LogConsole::abortEvaluation("array index out of bounds", this);
 
                                 auto newPattern = searchScope.front()->clone();
+                                newPattern->setOffset(staticArrayPattern->getOffset() + index * staticArrayPattern->getTemplate()->getSize());
                                 delete currPattern;
                                 currPattern = newPattern;
-                                currPattern->setOffset(staticArrayPattern->getOffset() + index * staticArrayPattern->getSize());
                             }
                         }
                     }, index->getValue());

plugins/libimhex/include/hex/pattern_language/evaluator.hpp

@@ -149,6 +149,18 @@ namespace hex::pl {
                 LogConsole::abortEvaluation("evaluation aborted by user");
         }
 
+        [[nodiscard]]
+        std::optional<Token::Literal> getEnvVariable(const std::string &name) const {
+            if (this->m_envVariables.contains(name))
+                return this->m_envVariables.at(name);
+            else
+                return std::nullopt;
+        }
+
+        void setEnvVariable(const std::string &name, const Token::Literal &value) {
+            this->m_envVariables[name] = value;
+        }
+
     private:
 
         void patternCreated();
@@ -173,6 +185,7 @@ namespace hex::pl {
         std::map<std::string, ContentRegistry::PatternLanguageFunctions::Function> m_customFunctions;
         std::vector<ASTNode*> m_customFunctionDefinitions;
         std::vector<Token::Literal> m_stack;
+        std::map<std::string, Token::Literal> m_envVariables;
 
         friend class PatternCreationLimiter;
     };

plugins/libimhex/include/hex/pattern_language/pattern_language.hpp

@@ -3,12 +3,14 @@
 #include <hex.hpp>
 
 #include <bit>
+#include <map>
 #include <optional>
 #include <string>
 #include <string_view>
 #include <vector>
 
 #include <hex/pattern_language/log_console.hpp>
+#include <hex/pattern_language/token.hpp>
 
 namespace hex::prv { class Provider; }
 
@@ -28,8 +30,8 @@ namespace hex::pl {
         PatternLanguage();
         ~PatternLanguage();
 
-        std::optional<std::vector<PatternData*>> executeString(prv::Provider *provider, const std::string &string);
-        std::optional<std::vector<PatternData*>> executeFile(prv::Provider *provider, const std::string &path);
+        std::optional<std::vector<PatternData*>> executeString(prv::Provider *provider, const std::string &string, const std::map<std::string, Token::Literal> &envVars = { });
+        std::optional<std::vector<PatternData*>> executeFile(prv::Provider *provider, const std::string &path, const std::map<std::string, Token::Literal> &envVars = { });
 
         void abort();
 

plugins/libimhex/include/hex/providers/provider.hpp

@@ -19,16 +19,14 @@ namespace hex::prv {
         Provider();
         virtual ~Provider();
 
-        virtual bool isAvailable() const = 0;
-        virtual bool isReadable() const = 0;
-        virtual bool isWritable() const = 0;
-        virtual bool isResizable() const = 0;
-        virtual bool isSavable() const = 0;
+        [[nodiscard]] virtual bool isAvailable() const = 0;
+        [[nodiscard]] virtual bool isReadable() const = 0;
+        [[nodiscard]] virtual bool isWritable() const = 0;
+        [[nodiscard]] virtual bool isResizable() const = 0;
+        [[nodiscard]] virtual bool isSavable() const = 0;
 
         virtual void read(u64 offset, void *buffer, size_t size, bool overlays = true);
-        virtual void readRelative(u64 offset, void *buffer, size_t size, bool overlays = true);
         virtual void write(u64 offset, const void *buffer, size_t size);
-        virtual void writeRelative(u64 offset, const void *buffer, size_t size);
 
         virtual void resize(ssize_t newSize);
 
@@ -37,37 +35,46 @@ namespace hex::prv {
 
         virtual void readRaw(u64 offset, void *buffer, size_t size) = 0;
         virtual void writeRaw(u64 offset, const void *buffer, size_t size) = 0;
-        virtual size_t getActualSize() const  = 0;
+        [[nodiscard]] virtual size_t getActualSize() const  = 0;
 
         void applyOverlays(u64 offset, void *buffer, size_t size);
 
-        std::map<u64, u8>& getPatches();
-        const std::map<u64, u8>& getPatches() const;
+        [[nodiscard]] std::map<u64, u8>& getPatches();
+        [[nodiscard]] const std::map<u64, u8>& getPatches() const;
         void applyPatches();
 
         [[nodiscard]] Overlay* newOverlay();
         void deleteOverlay(Overlay *overlay);
         [[nodiscard]] const std::list<Overlay*>& getOverlays();
 
-        u32 getPageCount() const;
-        u32 getCurrentPage() const;
+        [[nodiscard]] u32 getPageCount() const;
+        [[nodiscard]] u32 getCurrentPage() const;
         void setCurrentPage(u32 page);
 
         virtual void setBaseAddress(u64 address);
-        virtual u64 getBaseAddress() const;
-        virtual size_t getSize() const;
-        virtual std::optional<u32> getPageOfAddress(u64 address) const;
+        [[nodiscard]] virtual u64 getBaseAddress() const;
+        [[nodiscard]] virtual u64 getCurrentPageAddress() const;
+        [[nodiscard]] virtual size_t getSize() const;
+        [[nodiscard]] virtual std::optional<u32> getPageOfAddress(u64 address) const;
 
         [[nodiscard]] virtual std::string getName() const = 0;
         [[nodiscard]] virtual std::vector<std::pair<std::string, std::string>> getDataInformation() const = 0;
 
+        [[nodiscard]] virtual bool open() = 0;
+        virtual void close() = 0;
+
         void addPatch(u64 offset, const void *buffer, size_t size);
 
         void undo();
         void redo();
 
-        bool canUndo() const;
-        bool canRedo() const;
+        [[nodiscard]] bool canUndo() const;
+        [[nodiscard]] bool canRedo() const;
+
+        [[nodiscard]] virtual bool hasLoadInterface() const;
+        [[nodiscard]] virtual bool hasInterface() const;
+        virtual void drawLoadInterface();
+        virtual void drawInterface();
 
     protected:
         u32 m_currPage = 0;

plugins/libimhex/source/api/content_registry.cpp

@@ -184,7 +184,7 @@ namespace hex {
 
     /* Views */
 
-    void ContentRegistry::Views::add(View *view) {
+    void ContentRegistry::Views::impl::add(View *view) {
         getEntries().emplace_back(view);
     }
 
@@ -196,27 +196,27 @@ namespace hex {
     /* Tools */
 
     void ContentRegistry::Tools:: add(const std::string &unlocalizedName, const std::function<void()> &function) {
-        getEntries().emplace_back(Entry{ unlocalizedName, function });
+        getEntries().emplace_back(impl::Entry{ unlocalizedName, function });
     }
 
-    std::vector<ContentRegistry::Tools::Entry>& ContentRegistry::Tools::getEntries() {
+    std::vector<ContentRegistry::Tools::impl::Entry>& ContentRegistry::Tools::getEntries() {
         return SharedData::toolsEntries;
     }
 
 
     /* Data Inspector */
 
-    void ContentRegistry::DataInspector::add(const std::string &unlocalizedName, size_t requiredSize, ContentRegistry::DataInspector::GeneratorFunction function) {
+    void ContentRegistry::DataInspector::add(const std::string &unlocalizedName, size_t requiredSize, ContentRegistry::DataInspector::impl::GeneratorFunction function) {
         getEntries().push_back({ unlocalizedName, requiredSize, std::move(function) });
     }
 
-    std::vector<ContentRegistry::DataInspector::Entry>& ContentRegistry::DataInspector::getEntries() {
+    std::vector<ContentRegistry::DataInspector::impl::Entry>& ContentRegistry::DataInspector::getEntries() {
         return SharedData::dataInspectorEntries;
     }
 
     /* Data Processor Nodes */
 
-    void ContentRegistry::DataProcessorNode::add(const Entry &entry) {
+    void ContentRegistry::DataProcessorNode::impl::add(const impl::Entry &entry) {
         getEntries().push_back(entry);
     }
 
@@ -224,7 +224,7 @@ namespace hex {
         getEntries().push_back({ "", "", []{ return nullptr; } });
     }
 
-    std::vector<ContentRegistry::DataProcessorNode::Entry>& ContentRegistry::DataProcessorNode::getEntries() {
+    std::vector<ContentRegistry::DataProcessorNode::impl::Entry>& ContentRegistry::DataProcessorNode::getEntries() {
         return SharedData::dataProcessorNodes;
     }
 
@@ -269,4 +269,15 @@ namespace hex {
     std::vector<ContentRegistry::Interface::DrawCallback>& ContentRegistry::Interface::getToolbarItems() {
         return SharedData::toolbarItems;
     }
+
+
+    /* Providers */
+
+    void ContentRegistry::Provider::impl::addProviderName(const std::string &unlocalizedName) {
+        SharedData::providerNames.push_back(unlocalizedName);
+    }
+
+    const std::vector<std::string> &ContentRegistry::Provider::getEntries() {
+        return SharedData::providerNames;
+    }
 }

plugins/libimhex/source/api/imhex_api.cpp

@@ -68,6 +68,8 @@ namespace hex {
     void ImHexApi::Provider::add(prv::Provider *provider) {
         SharedData::providers.push_back(provider);
         SharedData::currentProvider = SharedData::providers.size() - 1;
+
+        EventManager::post<EventProviderCreated>(provider);
     }
 
     void ImHexApi::Provider::remove(prv::Provider *provider) {

plugins/libimhex/source/helpers/encoding_file.cpp

@@ -1,4 +1,4 @@
-#include "helpers/encoding_file.hpp"
+#include <hex/helpers/encoding_file.hpp>
 
 #include <hex/helpers/utils.hpp>