build: Bumped version to 1.12.0

This reverts commit 5759f163e3.

.github/workflows/build.yml

@@ -19,7 +19,7 @@ jobs:
       with:
         fetch-depth: 0
         submodules: recursive
-        
+
     - name: 📜 Restore cache
       uses: actions/cache@v2
       with:
@@ -33,7 +33,7 @@ jobs:
       run: |
         sudo apt update
         sudo bash dist/get_deps_debian.sh
-        
+
         curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs > rustup-init.sh
         sh rustup-init.sh -y --default-toolchain none
         rm rustup-init.sh
@@ -61,6 +61,16 @@ jobs:
         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 build-bundle imhex imhex.flatpak net.werwolv.ImHex stable
+        
+    - name: 📦 Bundle DEB
+      run: |
+        dpkg-deb --build build/install
+        mv build/install.deb imhex.deb
+
+    - name: 📦 Bundle AppImage
+      run: |
+        dist/AppImage/package.sh build
+        mv build/ImHex-x86_64.AppImage imhex.AppImage
 
     - name: ⬆️ Upload ELF
       uses: actions/upload-artifact@v2
@@ -74,7 +84,21 @@ jobs:
       with:
         name: Linux Flatpak
         path: |
-         imhex.flatpak
+          imhex.flatpak
+         
+    - name: ⬆️ Upload .deb
+      uses: actions/upload-artifact@v2
+      with:
+        name: Linux DEB
+        path: |
+          imhex.deb
+
+    - name: ⬆️ Upload AppImage
+      uses: actions/upload-artifact@v2
+      with:
+        name: Linux AppImage
+        path: |
+          imhex.AppImage
 
   win:
     runs-on: windows-latest
@@ -92,14 +116,26 @@ jobs:
       with:
         fetch-depth: 0
         submodules: recursive
-        
+
     - name: 🟦 Install msys2
       uses: msys2/setup-msys2@v2
+      with:
+        msystem: mingw64
+        pacboy: >-
+          gcc:p
+          cmake:p
+          make:p
+          ccache:p
+          capstone:p
+          glfw:p
+          file:p
+          mbedtls:p
+          python:p
+          freetype:p
+          dlfcn:p
 
     - name: ⬇️ Install dependencies
       run: |
-        bash dist/get_deps_msys2.sh
-        
         curl --proto '=https' --tlsv1.2 -sSf https://win.rustup.rs > rustup-init.exe
         ./rustup-init.exe -y --default-host=x86_64-pc-windows-gnu --default-toolchain=none
         rm rustup-init.exe

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.0")
+set(IMHEX_VERSION "1.12.0")
 project(imhex VERSION ${IMHEX_VERSION})
 
 set(CMAKE_CXX_STANDARD 20)
@@ -46,33 +46,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 +54,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()

README.md

@@ -100,7 +100,13 @@ If you like my work, please consider supporting me on GitHub Sponsors, Patreon o
 
 ## Pattern Language
 
-The custom C-like Pattern Language developed and used by ImHex is easy to read, understand and learn. A guide with all features of the language can be found [in the wiki](https://github.com/WerWolv/ImHex/wiki/Pattern-Language-Guide) or a simpler version in ImHex under `Help -> Pattern Language Cheat Sheet`
+The custom C-like Pattern Language developed and used by ImHex is easy to read, understand and learn. A guide with all features of the language can be found [on the docs page](http://imhex.werwolv.net/docs).
+
+## Plugin development
+
+To develop plugins for ImHex, use one of the following two templates projects to get startet. You then have access to the entirety of libimhex as well as the ImHex API and the Content Registry to interact with ImHex or to add new content.
+- [C++ Plugin Template](https://github.com/WerWolv/ImHex-Cpp-Plugin-Template)
+- [Rust Plugin Template](https://github.com/WerWolv/ImHex-Rust-Plugin-Template)
 
 ## Additional Files
 
@@ -209,6 +215,15 @@ with the environment variables `XDG_CONFIG_HOME`, `XDG_CONFIG_DIRS`,
 
 ## Credits
 
+### Contributors
+
+- [Mary](https://github.com/Thog) for her immense help porting ImHex to MacOS and help during development
+- [Roblabla](https://github.com/Roblabla) for adding MSI Installer support to ImHex
+- [jam1garner](https://github.com/jam1garner) and [raytwo](https://github.com/raytwo) for their help with adding Rust support to plugins
+- All other people that have been reporting issues on Discord or GitHub that I had great conversations with :)
+
+### Libraries
+
 - Thanks a lot to ocornut for their amazing [Dear ImGui](https://github.com/ocornut/imgui) which is used for building the entire interface
   - Thanks to ocornut as well for their hex editor view used as base for this project.
   - Thanks to BalazsJako for their incredible [ImGuiColorTextEdit](https://github.com/BalazsJako/ImGuiColorTextEdit) used for the pattern language syntax highlighting

cmake/build_helpers.cmake

@@ -84,10 +84,10 @@ macro(detectOS)
         set(MAGIC_INSTALL_LOCATION "magic")
     elseif(UNIX AND NOT APPLE)
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DOS_LINUX")
-        set(CMAKE_INSTALL_BINDIR "bin")
-        set(CMAKE_INSTALL_LIBDIR "lib")
-        set(PLUGINS_INSTALL_LOCATION "share/imhex/plugins")
-        set(MAGIC_INSTALL_LOCATION "share/imhex/magic")
+        set(CMAKE_INSTALL_BINDIR "usr/bin")
+        set(CMAKE_INSTALL_LIBDIR "usr/lib")
+        set(PLUGINS_INSTALL_LOCATION "usr/share/imhex/plugins")
+        set(MAGIC_INSTALL_LOCATION "usr/share/imhex/magic")
     else()
         message(FATAL_ERROR "Unknown / unsupported system!")
     endif()
@@ -186,6 +186,7 @@ macro(createPackage)
         endif ()
     endforeach()
 
+    install(FILES "$<TARGET_FILE:libimhex>" DESTINATION "${CMAKE_INSTALL_LIBDIR}")
     set_target_properties(libimhex PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 
     if (WIN32)
@@ -198,7 +199,7 @@ 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
@@ -207,10 +208,10 @@ macro(createPackage)
         )
 
         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})
@@ -222,6 +223,11 @@ macro(createPackage)
                 )
         endforeach()
         ]])
+    elseif(UNIX AND NOT APPLE)
+        configure_file(${CMAKE_SOURCE_DIR}/dist/DEBIAN/control.in ${CMAKE_BINARY_DIR}/DEBIAN/control)
+        install(FILES ${CMAKE_BINARY_DIR}/DEBIAN/control DESTINATION ${CMAKE_INSTALL_PREFIX}/DEBIAN)
+        install(FILES ${CMAKE_SOURCE_DIR}/dist/imhex.desktop DESTINATION ${CMAKE_INSTALL_PREFIX}/usr/share/applications)
+        install(FILES ${CMAKE_SOURCE_DIR}/res/icon.png DESTINATION ${CMAKE_INSTALL_PREFIX}/usr/share/pixmaps RENAME imhex.png)
     endif()
 
     if (CREATE_BUNDLE)
@@ -266,4 +272,4 @@ macro(setDefaultBuiltTypeIfUnset)
         set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Using Release build type as it was left unset" FORCE)
         set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release")
     endif()
-endmacro()
+endmacro()

dist/AppImage/Dockerfile

@@ -0,0 +1,40 @@
+FROM debian:bullseye-slim
+LABEL maintainer Example <example@example.com>
+
+ARG TAG=master
+ARG REPO=https://github.com/WerWolv/ImHex.git
+
+USER root
+
+# Bring packages up to date
+RUN apt-get update \
+    && apt-get upgrade -y \
+    && apt-get autoremove -y \
+    && apt-get install -y \
+        git \
+        cmake \
+        curl \
+        squashfs-tools
+
+# Fetch source and dependencies
+RUN mkdir -p /source \
+    && cd /source \
+    && git clone $REPO \
+    && cd ImHex \
+    && git checkout $TAG \
+    && git submodule update --init --recursive \
+    && cd /source/ImHex/dist \
+    && ./get_deps_debian.sh
+
+ARG CXX=g++-10
+
+# Build ImHex
+RUN mkdir -p /source/ImHex/build \
+    && cd /source/ImHex/build \
+    && cmake --install-prefix /usr -DCMAKE_BUILD_TYPE=Release .. \
+    && make -j
+
+# Prepare for AppImage
+RUN cd /source/ImHex/dist/AppImage \
+    && ./package.sh /source/ImHex/build \
+    && mv /source/ImHex/build/ImHex-x86_64.AppImage /

dist/AppImage/ImHex.desktop

@@ -0,0 +1,6 @@
+[Desktop Entry]
+Name=ImHex
+Exec=imhex
+Icon=imhex
+Type=Application
+Categories=Utility;

dist/AppImage/README.md

@@ -0,0 +1,22 @@
+# Building an AppImage
+There are two ways of building an AppImage for ImHex, using the provided
+tools here.
+
+If you want to create an AppImage and do not have a build to work from
+already, you can use docker to build ImHex and package an AppImage.
+
+Alternatively you can create an AppImage using an existing build.
+
+## Using docker
+First run `build.sh` to create a docker image. Then run `extract.sh` to get the
+AppImage out. This needs to be in two steps, as a docker build cannot copy
+files out. Nor can docker build use volume mounts.
+
+The environment variable TAG can be set to build for a specific git tag.
+Without the master branch is build.
+
+## Using an existing build
+Run `package.sh` with the build dir as an argument. E.g.:
+```
+./package.sh ../../build
+```

dist/AppImage/build.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+# Set the TAG environment variable to build a specific tag
+# Set the REPO environment variable to point at a different git repository
+
+# Make sure we're in the same directory as this script
+pushd $(dirname "$(realpath "$0")")
+
+BUILDARG=""
+SUFFIX=""
+[ -n "${TAG}" ] && BUILDARG="${BUILDARG} --build-arg=TAG=${TAG}" && SUFFIX=":${TAG}"
+[ -n "${REPO}" ] && BUILDARG="${BUILDARG} --build-arg=REPO=${REPO}"
+
+docker build ${BUILDARG} -t imhex-appimage-build${SUFFIX} .
+
+popd

dist/AppImage/extract.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+# Set the TAG environment variable to move to a versioned name while extracting
+
+# Make sure we're in the same directory as this script
+pushd $(dirname "$(realpath "$0")")
+
+SUFFIX=""
+[ -n "$TAG" ] && SUFFIX=":$TAG"
+
+# Remove old containers
+docker rm imhex 2>&1 > /dev/null
+
+docker run -d --name imhex imhex-appimage-build${SUFFIX} sleep 30 &
+sleep 15
+docker cp imhex:/ImHex-x86_64.AppImage .
+
+# Move to tagged name if $TAG set
+if [ -n "$TAG" ]; then
+    mv ImHex-x86_64.AppImage ImHex-${TAG}-x86_64.AppImage
+    echo -e "\nThe created AppImage can be found here:\n  $(pwd)/ImHex-${TAG}-x86_64.AppImage\n\n"
+else
+    echo -e "\nThe created AppImage can be found here:\n  $(pwd)/ImHex-x86_64.AppImage\n\n"
+fi
+
+popd

dist/AppImage/package.sh

@@ -0,0 +1,56 @@
+#!/bin/bash
+set -e # Exit on error
+set -o pipefail # Bash specific
+
+usage() {
+    echo "Tool to package an ImHex build into an AppImage"
+    echo
+    echo "Usage:"
+    echo "$0 <build dir>"
+    echo
+    exit
+}
+
+MYDIR=$(dirname "$(realpath "$0")")
+
+# Check is a build dir has been specified and it's a dir
+[ -z "$1" ] && usage
+[ -d "$1" ] || usage
+
+set -u # Throw errors when unset variables are used
+
+BUILDDIR=$1
+APPDIR=${BUILDDIR}/ImHex.AppDir
+APPIMAGE=${BUILDDIR}/ImHex-x86_64.AppImage
+
+# Prepare for AppImage
+## Fetch the needed AppImage binaries
+curl -L https://github.com/AppImage/AppImageKit/releases/download/13/AppRun-x86_64 -o ${MYDIR}/AppRun-x86_64
+curl -L https://github.com/AppImage/AppImageKit/releases/download/13/runtime-x86_64 -o ${MYDIR}/runtime-x86_64
+
+## Setup directory structure
+mkdir -p ${BUILDDIR}/ImHex.AppDir/usr/{bin,lib} ${BUILDDIR}/ImHex.AppDir/usr/share/imhex/plugins
+
+## Add ImHex files to structure
+cp ${BUILDDIR}/imhex ${APPDIR}/usr/bin
+cp ${BUILDDIR}/plugins/builtin/builtin.hexplug ${APPDIR}/usr/share/imhex/plugins
+cp ${MYDIR}/{AppRun-x86_64,ImHex.desktop,imhex.png} ${APPDIR}/
+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
+
+# Package it up as described here:
+# https://github.com/AppImage/AppImageKit#appimagetool-usage
+# under 'If you want to generate an AppImage manually'
+# This builds a v2 AppImage according to
+# https://github.com/AppImage/AppImageSpec/blob/master/draft.md#type-2-image-format
+mksquashfs ${APPDIR} ${BUILDDIR}/ImHex.squashfs -root-owned -noappend
+cat ${MYDIR}/runtime-x86_64 > ${APPIMAGE}
+cat ${BUILDDIR}/ImHex.squashfs >> ${APPIMAGE}
+chmod a+x ${APPIMAGE}
+
+if [ ! -f /.dockerenv ]; then
+    echo -e "\nThe created AppImage can be found here:\n  ${APPIMAGE}\n\n"
+fi

dist/DEBIAN/control.in

@@ -0,0 +1,12 @@
+Package: ImHex
+Version: ${PROJECT_VERSION}
+Section: editors
+Priority: optional
+Architecture: amd64
+License: GNU GPL-2
+Depends: libglfw3-dev, libmagic-dev, libmbedtls-dev, libcapstone-dev, python3-dev, libfreetype-dev, libgtk-3-dev, libldap2-dev
+Maintainer: WerWolv <hey@werwolv.net>
+Description: ImHex Hex Editor
+ A Hex Editor for Reverse Engineers, Programmers and
+ people who value their retinas when working at 3 AM.
+

dist/DEBIAN/imhex.desktop

@@ -0,0 +1,11 @@
+[Desktop Entry]
+Name=ImHex
+Comment=ImHex Hex Editor
+GenericName=Hex Editor
+Exec=/usr/bin/imhex %U
+Icon=/usr/share/pixmaps/imhex.png
+Type=Application
+StartupNotify=true
+Categories=GNOME;GTK;Development;
+StartupWMClass=imhex
+

dist/imhex.desktop

@@ -0,0 +1,11 @@
+[Desktop Entry]
+Name=ImHex
+Comment=ImHex Hex Editor
+GenericName=Hex Editor
+Exec=/usr/bin/imhex %U
+Icon=/usr/share/pixmaps/imhex.png
+Type=Application
+StartupNotify=true
+Categories=GNOME;GTK;Development;
+StartupWMClass=imhex
+

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: imhex
+command: /usr/bin/imhex
 
 finish-args:
   - --share=ipc
@@ -68,4 +68,4 @@ modules:
 
     sources:
       - type: git
-        url: https://github.com/WerWolv/ImHex.git
+        url: https://github.com/WerWolv/ImHex.git

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_impl_opengl3_loader.h

@@ -149,6 +149,7 @@ typedef khronos_uint8_t GLubyte;
 #define GL_FILL                           0x1B02
 #define GL_VERSION                        0x1F02
 #define GL_EXTENSIONS                     0x1F03
+#define GL_NEAREST                        0x2600
 #define GL_LINEAR                         0x2601
 #define GL_TEXTURE_MAG_FILTER             0x2800
 #define GL_TEXTURE_MIN_FILTER             0x2801

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/ImGui/source/imgui_impl_opengl3.cpp

@@ -525,7 +525,7 @@ bool ImGui_ImplOpenGL3_CreateFontsTexture()
     glGenTextures(1, &bd->FontTexture);
     glBindTexture(GL_TEXTURE_2D, bd->FontTexture);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 #ifdef GL_UNPACK_ROW_LENGTH // Not on WebGL/ES
     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
 #endif

include/window.hpp

@@ -25,7 +25,8 @@ namespace hex {
 
     private:
         void setupNativeWindow();
-        void updateNativeWindow();
+        void beginNativeWindowFrame();
+        void endNativeWindowFrame();
         void drawTitleBar();
 
         void frameBegin();

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
 

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;
@@ -57,9 +62,6 @@ namespace hex::prv {
         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; }
 

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,12 +197,12 @@ 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;
+            return false;
         }
 
         auto mappingCleanup = SCOPE_GUARD {
@@ -215,7 +214,7 @@ namespace hex::prv {
         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;
+            return false;
         }
 
         fileCleanup.release();
@@ -224,7 +223,7 @@ namespace hex::prv {
         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 +231,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:
@@ -138,7 +138,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 +158,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 +217,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]{
             {
@@ -161,7 +161,7 @@ namespace hex {
                     lastHighlightEnd.reset();
                 }
 
-                ImGui::SameLine(0.0F, col % 8 == 7 ? glyphWidth * 2.5F : glyphWidth * 0.25F);
+                ImGui::SameLine(0.0F, col % 8 == 7 ? glyphWidth * 2.5F : glyphWidth * 0.5F);
             }
             ImGui::TableNextColumn();
         }
@@ -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);
@@ -201,7 +201,7 @@ namespace hex {
                     for (u8 i = 0; i < 2; i++) {
                         for (u8 col = 0; col < this->m_columnCount; col++) {
                             ImGui::TextUnformatted(hex::format(this->m_upperCaseHex ? "{:02X}" : "{:02x}", col).c_str());
-                            ImGui::SameLine(0.0F, col % 8 == 7 ? glyphWidth * 2.5F : glyphWidth * 0.25F);
+                            ImGui::SameLine(0.0F, col % 8 == 7 ? glyphWidth * 2.5F : glyphWidth * 0.5F);
                         }
                         ImGui::TableNextColumn();
                     }
@@ -211,7 +211,7 @@ namespace hex {
                 if (this->m_providerA >= 0 && this->m_providerB >= 0) {
                     auto &providers = ImHexApi::Provider::getProviders();
                     ImGuiListClipper clipper;
-                    clipper.Begin(std::max(providers[this->m_providerA]->getSize() / this->m_columnCount, providers[this->m_providerB]->getSize() / this->m_columnCount));
+                    clipper.Begin(std::max(providers[this->m_providerA]->getSize() / this->m_columnCount, providers[this->m_providerB]->getSize() / this->m_columnCount) + 1, ImGui::GetTextLineHeightWithSpacing());
 
                     // Draw diff lines
                     while (clipper.Step()) {

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());
@@ -96,6 +99,8 @@ namespace hex {
             }
 
             {
+                magic::compile();
+
                 this->m_fileDescription = magic::getDescription(provider);
                 this->m_mimeType = magic::getMIMEType(provider);
                 this->m_dataValid = true;
@@ -106,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);
@@ -178,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)) {
@@ -197,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,6 +1,7 @@
-#include "views/view_strings.hpp"
+#include "content/views/view_strings.hpp"
 
 #include <hex/providers/provider.hpp>
+#include <hex/helpers/fmt.hpp>
 
 #include <cstring>
 #include <thread>
@@ -11,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) {
@@ -39,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();
         }
@@ -65,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)
@@ -94,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();
@@ -116,27 +122,31 @@ namespace hex {
                             }
                         } 
                         for (u64 i = 0; i < view.m_foundStrings.size(); i++) {
-                            if(view.m_regex){
+                            if (view.m_regex) {
                                 if(view.m_pattern_parsed && std::regex_search(readString(view.m_foundStrings[i]), pattern))
                                     view.m_filterIndices.push_back(i);
                             }
-                            else if(readString(view.m_foundStrings[i]).find(data->Buf) != std::string::npos) {
+                            else if (readString(view.m_foundStrings[i]).find(data->Buf) != std::string::npos) {
                                 view.m_filterIndices.push_back(i);
                             }
                         }
                         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);
+                    if (this->m_regex && !this->m_pattern_parsed) {
+                        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.builtin.view.strings.results"_lang, this->m_filterIndices.size()).c_str());
                 }
 
 
@@ -147,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();
 
@@ -214,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("");
                         }
@@ -207,7 +207,7 @@ namespace hex {
 
                 if (context.buffer.empty()) return nullptr;
 
-                provider->readRelative(context.currBlock.base, context.buffer.data(), context.buffer.size());
+                provider->read(context.currBlock.base + provider->getBaseAddress() + provider->getCurrentPageAddress(), context.buffer.data(), context.buffer.size());
 
                 return context.buffer.data();
             };

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,249 +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.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" },
@@ -664,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,253 +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.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" },
@@ -668,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/example_rust/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "example_rust"
 version = "0.1.0"
-authors = ["Marc-André Moreau <marcandre.moreau@gmail.com>"]
+authors = ["WerWolv <hey@werwolv.net>"]
 edition = "2018"
 
 [lib]
@@ -12,4 +12,4 @@ path = "source/plugin_example.rs"
 hex = { path = "../libimhex-rust" }
 
 [profile.release]
-lto = true
+lto = true

plugins/libimhex/CMakeLists.txt

@@ -77,6 +77,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

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/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

@@ -472,8 +472,13 @@ namespace hex::pl {
             auto literal = dynamic_cast<ASTNodeLiteral*>(this->m_value->evaluate(evaluator));
             auto type = dynamic_cast<ASTNodeBuiltinType*>(this->m_type->evaluate(evaluator))->getType();
 
+            auto startOffset= evaluator->dataOffset();
+
             auto typePattern = this->m_type->createPatterns(evaluator).front();
-            ON_SCOPE_EXIT { delete typePattern; };
+            ON_SCOPE_EXIT {
+                evaluator->dataOffset() = startOffset;
+                delete typePattern;
+            };
 
             return std::visit(overloaded {
                     [&, this](PatternData * value) -> ASTNode* { LogConsole::abortEvaluation(hex::format("cannot cast custom type '{}' to '{}'", value->getTypeName(), Token::getTypeName(type)), this); },
@@ -1085,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());
@@ -1642,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>
 

plugins/libimhex/source/helpers/loader_script_handler.cpp

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

plugins/libimhex/source/helpers/magic.cpp

@@ -65,7 +65,7 @@ namespace hex::magic {
 
     std::string getDescription(prv::Provider *provider, size_t size) {
         std::vector<u8> buffer(std::min(provider->getSize(), size), 0x00);
-        provider->readRelative(0x00, buffer.data(), buffer.size());
+        provider->read(provider->getBaseAddress(), buffer.data(), buffer.size());
 
         return getDescription(buffer);
     }
@@ -86,7 +86,7 @@ namespace hex::magic {
 
     std::string getMIMEType(prv::Provider *provider, size_t size) {
         std::vector<u8> buffer(std::min(provider->getSize(), size), 0x00);
-        provider->readRelative(0x00, buffer.data(), buffer.size());
+        provider->read(provider->getBaseAddress(), buffer.data(), buffer.size());
 
         return getMIMEType(buffer);
     }