build: Bumped version to 1.27.1

Closes #931

.github/workflows/analysis.yml

@@ -28,8 +28,8 @@ jobs:
     - name: 📜 Setup ccache
       uses: hendrikmuhs/ccache-action@v1.2
       with:
-        key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
-        restore-keys: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build
+        key: ${{ runner.os }}-analysis-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
+        restore-keys: ${{ runner.os }}-analysis-${{ secrets.CACHE_VERSION }}-build
         max-size: 50M
 
     - name: 📜 Restore CMakeCache
@@ -37,8 +37,8 @@ jobs:
       with:
         path: |
           build/CMakeCache.txt
-        key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ hashFiles('**/CMakeLists.txt') }}
-      
+        key: ${{ runner.os }}-analysis-${{ secrets.CACHE_VERSION }}-build-${{ hashFiles('**/CMakeLists.txt') }}
+
     - name: ⬇️ Install dependencies
       run: |
         sudo apt update

.github/workflows/build.yml

@@ -58,6 +58,7 @@ jobs:
           mbedtls:p
           freetype:p
           dlfcn:p
+          libbacktrace:p
 
     - name: 📜 Set version variable
       run: |
@@ -81,33 +82,24 @@ jobs:
           ..
         mingw32-make -j4 install
         cpack
-        echo "ImHex checks for the existence of this file to determine if it is running in portable mode. You should not delete this file" > $PWD/install/PORTABLE
+        mv imhex-*.msi ../imhex-${{env.IMHEX_VERSION}}-Windows-x86_64.msi
 
-    #- name: 🗝️ Sign Windows Installer
-    #  if: github.event_name == 'push' && github.ref == 'refs/heads/master'
-    #  shell: powershell
-    #  env:
-    #    WIN_SIGN_CERT: ${{ secrets.WIN_SIGN_CERT }}
-    #    WIN_SIGN_PW: ${{ secrets.WIN_SIGN_PW }}
-    #  run: |
-    #    $buffer = [System.Convert]::FromBase64String($env:WIN_SIGN_CERT)
-    #    $certificate = [System.Security.Cryptography.X509Certificates.X509Certificate2]::New($buffer, $env:WIN_SIGN_PW)
-    #    Get-ChildItem -Path ./build -Filter *.msi -Recurse | Set-AuthenticodeSignature -HashAlgorithm SHA256 -Certificate $certificate -TimestampServer http://timestamp.digicert.com
+        echo "ImHex checks for the existence of this file to determine if it is running in portable mode. You should not delete this file" > $PWD/install/PORTABLE
 
     - name: ⬆️ Upload Windows Installer
       uses: actions/upload-artifact@v3
       with:
-        name: Windows Installer
+        name: Windows Installer x86_64
         path: |
-          build/*.msi
+          imhex-*.msi
 
     - name: ⬆️ Upload Portable ZIP
       uses: actions/upload-artifact@v3
       with:
-        name: Windows Portable
+        name: Windows Portable x86_64
         path: |
           build/install/*
-      
+
     - name: ⬇️ Download Mesa3D for NoGPU version
       shell: bash
       run: |
@@ -119,7 +111,7 @@ jobs:
     - name: ⬆️ Upload NoGPU Portable ZIP
       uses: actions/upload-artifact@v3
       with:
-        name: Windows Portable NoGPU
+        name: Windows Portable NoGPU x86_64
         path: |
           build/install/*
 
@@ -134,7 +126,7 @@ jobs:
             custom_glfw: true
           - suffix: ""
             custom_glfw: false
-    
+
     name: 🍎 macOS 11.0${{matrix.suffix}}
 
     steps:
@@ -146,7 +138,7 @@ jobs:
     - name: 📜 Set version variable
       run: |
         echo "IMHEX_VERSION=`cat VERSION`" >> $GITHUB_ENV
-        
+
     - name: 📜 Setup ccache
       uses: hendrikmuhs/ccache-action@v1.2
       with:
@@ -154,7 +146,6 @@ jobs:
         restore-keys: ${{ runner.os }}-${{ matrix.suffix }}-${{ secrets.CACHE_VERSION }}-build
         max-size: 50M
 
-        
     - name: 📜 Restore CMakeCache
       uses: actions/cache@v3
       with:
@@ -172,7 +163,6 @@ jobs:
       run: |
         brew install glfw
 
-
     - name: 🧰 Checkout glfw
       if: ${{matrix.custom_glfw}}
       uses: actions/checkout@v3
@@ -219,14 +209,14 @@ jobs:
           -DCMAKE_OBJCXX_COMPILER_LAUNCHER=ccache \
           -DIMHEX_PATTERNS_PULL_MASTER=ON         \
           -DCMAKE_OSX_DEPLOYMENT_TARGET="10.10"   \
-          -DCPACK_PACKAGE_FILE_NAME="imhex-${{env.IMHEX_VERSION}}-macOS${{matrix.suffix}}"  \
+          -DCPACK_PACKAGE_FILE_NAME="imhex-${{env.IMHEX_VERSION}}-macOS${{matrix.suffix}}-x86_64"  \
           ..
         make -j4 package
 
     - name: ⬆️ Upload DMG
       uses: actions/upload-artifact@v3
       with:
-        name: macOS DMG${{matrix.suffix}}
+        name: macOS DMG${{matrix.suffix}} x86_64
         path: build/*.dmg
 
   # Ubuntu build
@@ -246,30 +236,18 @@ jobs:
           key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
           restore-keys: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build
           max-size: 50M
-          
-      - name: 📜 Restore other caches
+
+      - name: 📜 Restore CMakeCache
         uses: actions/cache@v3
         with:
           path: |
             build/CMakeCache.txt
-            build-appimage/CMakeCache.txt
-            .flatpak-builder
           key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ hashFiles('**/CMakeLists.txt') }}
-          
+
       - name: ⬇️ Install dependencies
         run: |
-          sudo rm -rf /usr/share/dotnet
-          sudo rm -rf /opt/ghc
-          sudo rm -rf "/usr/local/share/boost"
-          sudo rm -rf "$AGENT_TOOLSDIRECTORY"
-
           sudo apt update
           sudo bash dist/get_deps_debian.sh
-          
-          sudo apt install -y python3-pip python3-setuptools desktop-file-utils libgdk-pixbuf2.0-dev fuse
-          sudo wget https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage -O /usr/local/bin/appimagetool
-          sudo chmod +x /usr/local/bin/appimagetool
-          sudo pip3 install git+https://github.com/iTrooz/appimage-builder@dpkg-package-versions
 
       # Ubuntu cmake build
       - name: 🛠️ Build
@@ -290,23 +268,59 @@ jobs:
         run: |
           echo "IMHEX_VERSION=`cat VERSION`" >> $GITHUB_ENV
 
-      #- name: 📦 Bundle Flatpak
-      #  run: |
-      #    sudo apt install flatpak flatpak-builder
-      #    flatpak --user remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
-      #    flatpak --user install -y flathub org.freedesktop.Platform//20.08
-      #    flatpak --user install -y flathub org.freedesktop.Sdk//20.08
-      #    flatpak-builder --jobs=4 --repo=imhex _flatpak dist/net.werwolv.ImHex.yaml --ccache --keep-build-dirs
-      #    flatpak build-bundle imhex imhex.flatpak net.werwolv.ImHex stable
-
       - name: 📦 Bundle DEB
         run: |
           cp -r build/DEBIAN build/DebDir
           dpkg-deb -Zgzip --build build/DebDir
-          mv build/DebDir.deb imhex-${{env.IMHEX_VERSION}}-Ubuntu-22.04.deb
+          mv build/DebDir.deb imhex-${{env.IMHEX_VERSION}}-Ubuntu-22.04-x86_64.deb
+
+      - name: ⬆️ Upload DEB
+        uses: actions/upload-artifact@v3
+        with:
+          name: Ubuntu 22.04 DEB x86_64
+          path: '*.deb'
+
+  # AppImage build
+  appimage:
+    runs-on: ubuntu-22.04
+    name: ⬇️ AppImage
+    steps:
+
+      - name: 🧰 Checkout
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      - name: 📜 Setup ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ runner.os }}-appimage-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
+          restore-keys: ${{ runner.os }}-appimage-${{ secrets.CACHE_VERSION }}-build
+          max-size: 50M
+
+      - name: 📜 Restore CMakeCache
+        uses: actions/cache@v3
+        with:
+          path: |
+            build-appimage/CMakeCache.txt
+          key: ${{ runner.os }}-appimage-${{ secrets.CACHE_VERSION }}-build-${{ hashFiles('**/CMakeLists.txt') }}
+
+      - name: ⬇️ Install dependencies
+        run: |
+          sudo apt update
+          sudo bash dist/get_deps_debian.sh
+
+          sudo apt install -y python3-pip python3-setuptools desktop-file-utils libgdk-pixbuf2.0-dev fuse
+          sudo wget https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage -O /usr/local/bin/appimagetool
+          sudo chmod +x /usr/local/bin/appimagetool
+          sudo pip3 install git+https://github.com/iTrooz/appimage-builder@dpkg-package-versions
+
+      - name: 📜 Set version variable
+        run: |
+          echo "IMHEX_VERSION=`cat VERSION`" >> $GITHUB_ENV
 
       # AppImage cmake build
-      - name: 🛠️ Reconfigure build for AppImage
+      - name: 🛠️ Build
         run: |
           mkdir -p build-appimage
           cd build-appimage
@@ -328,36 +342,23 @@ jobs:
           export VERSION=${{env.IMHEX_VERSION}}
           appimage-builder --recipe ../dist/AppImageBuilder.yml
 
-      #- name: ⬆️ Upload Flatpak
-      #  uses: actions/upload-artifact@v3
-      #  with:
-      #    name: Linux Flatpak
-      #    path: |
-      #      imhex.flatpak
-
-      - name: ⬆️ Upload DEB
-        uses: actions/upload-artifact@v3
-        with:
-          name: Ubuntu 22.04 DEB
-          path: '*.deb'
-
       - name: ⬆️ Upload AppImage
         uses: actions/upload-artifact@v3
         with:
-          name: Linux AppImage
+          name: Linux AppImage x86_64
           path: 'build-appimage/*.AppImage'
-        
+
       - name: ⬆️ Upload AppImage zsync
         uses: actions/upload-artifact@v3
         with:
-          name: Linux AppImage zsync
+          name: Linux AppImage zsync x86_64
           path: 'build-appimage/*.AppImage.zsync'
 
   # ArchLinux build
   archlinux-build:
     name: 🐧 ArchLinux
     runs-on: ubuntu-latest
-    
+
     container:
       image: archlinux:base-devel
 
@@ -369,7 +370,7 @@ jobs:
       - name: ⬇️ Install setup dependencies
         run: |
           pacman -Syu git ccache --noconfirm
-          
+
       - name: 🧰 Checkout
         uses: actions/checkout@v3
         with:
@@ -385,14 +386,14 @@ jobs:
           key: archlinux-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
           restore-keys: archlinux-${{ secrets.CACHE_VERSION }}-build
           max-size: 50M
-        
+
       - name: 📜 Restore CMakeCache
         uses: actions/cache@v3
         with:
           path: |
             build/CMakeCache.txt
           key: archlinux-${{ secrets.CACHE_VERSION }}-build-${{ hashFiles('**/CMakeLists.txt') }}
-      
+
       # ArchLinux cmake build
       - name: 🛠️ Build
         run: |
@@ -416,7 +417,7 @@ jobs:
       - name: 📜 Set version variable
         run: |
           echo "IMHEX_VERSION=`cat VERSION`" >> $GITHUB_ENV
-      
+
       - name: ✒️ Prepare PKGBUILD
         run: |
           cp dist/Arch/PKGBUILD build
@@ -426,91 +427,142 @@ jobs:
       - name: 📦 Package ArchLinux .pkg.tar.zst
         run: |
           cd build
-          
+
           # the name is a small trick to make makepkg recognize it as the source
           # else, it would try to download the file from the release
-          tar -cvf imhex-${{env.IMHEX_VERSION}}-ArchLinux.pkg.tar.zst -C installDir .
-          
+          tar -cvf imhex-${{env.IMHEX_VERSION}}-ArchLinux-x86_64.pkg.tar.zst -C installDir .
+
           chmod -R 777 .
-          
+
           sudo -u nobody makepkg
 
           # Replace the old file
-          rm imhex-${{env.IMHEX_VERSION}}-ArchLinux.pkg.tar.zst
-          mv *.pkg.tar.zst imhex-${{env.IMHEX_VERSION}}-ArchLinux.pkg.tar.zst
-      
+          rm imhex-${{env.IMHEX_VERSION}}-ArchLinux-x86_64.pkg.tar.zst
+          mv *.pkg.tar.zst imhex-${{env.IMHEX_VERSION}}-ArchLinux-x86_64.pkg.tar.zst
+
       - name: ⬆️ Upload imhex-archlinux.pkg.tar.zst
         uses: actions/upload-artifact@v3
         with:
-          name: ArchLinux .pkg.tar.zst
+          name: ArchLinux .pkg.tar.zst x86_64
           path: |
-            build/imhex-${{env.IMHEX_VERSION}}-ArchLinux.pkg.tar.zst
+            build/imhex-${{env.IMHEX_VERSION}}-ArchLinux-x86_64.pkg.tar.zst
 
-  # Fedora build     
-  fedora-build:
+  # RPM distro builds
+  rpm-build:
     strategy:
       matrix:
         include:
-          - docker_image: fedora:latest
-            release: Latest
-          - docker_image: fedora:rawhide
-            release: Rawhide
+          - name: Fedora
+            mock_release: rawhide
+            release_num: rawhide
+            mock_config: fedora-rawhide
+          - name: Fedora
+            mock_release: f37
+            release_num: 37
+            mock_config: fedora-37
+          - name: Fedora
+            mock_release: f36
+            release_num: 36
+            mock_config: fedora-36
+          - name: RHEL-AlmaLinux
+            mock_release: epel9
+            release_num: 9
+            mock_config: "alma+epel-9"
 
-
-    name: 🐧 Fedora ${{ matrix.release }}
+    name: 🐧 ${{ matrix.name }} ${{ matrix.release_num }}
     runs-on: ubuntu-latest
-    
+
     container:
-      image: "${{ matrix.docker_image }}"
+      image: "fedora:latest"
+      options: --privileged
 
     steps:
-      - name: ⬇️ Update all packages
-        run: |
-          dnf upgrade -y
+      - name: ⬇️ Install git-core
+        run: dnf install --disablerepo="*" --enablerepo="fedora" git-core -y
 
-      - name: ⬇️ Install setup dependencies
-        run: |
-          dnf install -y     \
-          ccache             \
-          desktop-file-utils \
-          fmt-devel          \
-          git                \
-          json-devel         \
-          libcurl-devel      \
-          llvm-devel         \
-          mbedtls-devel      \
-          rpm-build          \
-          yara-devel
-          
       - name: 🧰 Checkout
         uses: actions/checkout@v3
         with:
+          path: ImHex
           submodules: recursive
 
-      - name: ⬇️ Install ImHex dependencies
+      - name: 📜 Setup DNF Cache
+        uses: actions/cache@v3
+        with:
+          path: /var/cache/dnf
+          key: ${{ matrix.mock_release }}-${{secrets.CACHE_VERSION }}-dnf-${{ github.run_id }}
+          restore-keys: |
+            ${{ matrix.mock_release }}-${{secrets.CACHE_VERSION }}-dnf-
+
+      - name: ⬇️ Update all packages and install dependencies
         run: |
-          dist/get_deps_fedora.sh
+          dnf upgrade --disablerepo="*" --enablerepo="fedora,updates" -y
+          dnf install --disablerepo="*" --enablerepo="fedora,updates" -y \
+          fedpkg         \
+          ccache
 
       - name: 📜 Setup ccache
-        uses: hendrikmuhs/ccache-action@v1.2
+        uses: hendrikmuhs/ccache-action@v1.2.5
         with:
-          key: fedora-${{ matrix.release }}-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
-          restore-keys: fedora-${{ matrix.release }}-${{ secrets.CACHE_VERSION }}-build
-          max-size: 50M
-   
+          key: rpm-${{ matrix.mock_release }}-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
+          restore-keys: rpm-${{ matrix.mock_release }}-${{ secrets.CACHE_VERSION }}-build
+          max-size: 1G
+
       - name: 📜 Set version variable
         run: |
-          echo "IMHEX_VERSION=`cat VERSION`" >> $GITHUB_ENV
-      
+          echo "IMHEX_VERSION=`cat ImHex/VERSION`" >> $GITHUB_ENV
+
+      - name: 🗜️ Create tarball from sources with dependencies
+        run: tar --exclude-vcs -czf $GITHUB_WORKSPACE/imhex-$IMHEX_VERSION.tar.gz ImHex
+
+      - name: "✒️ Modify spec file: set version, use latest pattern language, enable online build"
+        run: |
+          sed -i \
+          -e 's/Version:        [0-9]*\.[0-9]*\.[0-9]*$/Version:        ${{env.IMHEX_VERSION}}/g' \
+          -e 's/IMHEX_OFFLINE_BUILD=ON/IMHEX_OFFLINE_BUILD=OFF/g'                                 \
+          -e '/IMHEX_OFFLINE_BUILD=OFF/a -D IMHEX_PATTERNS_PULL_MASTER=ON \\'                     \
+          -e '/BuildRequires:  cmake/a BuildRequires:  git-core'                                  \
+          -e '/%files/a %{_datadir}/%{name}/'                                                     \
+          $GITHUB_WORKSPACE/ImHex/dist/rpm/imhex.spec
+
+      - name: 📜 Fix ccache on EL9
+        if: matrix.mock_release == 'epel9'
+        run: sed -i '/\. \/opt\/rh\/gcc-toolset-12\/enable/a PATH=/usr/lib64/ccache:$PATH' $GITHUB_WORKSPACE/ImHex/dist/rpm/imhex.spec
+
+      - name: 🟩 Copy spec file to build root
+        run: mv $GITHUB_WORKSPACE/ImHex/dist/rpm/imhex.spec $GITHUB_WORKSPACE/imhex.spec
+
+      - name: 📜 Enable ccache for mock
+        run: |
+          cat <<EOT > $GITHUB_WORKSPACE/mock.cfg
+          include('${{ matrix.mock_config }}-x86_64.cfg')
+          config_opts['plugin_conf']['ccache_enable'] = True
+          config_opts['plugin_conf']['ccache_opts']['max_cache_size'] = '1G'
+          config_opts['plugin_conf']['ccache_opts']['compress'] = True
+          config_opts['plugin_conf']['ccache_opts']['dir'] = "$GITHUB_WORKSPACE/.ccache"
+          EOT
+
+      - name: 📜 Setup Mock Cache
+        uses: actions/cache@v3
+        with:
+          path: /var/cache/mock
+          key: ${{ matrix.mock_release }}-${{secrets.CACHE_VERSION }}-mock-${{ github.run_id }}
+          restore-keys: |
+            ${{ matrix.mock_release }}-${{secrets.CACHE_VERSION }}-mock-
+
       # Fedora cmake build (in imhex.spec)
       - name: 📦 Build RPM
         run: |
-          rpmbuild -ba --define "_version ${{env.IMHEX_VERSION}}" --define "_src_path $GITHUB_WORKSPACE" --define "_build_type $BUILD_TYPE" $GITHUB_WORKSPACE/dist/rpm/imhex.spec
-          mv ~/rpmbuild/RPMS/x86_64/*.rpm imhex-${{env.IMHEX_VERSION}}-Fedora-${{matrix.release}}.rpm
-          
+          fedpkg --path $GITHUB_WORKSPACE --release ${{ matrix.mock_release }} mockbuild --enable-network -N --root $GITHUB_WORKSPACE/mock.cfg extra_args -- -v
+
+      - name: 🟩 Move and rename finished RPM
+        run: |
+          mv $GITHUB_WORKSPACE/results_imhex/${{env.IMHEX_VERSION}}/*/imhex-${{env.IMHEX_VERSION}}-0.*.x86_64.rpm \
+          $GITHUB_WORKSPACE/imhex-${{env.IMHEX_VERSION}}-${{matrix.name}}-${{matrix.release_num}}-x86_64.rpm
+
       - name: ⬆️ Upload RPM
         uses: actions/upload-artifact@v3
         with:
-          name: Fedora ${{ matrix.release }} RPM
+          name: ${{ matrix.name }} ${{ matrix.release_num }} RPM x86_64
           path: |
-            imhex-${{env.IMHEX_VERSION}}-Fedora-${{matrix.release}}.rpm
+            imhex-${{env.IMHEX_VERSION}}-${{matrix.name}}-${{matrix.release_num}}-x86_64.rpm

.github/workflows/release.yml

@@ -34,7 +34,7 @@ jobs:
 
       - name: 🗜️ Create tarball from sources with dependencies
         run: tar --exclude-vcs -czvf Full.Sources.tar.gz ImHex
-        
+
       - name: ⬇️ Download artifacts from latest workflow
         uses: dawidd6/action-download-artifact@v2
         with:
@@ -43,7 +43,7 @@ jobs:
           branch: ${{ github.event.release.target_commitish }}
           workflow_conclusion: success
           skip_unpack: true
-             
+
       - name: 🗜️ Unzip files when needed
         run: |	
           for zipfile in ./*.zip
@@ -60,8 +60,8 @@ jobs:
 
       - name: 🟩 Rename artifacts when needed
         run: |
-          mv "Windows Portable.zip" imhex-${{env.IMHEX_VERSION}}-Windows-Portable.zip
-          mv "Windows Portable NoGPU.zip" imhex-${{env.IMHEX_VERSION}}-Windows-Portable-NoGPU.zip
+          mv "Windows Portable x86_64.zip" imhex-${{env.IMHEX_VERSION}}-Windows-Portable-x86_64.zip
+          mv "Windows Portable NoGPU x86_64.zip" imhex-${{env.IMHEX_VERSION}}-Windows-Portable-NoGPU-x86_64.zip
 
       - name: ⬆️ Upload everything to release
         uses: softprops/action-gh-release@v1
@@ -72,13 +72,13 @@ jobs:
         run: |
           cp ImHex/dist/Arch/PKGBUILD .
           
-          hash=`md5sum imhex-${{env.IMHEX_VERSION}}-ArchLinux.pkg.tar.zst | cut -d ' ' -f 1`
+          hash=`md5sum imhex-${{env.IMHEX_VERSION}}-ArchLinux-x86_64.pkg.tar.zst | cut -d ' ' -f 1`
 
           sed -i 's/%version%/${{env.IMHEX_VERSION}}/g' PKGBUILD
           sed -i "s/(SKIP)/($hash)/g" PKGBUILD
 
       - name: ⬆️ Publish AUR package
-        
+
         # I couldn't make the condition in the env directly for some reason
         env:
           AUR_SSH_PRIVATE_KEY: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
@@ -113,28 +113,26 @@ jobs:
           tag: ImHex-v${{env.IMHEX_VERSION}}
           repo: ImHex-Patterns
           token: ${{ secrets.RELEASE_TOKEN }}
-          
+
       - name: ✉️ Update C++ Plugin Template
-        uses: mvasigh/dispatch-action@main
+        uses: peter-evans/repository-dispatch@v2
         env:
           RELEASE_TOKEN: ${{ secrets.RELEASE_TOKEN }}
         if: "${{ env.RELEASE_TOKEN != '' }}"
         with:
           token: ${{ secrets.RELEASE_TOKEN }}
-          repo: ImHex-Cpp-Plugin-Template
-          owner: WerWolv
-          event_type: update_submodule
+          repository: WerWolv/ImHex-Cpp-Plugin-Template
+          event-type: update_submodule
 
       - name: ✉️ Update Rust Plugin Template
-        uses: mvasigh/dispatch-action@main
+        uses: peter-evans/repository-dispatch@v2
         env:
           RELEASE_TOKEN: ${{ secrets.RELEASE_TOKEN }}
         if: "${{ env.RELEASE_TOKEN != '' }}"
         with:
           token: ${{ secrets.RELEASE_TOKEN }}
-          repo: ImHex-Rust-Plugin-Template
-          owner: WerWolv
-          event_type: update_submodule
+          repository: WerWolv/ImHex-Rust-Plugin-Template
+          event-type: update_submodule
 
   release-windows:
     name: Release Windows
@@ -153,7 +151,7 @@ jobs:
         run: |
           $tagname = $env:GITHUB_REF.Replace("refs/tags/", "")
           $version = $tagname.Replace("v", "")
-          $url = "https://github.com/WerWolv/ImHex/releases/download/${tagname}/imhex-${version}-win64.msi"
+          $url = "https://github.com/WerWolv/ImHex/releases/download/${tagname}/imhex-${version}-Windows-x86_64.msi"
           .\wingetcreate.exe update WerWolv.ImHex -u $url --version $version
           if ($version -notmatch "-") {
             .\wingetcreate.exe submit .\manifests\w\WerWolv\ImHex\${version}\ --token $env:WINGET_GITHUB_TOKEN

.github/workflows/tests.yml

@@ -25,18 +25,18 @@ jobs:
     - name: 📜 Setup ccache
       uses: hendrikmuhs/ccache-action@v1.2
       with:
-        key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
-        restore-keys: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build
+        key: ${{ runner.os }}-tests-${{ secrets.CACHE_VERSION }}-build-${{ github.run_id }}
+        restore-keys: ${{ runner.os }}-tests-${{ secrets.CACHE_VERSION }}-build
         max-size: 50M
-        
+
 
     - name: 📜 Restore CMakeCache
       uses: actions/cache@v3
       with:
         path: |
           build/CMakeCache.txt
-        key: ${{ runner.os }}-${{ secrets.CACHE_VERSION }}-build-${{ hashFiles('**/CMakeLists.txt') }}
-        
+        key: ${{ runner.os }}-tests-${{ secrets.CACHE_VERSION }}-build-${{ hashFiles('**/CMakeLists.txt') }}
+
     - name: ⬇️ Install dependencies
       run: |
         sudo apt update
@@ -48,14 +48,13 @@ jobs:
         cd build
         CC=gcc-12 CXX=g++-12 cmake                                                                      \
           -DCMAKE_BUILD_TYPE=Debug                                                                      \
-          -DCMAKE_INSTALL_PREFIX="$PWD/install"                                                         \
           -DCMAKE_C_COMPILER_LAUNCHER=ccache                                                            \
           -DCMAKE_CXX_COMPILER_LAUNCHER=ccache                                                          \
           -DCMAKE_C_FLAGS="-fuse-ld=lld -fsanitize=address,leak,undefined -fno-sanitize-recover=all"    \
           -DCMAKE_CXX_FLAGS="-fuse-ld=lld -fsanitize=address,leak,undefined -fno-sanitize-recover=all"  \
           -DIMHEX_OFFLINE_BUILD=ON                                                                      \
           ..
-        make -j4 unit_tests install
+        make -j4 unit_tests
 
     - name: 🧪 Perform Unit Tests
       run: |

CMakeLists.txt

@@ -8,6 +8,7 @@ option(IMHEX_OFFLINE_BUILD "Enable offline build" OFF)
 option(IMHEX_IGNORE_BAD_CLONE "Disable the bad clone prevention checks" OFF)
 option(IMHEX_PATTERNS_PULL_MASTER "Download latest files from master branch of the ImHex-Patterns repo" OFF)
 option(IMHEX_IGNORE_BAD_COMPILER "Allow compiling with an unsupported compiler" OFF)
+option(IMHEX_USE_GTK_FILE_PICKER "Use GTK file picker instead of xdg-desktop-portals" OFF)
 
 # Basic compiler and cmake configurations
 set(CMAKE_CXX_STANDARD 23)
@@ -19,7 +20,11 @@ include("${IMHEX_BASE_FOLDER}/cmake/build_helpers.cmake")
 # Setup project
 loadVersion(IMHEX_VERSION)
 setVariableInParent(IMHEX_VERSION ${IMHEX_VERSION})
-project(imhex VERSION ${IMHEX_VERSION})
+project(imhex
+        LANGUAGES C CXX VERSION ${IMHEX_VERSION}
+        DESCRIPTION "The ImHex Hex Editor"
+        HOMEPAGE_URL "https://imhex.werwolv.net"
+)
 
 # Make sure project is configured correctly
 setDefaultBuiltTypeIfUnset()
@@ -43,7 +48,7 @@ addBundledLibraries()
 # Add ImHex sources
 add_subdirectory(lib/libimhex)
 add_subdirectory(main)
-add_custom_target(imhex_all ALL DEPENDS main)
+add_custom_target(imhex_all ALL DEPENDS main libimhex)
 
 # Add unit tests
 enable_testing()

INSTALL.md

@@ -6,6 +6,55 @@ The easiest way to install ImHex is to download the latest release from the [Git
 
 There's also a NoGPU version available for users who don't have a GPU or want to run ImHex in a VM without GPU passthrough.
 
+### Windows
+
+#### Installer
+Simply run the installer to install ImHex on your system
+
+#### Portable
+Extract the zip file to any location on your system.
+
+### macOS
+Simply use the drag-n-drop dmg package to install ImHex on your system. It's possible that you need to allow the app to run in the security settings.
+
+### Linux
+
+#### AppImage
+To run the AppImage, make sure it's executable. Then simply run it.
+
+```bash
+chmod +x imhex-*.AppImage
+./imhex-*.AppImage
+```
+
+#### Flatpak
+To install the Flatpak, make sure you have the Flathub repository added to your system. Then simply run the following command:
+
+```bash
+flatpak install flathub net.werwolv.ImHex
+```
+
+#### Ubuntu DEB Package
+To install the DEB package, simply run the following command:
+
+```bash
+sudo apt install ./imhex-*.deb
+```
+
+#### Arch Linux
+To install the Arch Linux package, simply run the following command:
+
+```bash
+sudo pacman -U imhex-*.pkg.tar.zst
+```
+
+#### Fedora / RHEL / AlmaLinux RPM Package
+To install the RPM package, simply run the following command:
+
+```bash
+sudo dnf install ./imhex-*.rpm
+```
+
 ## Nightly Builds
 
 The GitHub Actions CI builds a new release package on every commit made to repository. These builds are available on the [GitHub Actions page](https://github.com/WerWolv/ImHex/actions?query=workflow%3A%22Build%22).
@@ -24,10 +73,10 @@ ImHex is also available on various package managers. The officially supported on
 
 ### Windows
 
-- **Cocolatey**
+- **Chocolatey**
   - [imhex](https://community.chocolatey.org/packages/imhex) (Thanks to @Jarcho)
     - `choco install imhex`
-- **winget**
+- **Winget**
   - [WerWolv.ImHex](https://github.com/microsoft/winget-pkgs/tree/master/manifests/w/WerWolv/ImHex)
     - `winget install WerWolv.ImHex`
 

README.md

@@ -1,16 +1,30 @@
 <a href="https://imhex.werwolv.net">
   <h1 align="center">
-    <img height="100px" src="./resources/projects/logo_text_light.svg#gh-dark-mode-only">
-    <img height="100px" src="./resources/projects/logo_text_dark.svg#gh-light-mode-only">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="./resources/projects/logo_text_light.svg">
+      <img height="100px" src="./resources/projects/logo_text_dark.svg">
+    </picture>
   </h1>
 </a>
 
 <p align="center">A Hex Editor for Reverse Engineers, Programmers and people who value their retinas when working at 3 AM.</p>
 
 <p align="center">
-  <a title="'Build' workflow Status" href="https://github.com/WerWolv/ImHex/actions?query=workflow%3ABuild"><img alt="'Build' workflow Status" src="https://img.shields.io/github/actions/workflow/status/WerWolv/ImHex/build.yml?longCache=true&style=for-the-badge&label=Build&logoColor=fff&logo=GitHub%20Actions&branch=master"></a>
-  <a title="Discord Server" href="https://discord.gg/X63jZ36xBY"><img alt="Discord Server" src="https://img.shields.io/discord/789833418631675954?label=Discord&logo=Discord&style=for-the-badge"></a>
-  <a title="Total Downloads" href="https://github.com/WerWolv/ImHex/releases/latest"><img alt="Total Downloads" src="https://img.shields.io/github/downloads/WerWolv/ImHex/total?longCache=true&style=for-the-badge&label=Downloads&logoColor=fff&logo=GitHub"></a>
+  <a title="'Build' workflow Status" href="https://github.com/WerWolv/ImHex/actions?query=workflow%3ABuild">
+    <img alt="'Build' workflow Status" src="https://img.shields.io/github/actions/workflow/status/WerWolv/ImHex/build.yml?longCache=true&style=for-the-badge&label=Build&logoColor=fff&logo=GitHub%20Actions&branch=master">
+  </a>
+  <a title="Discord Server" href="https://discord.gg/X63jZ36xBY">
+    <img alt="Discord Server" src="https://img.shields.io/discord/789833418631675954?label=Discord&logo=Discord&logoColor=fff&style=for-the-badge">
+  </a>
+  <a title="Total Downloads" href="https://github.com/WerWolv/ImHex/releases/latest">
+    <img alt="Total Downloads" src="https://img.shields.io/github/downloads/WerWolv/ImHex/total?longCache=true&style=for-the-badge&label=Downloads&logoColor=fff&logo=GitHub">
+  </a>
+  <a title="Code Quality" href="https://www.codefactor.io/repository/github/werwolv/imhex">
+    <img alt="Code Quality" src="https://img.shields.io/codefactor/grade/github/WerWolv/ImHex?longCache=true&style=for-the-badge&label=Code%20Quality&logoColor=fff&logo=CodeFactor&branch=master">
+  </a>
+  <a title="Translation" href="https://weblate.werwolv.net/projects/imhex/">
+    <img alt="Translation" src="https://img.shields.io/weblate/progress/imhex?logo=weblate&logoColor=%23FFFFFF&server=https%3A%2F%2Fweblate.werwolv.net&style=for-the-badge">
+  </a>
 </p>
 
 ## Supporting
@@ -125,10 +139,12 @@ For format patterns, libraries, magic and constant files, check out the [ImHex-P
 
 To use ImHex, the following minimal system requirements need to be met:
 
-- **OS**: Windows 7 or higher, macOS 10.15 (Catalina) or higher, "Modern" Linux (Ubuntu 22.04, Fedora Stable/Rawhide, and Arch Linux have official packages, other distributions can use the AppImage)
+- **OS**: Windows 7 or higher, macOS 10.15 (Catalina) or higher, "Modern" Linux (Ubuntu 22.04, Fedora 36/37, RHEL/AlmaLinux 9, and Arch Linux have official packages, other and older distributions can use the AppImage)
 - **CPU**: x86_64 (64 Bit)
-- **GPU**: OpenGL 3.0 or higher (preferable a dedicated GPU and not Intel HD Graphics)
-- **RAM**: 512MB, more may be required for more complicated analysis
+- **GPU**: OpenGL 3.0 or higher 
+  - Intel HD drivers are really buggy and often cause graphic artifacts
+  - In case you don't have a GPU available, there are software rendered releases available for Windows and macOS
+- **RAM**: 256MB, more may be required for more complicated analysis
 - **Storage**: 100MB
 
 ## Installing

VERSION

@@ -1 +1 @@
-1.26.0
+1.27.1

cmake/build_helpers.cmake

@@ -41,7 +41,7 @@ macro(addVersionDefines)
         set(IMHEX_VERSION_STRING ${IMHEX_VERSION_STRING})
     elseif (CMAKE_BUILD_TYPE STREQUAL "Debug")
         set(IMHEX_VERSION_STRING ${IMHEX_VERSION_STRING}-Debug)
-        add_compile_definitions(DEBUG _GLIBCXX_DEBUG)
+        add_compile_definitions(DEBUG _GLIBCXX_DEBUG _GLIBCXX_VERBOSE)
     elseif (CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
         set(IMHEX_VERSION_STRING ${IMHEX_VERSION_STRING}-RelWithDebInfo)
     elseif (CMAKE_BUILD_TYPE STREQUAL "MinSizeRel")
@@ -433,8 +433,13 @@ macro(addBundledLibraries)
         set(FMT_LIBRARIES fmt::fmt)
     endif()
 
+    if (IMHEX_USE_GTK_FILE_PICKER)
+        set(NFD_PORTAL OFF CACHE BOOL "Use Portals for Linux file dialogs" FORCE)
+    else ()
+        set(NFD_PORTAL ON CACHE BOOL "Use GTK for Linux file dialogs" FORCE)
+    endif ()
+
     if (NOT USE_SYSTEM_NFD)
-        set(NFD_PORTAL ON CACHE BOOL "Use Portals for Linux file dialogs" FORCE)
         add_subdirectory(${EXTERN_LIBS_FOLDER}/nativefiledialog EXCLUDE_FROM_ALL)
         set_target_properties(nfd PROPERTIES POSITION_INDEPENDENT_CODE ON)
         set(NFD_LIBRARIES nfd)
@@ -476,6 +481,15 @@ macro(addBundledLibraries)
         pkg_check_modules(YARA REQUIRED IMPORTED_TARGET yara)
     endif()
 
+    if (NOT USE_SYSTEM_MINIAUDIO)
+        add_subdirectory(${EXTERN_LIBS_FOLDER}/miniaudio EXCLUDE_FROM_ALL)
+        set_target_properties(miniaudio PROPERTIES POSITION_INDEPENDENT_CODE ON)
+        set(MINIAUDIO_LIBRARIES miniaudio)
+    else()
+        find_package(PkgConfig REQUIRED)
+        pkg_check_modules(miniaudio REQUIRED IMPORTED_TARGET miniaudio)
+    endif()
+
     if (NOT USE_SYSTEM_CAPSTONE)
         set(CAPSTONE_BUILD_STATIC_RUNTIME OFF CACHE BOOL "Disable shared library building")
         set(CAPSTONE_BUILD_SHARED OFF CACHE BOOL "Disable shared library building")
@@ -500,4 +514,26 @@ macro(addBundledLibraries)
     else()
         set(MAGIC_INCLUDE_DIRS ${MAGIC_INCLUDEDIR})
     endif()
+
+    if (WIN32)
+        message(STATUS "StackWalk enabled!")
+        set(LIBBACKTRACE_LIBRARIES DbgHelp.lib)
+    else ()
+        find_package(Backtrace)
+        if (${Backtrace_FOUND})
+            message(STATUS "Backtrace enabled! Header: ${Backtrace_HEADER}")
+
+            if (Backtrace_HEADER STREQUAL "execinfo.h")
+                set(LIBBACKTRACE_LIBRARIES)
+                set(LIBBACKTRACE_INCLUDE_DIRS ${Backtrace_INCLUDE_DIR})
+                add_compile_definitions(BACKTRACE_HEADER=\"${Backtrace_HEADER}\")
+                add_compile_definitions(HEX_HAS_EXECINFO)
+            elseif (Backtrace_HEADER STREQUAL "backtrace.h")
+                set(LIBBACKTRACE_LIBRARIES backtrace)
+                set(LIBBACKTRACE_INCLUDE_DIRS ${Backtrace_INCLUDE_DIR})
+                add_compile_definitions(BACKTRACE_HEADER=\"${Backtrace_HEADER}\")
+                add_compile_definitions(HEX_HAS_BACKTRACE)
+            endif ()
+        endif()
+    endif ()
 endmacro()

cmake/modules/FindBacktrace.cmake

@@ -0,0 +1,91 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+FindBacktrace
+-------------
+
+Find provider for `backtrace(3) <https://man7.org/linux/man-pages/man3/backtrace.3.html>`__.
+
+Checks if OS supports ``backtrace(3)`` via either ``libc`` or custom library.
+This module defines the following variables:
+
+``Backtrace_HEADER``
+  The header file needed for ``backtrace(3)``. Cached.
+  Could be forcibly set by user.
+``Backtrace_INCLUDE_DIRS``
+  The include directories needed to use ``backtrace(3)`` header.
+``Backtrace_LIBRARIES``
+  The libraries (linker flags) needed to use ``backtrace(3)``, if any.
+``Backtrace_FOUND``
+  Is set if and only if ``backtrace(3)`` support detected.
+
+The following cache variables are also available to set or use:
+
+``Backtrace_LIBRARY``
+  The external library providing backtrace, if any.
+``Backtrace_INCLUDE_DIR``
+  The directory holding the ``backtrace(3)`` header.
+
+Typical usage is to generate of header file using :command:`configure_file`
+with the contents like the following::
+
+ #cmakedefine01 Backtrace_FOUND
+ #if Backtrace_FOUND
+ # include <${Backtrace_HEADER}>
+ #endif
+
+And then reference that generated header file in actual source.
+#]=======================================================================]
+
+include(CMakePushCheckState)
+include(CheckSymbolExists)
+include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
+
+# List of variables to be provided to find_package_handle_standard_args()
+set(_Backtrace_STD_ARGS Backtrace_INCLUDE_DIR)
+
+if(Backtrace_HEADER)
+  set(_Backtrace_HEADER_TRY "${Backtrace_HEADER}")
+else(Backtrace_HEADER)
+  set(_Backtrace_HEADER_TRY "execinfo.h")
+endif(Backtrace_HEADER)
+
+find_path(Backtrace_INCLUDE_DIR "${_Backtrace_HEADER_TRY}")
+set(Backtrace_INCLUDE_DIRS ${Backtrace_INCLUDE_DIR})
+
+if (NOT DEFINED Backtrace_LIBRARY)
+  # First, check if we already have backtrace(), e.g., in libc
+  cmake_push_check_state(RESET)
+  set(CMAKE_REQUIRED_INCLUDES ${Backtrace_INCLUDE_DIRS})
+  set(CMAKE_REQUIRED_QUIET ${Backtrace_FIND_QUIETLY})
+  check_symbol_exists("backtrace" "${_Backtrace_HEADER_TRY}" _Backtrace_SYM_FOUND)
+  cmake_pop_check_state()
+endif()
+
+if(_Backtrace_SYM_FOUND)
+  # Avoid repeating the message() call below each time CMake is run.
+  if(NOT Backtrace_FIND_QUIETLY AND NOT DEFINED Backtrace_LIBRARY)
+    message(STATUS "backtrace facility detected in default set of libraries")
+  endif()
+  set(Backtrace_LIBRARY "" CACHE FILEPATH "Library providing backtrace(3), empty for default set of libraries")
+else()
+  # Check for external library, for non-glibc systems
+  if(Backtrace_INCLUDE_DIR)
+    # OpenBSD has libbacktrace renamed to libexecinfo
+    find_library(Backtrace_LIBRARY "execinfo")
+  else()     # respect user wishes
+    set(_Backtrace_HEADER_TRY "backtrace.h")
+    find_path(Backtrace_INCLUDE_DIR ${_Backtrace_HEADER_TRY})
+    find_library(Backtrace_LIBRARY "backtrace")
+  endif()
+
+  # Prepend list with library path as it's more common practice
+  set(_Backtrace_STD_ARGS Backtrace_LIBRARY ${_Backtrace_STD_ARGS})
+endif()
+
+set(Backtrace_LIBRARIES ${Backtrace_LIBRARY})
+set(Backtrace_HEADER "${_Backtrace_HEADER_TRY}" CACHE STRING "Header providing backtrace(3) facility")
+
+find_package_handle_standard_args(Backtrace FOUND_VAR Backtrace_FOUND REQUIRED_VARS ${_Backtrace_STD_ARGS})
+mark_as_advanced(Backtrace_HEADER Backtrace_INCLUDE_DIR Backtrace_LIBRARY)

cmake/modules/FindPackageHandleStandardArgs.cmake

@@ -0,0 +1,611 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+FindPackageHandleStandardArgs
+-----------------------------
+
+This module provides functions intended to be used in :ref:`Find Modules`
+implementing :command:`find_package(<PackageName>)` calls.
+
+.. command:: find_package_handle_standard_args
+
+  This command handles the ``REQUIRED``, ``QUIET`` and version-related
+  arguments of :command:`find_package`.  It also sets the
+  ``<PackageName>_FOUND`` variable.  The package is considered found if all
+  variables listed contain valid results, e.g. valid filepaths.
+
+  There are two signatures:
+
+  .. code-block:: cmake
+
+    find_package_handle_standard_args(<PackageName>
+      (DEFAULT_MSG|<custom-failure-message>)
+      <required-var>...
+      )
+
+    find_package_handle_standard_args(<PackageName>
+      [FOUND_VAR <result-var>]
+      [REQUIRED_VARS <required-var>...]
+      [VERSION_VAR <version-var>]
+      [HANDLE_VERSION_RANGE]
+      [HANDLE_COMPONENTS]
+      [CONFIG_MODE]
+      [NAME_MISMATCHED]
+      [REASON_FAILURE_MESSAGE <reason-failure-message>]
+      [FAIL_MESSAGE <custom-failure-message>]
+      )
+
+  The ``<PackageName>_FOUND`` variable will be set to ``TRUE`` if all
+  the variables ``<required-var>...`` are valid and any optional
+  constraints are satisfied, and ``FALSE`` otherwise.  A success or
+  failure message may be displayed based on the results and on
+  whether the ``REQUIRED`` and/or ``QUIET`` option was given to
+  the :command:`find_package` call.
+
+  The options are:
+
+  ``(DEFAULT_MSG|<custom-failure-message>)``
+    In the simple signature this specifies the failure message.
+    Use ``DEFAULT_MSG`` to ask for a default message to be computed
+    (recommended).  Not valid in the full signature.
+
+  ``FOUND_VAR <result-var>``
+    .. deprecated:: 3.3
+
+    Specifies either ``<PackageName>_FOUND`` or
+    ``<PACKAGENAME>_FOUND`` as the result variable.  This exists only
+    for compatibility with older versions of CMake and is now ignored.
+    Result variables of both names are always set for compatibility.
+
+  ``REQUIRED_VARS <required-var>...``
+    Specify the variables which are required for this package.
+    These may be named in the generated failure message asking the
+    user to set the missing variable values.  Therefore these should
+    typically be cache entries such as ``FOO_LIBRARY`` and not output
+    variables like ``FOO_LIBRARIES``.
+
+    .. versionchanged:: 3.18
+      If ``HANDLE_COMPONENTS`` is specified, this option can be omitted.
+
+  ``VERSION_VAR <version-var>``
+    Specify the name of a variable that holds the version of the package
+    that has been found.  This version will be checked against the
+    (potentially) specified required version given to the
+    :command:`find_package` call, including its ``EXACT`` option.
+    The default messages include information about the required
+    version and the version which has been actually found, both
+    if the version is ok or not.
+
+  ``HANDLE_VERSION_RANGE``
+    .. versionadded:: 3.19
+
+    Enable handling of a version range, if one is specified. Without this
+    option, a developer warning will be displayed if a version range is
+    specified.
+
+  ``HANDLE_COMPONENTS``
+    Enable handling of package components.  In this case, the command
+    will report which components have been found and which are missing,
+    and the ``<PackageName>_FOUND`` variable will be set to ``FALSE``
+    if any of the required components (i.e. not the ones listed after
+    the ``OPTIONAL_COMPONENTS`` option of :command:`find_package`) are
+    missing.
+
+  ``CONFIG_MODE``
+    Specify that the calling find module is a wrapper around a
+    call to ``find_package(<PackageName> NO_MODULE)``.  This implies
+    a ``VERSION_VAR`` value of ``<PackageName>_VERSION``.  The command
+    will automatically check whether the package configuration file
+    was found.
+
+  ``REASON_FAILURE_MESSAGE <reason-failure-message>``
+    .. versionadded:: 3.16
+
+    Specify a custom message of the reason for the failure which will be
+    appended to the default generated message.
+
+  ``FAIL_MESSAGE <custom-failure-message>``
+    Specify a custom failure message instead of using the default
+    generated message.  Not recommended.
+
+  ``NAME_MISMATCHED``
+    .. versionadded:: 3.17
+
+    Indicate that the ``<PackageName>`` does not match
+    ``${CMAKE_FIND_PACKAGE_NAME}``. This is usually a mistake and raises a
+    warning, but it may be intentional for usage of the command for components
+    of a larger package.
+
+Example for the simple signature:
+
+.. code-block:: cmake
+
+  find_package_handle_standard_args(LibXml2 DEFAULT_MSG
+    LIBXML2_LIBRARY LIBXML2_INCLUDE_DIR)
+
+The ``LibXml2`` package is considered to be found if both
+``LIBXML2_LIBRARY`` and ``LIBXML2_INCLUDE_DIR`` are valid.
+Then also ``LibXml2_FOUND`` is set to ``TRUE``.  If it is not found
+and ``REQUIRED`` was used, it fails with a
+:command:`message(FATAL_ERROR)`, independent whether ``QUIET`` was
+used or not.  If it is found, success will be reported, including
+the content of the first ``<required-var>``.  On repeated CMake runs,
+the same message will not be printed again.
+
+.. note::
+
+  If ``<PackageName>`` does not match ``CMAKE_FIND_PACKAGE_NAME`` for the
+  calling module, a warning that there is a mismatch is given. The
+  ``FPHSA_NAME_MISMATCHED`` variable may be set to bypass the warning if using
+  the old signature and the ``NAME_MISMATCHED`` argument using the new
+  signature. To avoid forcing the caller to require newer versions of CMake for
+  usage, the variable's value will be used if defined when the
+  ``NAME_MISMATCHED`` argument is not passed for the new signature (but using
+  both is an error)..
+
+Example for the full signature:
+
+.. code-block:: cmake
+
+  find_package_handle_standard_args(LibArchive
+    REQUIRED_VARS LibArchive_LIBRARY LibArchive_INCLUDE_DIR
+    VERSION_VAR LibArchive_VERSION)
+
+In this case, the ``LibArchive`` package is considered to be found if
+both ``LibArchive_LIBRARY`` and ``LibArchive_INCLUDE_DIR`` are valid.
+Also the version of ``LibArchive`` will be checked by using the version
+contained in ``LibArchive_VERSION``.  Since no ``FAIL_MESSAGE`` is given,
+the default messages will be printed.
+
+Another example for the full signature:
+
+.. code-block:: cmake
+
+  find_package(Automoc4 QUIET NO_MODULE HINTS /opt/automoc4)
+  find_package_handle_standard_args(Automoc4  CONFIG_MODE)
+
+In this case, a ``FindAutmoc4.cmake`` module wraps a call to
+``find_package(Automoc4 NO_MODULE)`` and adds an additional search
+directory for ``automoc4``.  Then the call to
+``find_package_handle_standard_args`` produces a proper success/failure
+message.
+
+.. command:: find_package_check_version
+
+  .. versionadded:: 3.19
+
+  Helper function which can be used to check if a ``<version>`` is valid
+  against version-related arguments of :command:`find_package`.
+
+  .. code-block:: cmake
+
+    find_package_check_version(<version> <result-var>
+      [HANDLE_VERSION_RANGE]
+      [RESULT_MESSAGE_VARIABLE <message-var>]
+      )
+
+  The ``<result-var>`` will hold a boolean value giving the result of the check.
+
+  The options are:
+
+  ``HANDLE_VERSION_RANGE``
+    Enable handling of a version range, if one is specified. Without this
+    option, a developer warning will be displayed if a version range is
+    specified.
+
+  ``RESULT_MESSAGE_VARIABLE <message-var>``
+    Specify a variable to get back a message describing the result of the check.
+
+Example for the usage:
+
+.. code-block:: cmake
+
+  find_package_check_version(1.2.3 result HANDLE_VERSION_RANGE
+    RESULT_MESSAGE_VARIABLE reason)
+  if (result)
+    message (STATUS "${reason}")
+  else()
+    message (FATAL_ERROR "${reason}")
+  endif()
+#]=======================================================================]
+
+include(${CMAKE_CURRENT_LIST_DIR}/FindPackageMessage.cmake)
+
+
+cmake_policy(PUSH)
+# numbers and boolean constants
+cmake_policy (SET CMP0012 NEW)
+# IN_LIST operator
+cmake_policy (SET CMP0057 NEW)
+
+
+# internal helper macro
+macro(_FPHSA_FAILURE_MESSAGE _msg)
+  set (__msg "${_msg}")
+  if (FPHSA_REASON_FAILURE_MESSAGE)
+    string(APPEND __msg "\n    Reason given by package: ${FPHSA_REASON_FAILURE_MESSAGE}\n")
+  endif()
+  if (${_NAME}_FIND_REQUIRED)
+    message(FATAL_ERROR "${__msg}")
+  else ()
+    if (NOT ${_NAME}_FIND_QUIETLY)
+      message(STATUS "${__msg}")
+    endif ()
+  endif ()
+endmacro()
+
+
+# internal helper macro to generate the failure message when used in CONFIG_MODE:
+macro(_FPHSA_HANDLE_FAILURE_CONFIG_MODE)
+  # <PackageName>_CONFIG is set, but FOUND is false, this means that some other of the REQUIRED_VARS was not found:
+  if(${_NAME}_CONFIG)
+    _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: missing:${MISSING_VARS} (found ${${_NAME}_CONFIG} ${VERSION_MSG})")
+  else()
+    # If _CONSIDERED_CONFIGS is set, the config-file has been found, but no suitable version.
+    # List them all in the error message:
+    if(${_NAME}_CONSIDERED_CONFIGS)
+      set(configsText "")
+      list(LENGTH ${_NAME}_CONSIDERED_CONFIGS configsCount)
+      math(EXPR configsCount "${configsCount} - 1")
+      foreach(currentConfigIndex RANGE ${configsCount})
+        list(GET ${_NAME}_CONSIDERED_CONFIGS ${currentConfigIndex} filename)
+        list(GET ${_NAME}_CONSIDERED_VERSIONS ${currentConfigIndex} version)
+        string(APPEND configsText "\n    ${filename} (version ${version})")
+      endforeach()
+      if (${_NAME}_NOT_FOUND_MESSAGE)
+        if (FPHSA_REASON_FAILURE_MESSAGE)
+          string(PREPEND FPHSA_REASON_FAILURE_MESSAGE "${${_NAME}_NOT_FOUND_MESSAGE}\n    ")
+        else()
+          set(FPHSA_REASON_FAILURE_MESSAGE "${${_NAME}_NOT_FOUND_MESSAGE}")
+        endif()
+      else()
+        string(APPEND configsText "\n")
+      endif()
+      _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} ${VERSION_MSG}, checked the following files:${configsText}")
+
+    else()
+      # Simple case: No Config-file was found at all:
+      _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: found neither ${_NAME}Config.cmake nor ${_NAME_LOWER}-config.cmake ${VERSION_MSG}")
+    endif()
+  endif()
+endmacro()
+
+
+function(FIND_PACKAGE_CHECK_VERSION version result)
+  cmake_parse_arguments (PARSE_ARGV 2 FPCV "HANDLE_VERSION_RANGE;NO_AUTHOR_WARNING_VERSION_RANGE" "RESULT_MESSAGE_VARIABLE" "")
+
+  if (FPCV_UNPARSED_ARGUMENTS)
+    message (FATAL_ERROR "find_package_check_version(): ${FPCV_UNPARSED_ARGUMENTS}: unexpected arguments")
+  endif()
+  if ("RESULT_MESSAGE_VARIABLE" IN_LIST FPCV_KEYWORDS_MISSING_VALUES)
+    message (FATAL_ERROR "find_package_check_version(): RESULT_MESSAGE_VARIABLE expects an argument")
+  endif()
+
+  set (${result} FALSE PARENT_SCOPE)
+  if (FPCV_RESULT_MESSAGE_VARIABLE)
+    unset (${FPCV_RESULT_MESSAGE_VARIABLE} PARENT_SCOPE)
+  endif()
+
+  if (_CMAKE_FPHSA_PACKAGE_NAME)
+    set (package "${_CMAKE_FPHSA_PACKAGE_NAME}")
+  elseif (CMAKE_FIND_PACKAGE_NAME)
+    set (package "${CMAKE_FIND_PACKAGE_NAME}")
+  else()
+    message (FATAL_ERROR "find_package_check_version(): Cannot be used outside a 'Find Module'")
+  endif()
+
+  if (NOT FPCV_NO_AUTHOR_WARNING_VERSION_RANGE
+      AND ${package}_FIND_VERSION_RANGE AND NOT FPCV_HANDLE_VERSION_RANGE)
+    message(AUTHOR_WARNING
+      "`find_package()` specify a version range but the option "
+      "HANDLE_VERSION_RANGE` is not passed to `find_package_check_version()`. "
+      "Only the lower endpoint of the range will be used.")
+  endif()
+
+
+  set (version_ok FALSE)
+  unset (version_msg)
+
+  if (FPCV_HANDLE_VERSION_RANGE AND ${package}_FIND_VERSION_RANGE)
+    if ((${package}_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE"
+          AND version VERSION_GREATER_EQUAL ${package}_FIND_VERSION_MIN)
+        AND ((${package}_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE"
+            AND version VERSION_LESS_EQUAL ${package}_FIND_VERSION_MAX)
+          OR (${package}_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE"
+            AND version VERSION_LESS ${package}_FIND_VERSION_MAX)))
+      set (version_ok TRUE)
+      set(version_msg "(found suitable version \"${version}\", required range is \"${${package}_FIND_VERSION_RANGE}\")")
+    else()
+      set(version_msg "Found unsuitable version \"${version}\", required range is \"${${package}_FIND_VERSION_RANGE}\"")
+    endif()
+  elseif (DEFINED ${package}_FIND_VERSION)
+    if(${package}_FIND_VERSION_EXACT)       # exact version required
+      # count the dots in the version string
+      string(REGEX REPLACE "[^.]" "" version_dots "${version}")
+      # add one dot because there is one dot more than there are components
+      string(LENGTH "${version_dots}." version_dots)
+      if (version_dots GREATER ${package}_FIND_VERSION_COUNT)
+        # Because of the C++ implementation of find_package() ${package}_FIND_VERSION_COUNT
+        # is at most 4 here. Therefore a simple lookup table is used.
+        if (${package}_FIND_VERSION_COUNT EQUAL 1)
+          set(version_regex "[^.]*")
+        elseif (${package}_FIND_VERSION_COUNT EQUAL 2)
+          set(version_regex "[^.]*\\.[^.]*")
+        elseif (${package}_FIND_VERSION_COUNT EQUAL 3)
+          set(version_regex "[^.]*\\.[^.]*\\.[^.]*")
+        else()
+          set(version_regex "[^.]*\\.[^.]*\\.[^.]*\\.[^.]*")
+        endif()
+        string(REGEX REPLACE "^(${version_regex})\\..*" "\\1" version_head "${version}")
+        if (NOT ${package}_FIND_VERSION VERSION_EQUAL version_head)
+          set(version_msg "Found unsuitable version \"${version}\", but required is exact version \"${${package}_FIND_VERSION}\"")
+        else ()
+          set(version_ok TRUE)
+          set(version_msg "(found suitable exact version \"${_FOUND_VERSION}\")")
+        endif ()
+      else ()
+        if (NOT ${package}_FIND_VERSION VERSION_EQUAL version)
+          set(version_msg "Found unsuitable version \"${version}\", but required is exact version \"${${package}_FIND_VERSION}\"")
+        else ()
+          set(version_ok TRUE)
+          set(version_msg "(found suitable exact version \"${version}\")")
+        endif ()
+      endif ()
+    else()     # minimum version
+      if (${package}_FIND_VERSION VERSION_GREATER version)
+        set(version_msg "Found unsuitable version \"${version}\", but required is at least \"${${package}_FIND_VERSION}\"")
+      else()
+        set(version_ok TRUE)
+        set(version_msg "(found suitable version \"${version}\", minimum required is \"${${package}_FIND_VERSION}\")")
+      endif()
+    endif()
+  else ()
+    set(version_ok TRUE)
+    set(version_msg "(found version \"${version}\")")
+  endif()
+
+  set (${result} ${version_ok} PARENT_SCOPE)
+  if (FPCV_RESULT_MESSAGE_VARIABLE)
+    set (${FPCV_RESULT_MESSAGE_VARIABLE} "${version_msg}" PARENT_SCOPE)
+  endif()
+endfunction()
+
+
+function(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FIRST_ARG)
+
+  # Set up the arguments for `cmake_parse_arguments`.
+  set(options  CONFIG_MODE  HANDLE_COMPONENTS NAME_MISMATCHED HANDLE_VERSION_RANGE)
+  set(oneValueArgs  FAIL_MESSAGE  REASON_FAILURE_MESSAGE VERSION_VAR  FOUND_VAR)
+  set(multiValueArgs REQUIRED_VARS)
+
+  # Check whether we are in 'simple' or 'extended' mode:
+  set(_KEYWORDS_FOR_EXTENDED_MODE  ${options} ${oneValueArgs} ${multiValueArgs} )
+  list(FIND _KEYWORDS_FOR_EXTENDED_MODE "${_FIRST_ARG}" INDEX)
+
+  unset(FPHSA_NAME_MISMATCHED_override)
+  if (DEFINED FPHSA_NAME_MISMATCHED)
+    # If the variable NAME_MISMATCHED variable is set, error if it is passed as
+    # an argument. The former is for old signatures, the latter is for new
+    # signatures.
+    list(FIND ARGN "NAME_MISMATCHED" name_mismatched_idx)
+    if (NOT name_mismatched_idx EQUAL "-1")
+      message(FATAL_ERROR
+        "The `NAME_MISMATCHED` argument may only be specified by the argument or "
+        "the variable, not both.")
+    endif ()
+
+    # But use the variable if it is not an argument to avoid forcing minimum
+    # CMake version bumps for calling modules.
+    set(FPHSA_NAME_MISMATCHED_override "${FPHSA_NAME_MISMATCHED}")
+  endif ()
+
+  if(${INDEX} EQUAL -1)
+    set(FPHSA_FAIL_MESSAGE ${_FIRST_ARG})
+    set(FPHSA_REQUIRED_VARS ${ARGN})
+    set(FPHSA_VERSION_VAR)
+  else()
+    cmake_parse_arguments(FPHSA "${options}" "${oneValueArgs}" "${multiValueArgs}"  ${_FIRST_ARG} ${ARGN})
+
+    if(FPHSA_UNPARSED_ARGUMENTS)
+      message(FATAL_ERROR "Unknown keywords given to FIND_PACKAGE_HANDLE_STANDARD_ARGS(): \"${FPHSA_UNPARSED_ARGUMENTS}\"")
+    endif()
+
+    if(NOT FPHSA_FAIL_MESSAGE)
+      set(FPHSA_FAIL_MESSAGE  "DEFAULT_MSG")
+    endif()
+
+    # In config-mode, we rely on the variable <PackageName>_CONFIG, which is set by find_package()
+    # when it successfully found the config-file, including version checking:
+    if(FPHSA_CONFIG_MODE)
+      list(INSERT FPHSA_REQUIRED_VARS 0 ${_NAME}_CONFIG)
+      list(REMOVE_DUPLICATES FPHSA_REQUIRED_VARS)
+      set(FPHSA_VERSION_VAR ${_NAME}_VERSION)
+    endif()
+
+    if(NOT FPHSA_REQUIRED_VARS AND NOT FPHSA_HANDLE_COMPONENTS)
+      message(FATAL_ERROR "No REQUIRED_VARS specified for FIND_PACKAGE_HANDLE_STANDARD_ARGS()")
+    endif()
+  endif()
+
+  if (DEFINED FPHSA_NAME_MISMATCHED_override)
+    set(FPHSA_NAME_MISMATCHED "${FPHSA_NAME_MISMATCHED_override}")
+  endif ()
+
+  if (DEFINED CMAKE_FIND_PACKAGE_NAME
+      AND NOT FPHSA_NAME_MISMATCHED
+      AND NOT _NAME STREQUAL CMAKE_FIND_PACKAGE_NAME)
+    message(AUTHOR_WARNING
+      "The package name passed to `find_package_handle_standard_args` "
+      "(${_NAME}) does not match the name of the calling package "
+      "(${CMAKE_FIND_PACKAGE_NAME}). This can lead to problems in calling "
+      "code that expects `find_package` result variables (e.g., `_FOUND`) "
+      "to follow a certain pattern.")
+  endif ()
+
+  if (${_NAME}_FIND_VERSION_RANGE AND NOT FPHSA_HANDLE_VERSION_RANGE)
+    message(AUTHOR_WARNING
+      "`find_package()` specify a version range but the module ${_NAME} does "
+      "not support this capability. Only the lower endpoint of the range "
+      "will be used.")
+  endif()
+
+  # to propagate package name to FIND_PACKAGE_CHECK_VERSION
+  set(_CMAKE_FPHSA_PACKAGE_NAME "${_NAME}")
+
+  # now that we collected all arguments, process them
+
+  if("x${FPHSA_FAIL_MESSAGE}" STREQUAL "xDEFAULT_MSG")
+    set(FPHSA_FAIL_MESSAGE "Could NOT find ${_NAME}")
+  endif()
+
+  if (FPHSA_REQUIRED_VARS)
+    list(GET FPHSA_REQUIRED_VARS 0 _FIRST_REQUIRED_VAR)
+  endif()
+
+  string(TOUPPER ${_NAME} _NAME_UPPER)
+  string(TOLOWER ${_NAME} _NAME_LOWER)
+
+  if(FPHSA_FOUND_VAR)
+    set(_FOUND_VAR_UPPER ${_NAME_UPPER}_FOUND)
+    set(_FOUND_VAR_MIXED ${_NAME}_FOUND)
+    if(FPHSA_FOUND_VAR STREQUAL _FOUND_VAR_MIXED  OR  FPHSA_FOUND_VAR STREQUAL _FOUND_VAR_UPPER)
+      set(_FOUND_VAR ${FPHSA_FOUND_VAR})
+    else()
+      message(FATAL_ERROR "The argument for FOUND_VAR is \"${FPHSA_FOUND_VAR}\", but only \"${_FOUND_VAR_MIXED}\" and \"${_FOUND_VAR_UPPER}\" are valid names.")
+    endif()
+  else()
+    set(_FOUND_VAR ${_NAME_UPPER}_FOUND)
+  endif()
+
+  # collect all variables which were not found, so they can be printed, so the
+  # user knows better what went wrong (#6375)
+  set(MISSING_VARS "")
+  set(DETAILS "")
+  # check if all passed variables are valid
+  set(FPHSA_FOUND_${_NAME} TRUE)
+  foreach(_CURRENT_VAR ${FPHSA_REQUIRED_VARS})
+    if(NOT ${_CURRENT_VAR})
+      set(FPHSA_FOUND_${_NAME} FALSE)
+      string(APPEND MISSING_VARS " ${_CURRENT_VAR}")
+    else()
+      string(APPEND DETAILS "[${${_CURRENT_VAR}}]")
+    endif()
+  endforeach()
+  if(FPHSA_FOUND_${_NAME})
+    set(${_NAME}_FOUND TRUE)
+    set(${_NAME_UPPER}_FOUND TRUE)
+  else()
+    set(${_NAME}_FOUND FALSE)
+    set(${_NAME_UPPER}_FOUND FALSE)
+  endif()
+
+  # component handling
+  unset(FOUND_COMPONENTS_MSG)
+  unset(MISSING_COMPONENTS_MSG)
+
+  if(FPHSA_HANDLE_COMPONENTS)
+    foreach(comp ${${_NAME}_FIND_COMPONENTS})
+      if(${_NAME}_${comp}_FOUND)
+
+        if(NOT DEFINED FOUND_COMPONENTS_MSG)
+          set(FOUND_COMPONENTS_MSG "found components:")
+        endif()
+        string(APPEND FOUND_COMPONENTS_MSG " ${comp}")
+
+      else()
+
+        if(NOT DEFINED MISSING_COMPONENTS_MSG)
+          set(MISSING_COMPONENTS_MSG "missing components:")
+        endif()
+        string(APPEND MISSING_COMPONENTS_MSG " ${comp}")
+
+        if(${_NAME}_FIND_REQUIRED_${comp})
+          set(${_NAME}_FOUND FALSE)
+          string(APPEND MISSING_VARS " ${comp}")
+        endif()
+
+      endif()
+    endforeach()
+    set(COMPONENT_MSG "${FOUND_COMPONENTS_MSG} ${MISSING_COMPONENTS_MSG}")
+    string(APPEND DETAILS "[c${COMPONENT_MSG}]")
+  endif()
+
+  # version handling:
+  set(VERSION_MSG "")
+  set(VERSION_OK TRUE)
+
+  # check that the version variable is not empty to avoid emitting a misleading
+  # message (i.e. `Found unsuitable version ""`)
+  if (DEFINED ${_NAME}_FIND_VERSION)
+    if(DEFINED ${FPHSA_VERSION_VAR})
+      if(NOT "${${FPHSA_VERSION_VAR}}" STREQUAL "")
+        set(_FOUND_VERSION ${${FPHSA_VERSION_VAR}})
+        if (FPHSA_HANDLE_VERSION_RANGE)
+          set (FPCV_HANDLE_VERSION_RANGE HANDLE_VERSION_RANGE)
+        else()
+          set(FPCV_HANDLE_VERSION_RANGE NO_AUTHOR_WARNING_VERSION_RANGE)
+        endif()
+        find_package_check_version ("${_FOUND_VERSION}" VERSION_OK RESULT_MESSAGE_VARIABLE VERSION_MSG
+          ${FPCV_HANDLE_VERSION_RANGE})
+      else()
+        set(VERSION_OK FALSE)
+      endif()
+    endif()
+    if("${${FPHSA_VERSION_VAR}}" STREQUAL "")
+      # if the package was not found, but a version was given, add that to the output:
+      if(${_NAME}_FIND_VERSION_EXACT)
+        set(VERSION_MSG "(Required is exact version \"${${_NAME}_FIND_VERSION}\")")
+      elseif (FPHSA_HANDLE_VERSION_RANGE AND ${_NAME}_FIND_VERSION_RANGE)
+        set(VERSION_MSG "(Required is version range \"${${_NAME}_FIND_VERSION_RANGE}\")")
+      else()
+        set(VERSION_MSG "(Required is at least version \"${${_NAME}_FIND_VERSION}\")")
+      endif()
+    endif()
+  else ()
+    # Check with DEFINED as the found version may be 0.
+    if(DEFINED ${FPHSA_VERSION_VAR})
+      set(VERSION_MSG "(found version \"${${FPHSA_VERSION_VAR}}\")")
+    endif()
+  endif ()
+
+  if(VERSION_OK)
+    string(APPEND DETAILS "[v${${FPHSA_VERSION_VAR}}(${${_NAME}_FIND_VERSION})]")
+  else()
+    set(${_NAME}_FOUND FALSE)
+  endif()
+
+
+  # print the result:
+  if (${_NAME}_FOUND)
+    FIND_PACKAGE_MESSAGE(${_NAME} "Found ${_NAME}: ${${_FIRST_REQUIRED_VAR}} ${VERSION_MSG} ${COMPONENT_MSG}" "${DETAILS}")
+  else ()
+
+    if(FPHSA_CONFIG_MODE)
+      _FPHSA_HANDLE_FAILURE_CONFIG_MODE()
+    else()
+      if(NOT VERSION_OK)
+        set(RESULT_MSG)
+        if (_FIRST_REQUIRED_VAR)
+          string (APPEND RESULT_MSG "found ${${_FIRST_REQUIRED_VAR}}")
+        endif()
+        if (COMPONENT_MSG)
+          if (RESULT_MSG)
+            string (APPEND RESULT_MSG ", ")
+          endif()
+          string (APPEND RESULT_MSG "${FOUND_COMPONENTS_MSG}")
+        endif()
+        _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: ${VERSION_MSG} (${RESULT_MSG})")
+      else()
+        _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} (missing:${MISSING_VARS}) ${VERSION_MSG}")
+      endif()
+    endif()
+
+  endif ()
+
+  set(${_NAME}_FOUND ${${_NAME}_FOUND} PARENT_SCOPE)
+  set(${_NAME_UPPER}_FOUND ${${_NAME}_FOUND} PARENT_SCOPE)
+endfunction()
+
+
+cmake_policy(POP)

cmake/modules/FindPackageMessage.cmake

@@ -0,0 +1,48 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+FindPackageMessage
+------------------
+
+.. code-block:: cmake
+
+  find_package_message(<name> "message for user" "find result details")
+
+This function is intended to be used in FindXXX.cmake modules files.
+It will print a message once for each unique find result.  This is
+useful for telling the user where a package was found.  The first
+argument specifies the name (XXX) of the package.  The second argument
+specifies the message to display.  The third argument lists details
+about the find result so that if they change the message will be
+displayed again.  The macro also obeys the QUIET argument to the
+find_package command.
+
+Example:
+
+.. code-block:: cmake
+
+  if(X11_FOUND)
+    find_package_message(X11 "Found X11: ${X11_X11_LIB}"
+      "[${X11_X11_LIB}][${X11_INCLUDE_DIR}]")
+  else()
+   ...
+  endif()
+#]=======================================================================]
+
+function(find_package_message pkg msg details)
+  # Avoid printing a message repeatedly for the same find result.
+  if(NOT ${pkg}_FIND_QUIETLY)
+    string(REPLACE "\n" "" details "${details}")
+    set(DETAILS_VAR FIND_PACKAGE_MESSAGE_DETAILS_${pkg})
+    if(NOT "${details}" STREQUAL "${${DETAILS_VAR}}")
+      # The message has not yet been printed.
+      message(STATUS "${msg}")
+
+      # Save the find details in the cache to avoid printing the same
+      # message again.
+      set("${DETAILS_VAR}" "${details}"
+        CACHE INTERNAL "Details about finding ${pkg}")
+    endif()
+  endif()
+endfunction()

dist/AppImageBuilder.yml

@@ -135,5 +135,5 @@ AppDir:
     - usr/share/doc/*/TODO.*
 AppImage:
   arch: x86_64
-  update-information: gh-releases-zsync|WerWolv|ImHex|latest|imhex-*.AppImage.zsync
-  file_name: imhex-{{VERSION}}.AppImage
+  update-information: gh-releases-zsync|WerWolv|ImHex|latest|imhex-*-x86_64.AppImage.zsync
+  file_name: imhex-{{VERSION}}-x86_64.AppImage

dist/Arch/PKGBUILD

@@ -1,4 +1,4 @@
-# Maintainer: iTrooz_ <itrooz at protonmail dot com>
+# Maintainer: iTrooz_ <hey at itrooz dot fr>
 # Contributor: Morten Linderud <foxboron@archlinux.org>
 
 pkgname=imhex-bin
@@ -12,7 +12,7 @@ depends=(glfw mbedtls freetype2 libglvnd dbus xdg-desktop-portal curl fmt yara n
 makedepends=(git)
 provides=(imhex)
 conflicts=(imhex)
-source=("$url/releases/download/v$pkgver/imhex-$pkgver-ArchLinux.pkg.tar.zst")
+source=("$url/releases/download/v$pkgver/imhex-$pkgver-ArchLinux-x86_64.pkg.tar.zst")
 md5sums=(SKIP)
 
 package() {

dist/Brewfile

@@ -7,3 +7,4 @@ brew "libmagic"
 brew "pkg-config"
 brew "gcc@12"
 brew "llvm"
+brew "glfw"

dist/langtool.py

@@ -3,7 +3,7 @@ import sys
 import json
 
 DEFAULT_LANG = "en_US"
-INVALID_TRANSLATION = "***** MISSING TRANSLATION *****"
+INVALID_TRANSLATION = ""
 
 
 def handle_missing_key(command, lang_data, key, value):

dist/rpm/imhex.spec

@@ -1,10 +1,14 @@
 Name:           imhex
-Version:        %{_version}
+Version:        1.26.2
 Release:        0%{?dist}
 Summary:        A hex editor for reverse engineers and programmers
 
-License:        GPL-2.0-only
+License:        GPL-2.0-only AND Zlib AND MIT AND Apache-2.0
+# imhex is gplv2.  capstone is custom.  nativefiledialog is Zlib.  intervaltree is MIT
+# see license dir for full breakdown
 URL:            https://imhex.werwolv.net/
+# We need the archive with deps bundled
+Source0:        https://github.com/WerWolv/%{name}/releases/download/v%{version}/Full.Sources.tar.gz#/%{name}-%{version}.tar.gz
 
 BuildRequires:  cmake
 BuildRequires:  desktop-file-utils
@@ -13,16 +17,36 @@ BuildRequires:  file-devel
 BuildRequires:  freetype-devel
 BuildRequires:  fmt-devel
 BuildRequires:  gcc-c++
-BuildRequires:  mesa-libGL-devel
+BuildRequires:  libappstream-glib
+BuildRequires:  libglvnd-devel
 BuildRequires:  glfw-devel
 BuildRequires:  json-devel
 BuildRequires:  libcurl-devel
 BuildRequires:  llvm-devel
 BuildRequires:  mbedtls-devel
-%if 0%{?fedora} >= 37
 BuildRequires:  yara-devel
+BuildRequires:  nativefiledialog-extended-devel
+%if 0%{?rhel}
+BuildRequires:  gcc-toolset-12
 %endif
 
+Provides:       bundled(gnulib)
+Provides:       bundled(capstone) = 5.0-rc2
+Provides:       bundled(imgui)
+Provides:       bundled(libromfs)
+Provides:       bundled(microtar)
+Provides:       bundled(libpl)
+# ImHex modified upstream intervaltree so we have to package it
+# https://github.com/ekg/intervaltree
+Provides:       bundled(intervaltree) = 0.1
+Provides:       bundled(xdgpp)
+
+# ftbfs on these arches.  armv7hl might compile when capstone 5.x
+# is released upstream and we can build against it
+# [7:02 PM] WerWolv: We're not supporting 32 bit anyways soooo
+# [11:38 AM] WerWolv: Officially supported are x86_64 and aarch64
+ExclusiveArch:  x86_64 %{arm64} ppc64le
+
 
 %description
 ImHex is a Hex Editor, a tool to display, decode and analyze binary data to
@@ -37,26 +61,26 @@ same time ImHex is completely free and open source under the GPLv2 language.
 
 
 %prep
-# don't use the setup macro since we're pulling from git
-cp -r %{_src_path}/* %{_builddir}/
-
+%autosetup -n ImHex
+# remove bundled libs we aren't using
+rm -rf lib/external/{curl,fmt,llvm,nlohmann_json,yara}
 
 %build
-%cmake \
- -DCMAKE_BUILD_TYPE=%{_build_type} \
- -D USE_SYSTEM_NLOHMANN_JSON=ON \
- -D USE_SYSTEM_FMT=ON \
- -D USE_SYSTEM_CURL=ON \
- -D USE_SYSTEM_LLVM=ON \
- -DCMAKE_C_COMPILER_LAUNCHER=ccache        \
- -DCMAKE_CXX_COMPILER_LAUNCHER=ccache      \
- -D IMHEX_PATTERNS_PULL_MASTER=ON          \
-%if 0%{?fedora} >= 37
- -D USE_SYSTEM_YARA=ON \
-# if fedora <= 36 get updated to yara 4.2.x then they should \
-# be able to build against system libs \
-# https://bugzilla.redhat.com/show_bug.cgi?id=2112508 \
+%if 0%{?rhel}
+. /opt/rh/gcc-toolset-12/enable
+%set_build_flags
+CXXFLAGS+=" -std=gnu++2b"
 %endif
+%cmake \
+ -D CMAKE_BUILD_TYPE=Release             \
+ -D IMHEX_STRIP_RELEASE=OFF              \
+ -D IMHEX_OFFLINE_BUILD=ON               \
+ -D USE_SYSTEM_NLOHMANN_JSON=ON          \
+ -D USE_SYSTEM_FMT=ON                    \
+ -D USE_SYSTEM_CURL=ON                   \
+ -D USE_SYSTEM_LLVM=ON                   \
+ -D USE_SYSTEM_YARA=ON                   \
+ -D USE_SYSTEM_NFD=ON                    \
 # when capstone >= 5.x is released we should be able to build against \
 # system libs of it \
 # -D USE_SYSTEM_CAPSTONE=ON
@@ -64,23 +88,48 @@ cp -r %{_src_path}/* %{_builddir}/
 %cmake_build
 
 
+%check
+%if 0%{?rhel}
+. /opt/rh/gcc-toolset-12/enable
+%set_build_flags
+CXXFLAGS+=" -std=gnu++2b"
+%endif
+# build binaries required for tests
+%cmake_build --target unit_tests
+%ctest --exclude-regex '(Helpers/StoreAPI|Helpers/TipsAPI|Helpers/ContentAPI)'
+# Helpers/*API exclude tests that require network access
+
+
 %install
 %cmake_install
-desktop-file-validate %{buildroot}%{_datadir}/applications/imhex.desktop
+desktop-file-validate %{buildroot}%{_datadir}/applications/%{name}.desktop
+
+# this is a symlink for the old appdata name that we don't need
+rm -f %{buildroot}%{_metainfodir}/net.werwolv.%{name}.appdata.xml
+
+# AppData
+appstream-util validate-relax --nonet %{buildroot}%{_metainfodir}/net.werwolv.%{name}.metainfo.xml
+
+# install licenses
+cp -a lib/external/nativefiledialog/LICENSE                       %{buildroot}%{_datadir}/licenses/%{name}/nativefiledialog-LICENSE
+cp -a lib/external/capstone/LICENSE.TXT                           %{buildroot}%{_datadir}/licenses/%{name}/capstone-LICENSE
+cp -a lib/external/capstone/suite/regress/LICENSE                 %{buildroot}%{_datadir}/licenses/%{name}/capstone-regress-LICENSE
+cp -a lib/external/microtar/LICENSE                               %{buildroot}%{_datadir}/licenses/%{name}/microtar-LICENSE
+cp -a lib/external/pattern_language/external/intervaltree/LICENSE %{buildroot}%{_datadir}/licenses/%{name}/pattern-language-intervaltree-LICENSE
+cp -a lib/external/xdgpp/LICENSE                                  %{buildroot}%{_datadir}/licenses/%{name}/xdgpp-LICENSE
 
 
 %files
-%dir %{_datadir}/licenses/imhex
-%license %{_datadir}/licenses/imhex/LICENSE
+%license %{_datadir}/licenses/%{name}/
 %doc README.md
 %{_bindir}/imhex
-%dir %{_datadir}/imhex
-%{_datadir}/imhex/*
-%{_datadir}/pixmaps/imhex.png
-%{_datadir}/applications/imhex.desktop
-%{_prefix}/lib64/libimhex.so.%{_version}
-%{_prefix}/lib64/imhex/plugins/*
-%{_metainfodir}/net.werwolv.imhex.metainfo.xml
-%{_metainfodir}/net.werwolv.imhex.appdata.xml
+%{_datadir}/pixmaps/%{name}.png
+%{_datadir}/applications/%{name}.desktop
+%{_libdir}/libimhex.so*
+%{_libdir}/%{name}/
+%{_metainfodir}/net.werwolv.%{name}.metainfo.xml
+
 
 %changelog
+* Thu Jan 01 1970 ImHex GitHub CI - 0.0.0-0
+- Build Package

lib/external/imgui/CMakeLists.txt

@@ -8,10 +8,6 @@ find_package(Freetype REQUIRED)
 find_package(OpenGL REQUIRED)
 pkg_search_module(GLFW REQUIRED glfw3)
 
-if (UNIX)
-    find_package(OpenGL REQUIRED)
-endif ()
-
 add_library(imgui OBJECT
         source/imgui.cpp
         source/imgui_demo.cpp
@@ -39,12 +35,8 @@ add_library(imgui OBJECT
 
 add_compile_definitions(IMGUI_IMPL_OPENGL_LOADER_GLAD)
 
-target_include_directories(imgui PUBLIC include ${FREETYPE_INCLUDE_DIRS} ${GLFW_INCLUDE_DIRS})
+target_include_directories(imgui PUBLIC include ${FREETYPE_INCLUDE_DIRS} ${GLFW_INCLUDE_DIRS} ${OpenGL_INCLUDE_DIRS})
 
-target_link_directories(imgui PUBLIC ${GLFW_LIBRARY_DIRS})
+target_link_directories(imgui PUBLIC ${GLFW_LIBRARY_DIRS} ${OpenGL_LIBRARY_DIRS})
 
-if (WIN32)
-    target_link_libraries(imgui PUBLIC Freetype::Freetype glfw3 opengl32.lib)
-elseif (UNIX)
-    target_link_libraries(imgui PUBLIC Freetype::Freetype glfw OpenGL::GL)
-endif()
+target_link_libraries(imgui PUBLIC Freetype::Freetype ${GLFW_LIBRARIES} ${OPENGL_LIBRARIES})

lib/external/imgui/source/TextEditor.cpp

@@ -314,7 +314,7 @@ TextEditor::Coordinates TextEditor::FindWordStart(const Coordinates &aFrom) cons
     while (cindex > 0 && isspace(line[cindex].mChar))
         --cindex;
 
-    auto cstart = (PaletteIndex)line[cindex].mColorIndex;
+    auto cstart = line[cindex].mChar;
     while (cindex > 0) {
         auto c = line[cindex].mChar;
         if ((c & 0xC0) != 0x80)    // not UTF code sequence 10xxxxxx
@@ -323,8 +323,15 @@ TextEditor::Coordinates TextEditor::FindWordStart(const Coordinates &aFrom) cons
                 cindex++;
                 break;
             }
-            if (cstart != (PaletteIndex)line[size_t(cindex - 1)].mColorIndex)
+
+            if (isalnum(cstart)) {
+                if (!isalnum(c)) {
+                    cindex++;
+                    break;
+                }
+            } else {
                 break;
+            }
         }
         --cindex;
     }
@@ -632,10 +639,24 @@ void TextEditor::HandleKeyboardInputs() {
             MoveEnd(shift);
         else if (!IsReadOnly() && !ctrl && !shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Delete)))
             Delete();
+        else if (!IsReadOnly() && ctrl && !shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Delete))) {
+            auto wordStart = GetCursorPosition();
+            MoveRight();
+            auto wordEnd = FindWordEnd(GetCursorPosition());
+            SetSelection(wordStart, wordEnd);
+            Backspace();
+        }
         else if (!IsReadOnly() && !ctrl && !shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Backspace)))
             Backspace();
+        else if (!IsReadOnly() && ctrl && !shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Backspace))) {
+            auto wordEnd = GetCursorPosition();
+            MoveLeft();
+            auto wordStart = FindWordStart(GetCursorPosition());
+            SetSelection(wordStart, wordEnd);
+            Backspace();
+        }
         else if (!ctrl && !shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Insert)))
-            mOverwrite ^= true;
+            mOverwrite = !mOverwrite;
         else if (ctrl && !shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Insert)))
             Copy();
         else if (ctrl && !shift && !alt && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_C)))
@@ -2123,7 +2144,7 @@ void TextEditor::EnsureCursorVisible() {
     if (len + mTextStart < left + 4)
         ImGui::SetScrollX(std::max(0.0f, len + mTextStart - 4));
     if (len + mTextStart > right - 4)
-        ImGui::SetScrollX(std::max(0.0f, len + mTextStart + 4 - width));
+        ImGui::SetScrollX(std::max(0.0f, len + mTextStart + 4 - width + mCharAdvance.x * 2));
 }
 
 int TextEditor::GetPageSize() const {

lib/external/miniaudio/CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.16)
+project(miniaudio)
+
+add_library(miniaudio STATIC
+        source/miniaudio.c
+)
+
+target_include_directories(miniaudio PUBLIC include)
+
+if (APPLE)
+    set_source_files_properties(source/miniaudio.c PROPERTIES LANGUAGE OBJC)
+endif ()

lib/external/miniaudio/LICENSE

@@ -0,0 +1,47 @@
+This software is available as a choice of the following licenses. Choose
+whichever you prefer.
+
+===============================================================================
+ALTERNATIVE 1 - Public Domain (www.unlicense.org)
+===============================================================================
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>
+
+===============================================================================
+ALTERNATIVE 2 - MIT No Attribution
+===============================================================================
+Copyright 2020 David Reid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lib/libimhex/CMakeLists.txt

@@ -24,11 +24,13 @@ set(LIBIMHEX_SOURCES
     source/helpers/magic.cpp
     source/helpers/crypto.cpp
     source/helpers/net.cpp
+    source/helpers/opengl.cpp
     source/helpers/file.cpp
     source/helpers/socket.cpp
     source/helpers/patches.cpp
     source/helpers/encoding_file.cpp
     source/helpers/logger.cpp
+    source/helpers/stacktrace.cpp
     source/helpers/tar.cpp
 
     source/providers/provider.cpp
@@ -59,7 +61,7 @@ set_target_properties(libimhex PROPERTIES POSITION_INDEPENDENT_CODE ON)
 setupCompilerWarnings(libimhex)
 
 
-target_include_directories(libimhex PUBLIC include ${XDGPP_INCLUDE_DIRS} ${MBEDTLS_INCLUDE_DIRS} ${CAPSTONE_INCLUDE_DIRS} ${MAGIC_INCLUDE_DIRS} ${LLVM_INCLUDE_DIRS} ${FMT_INCLUDE_DIRS} ${CURL_INCLUDE_DIRS} ${YARA_INCLUDE_DIRS})
+target_include_directories(libimhex PUBLIC include ${XDGPP_INCLUDE_DIRS} ${MBEDTLS_INCLUDE_DIRS} ${CAPSTONE_INCLUDE_DIRS} ${MAGIC_INCLUDE_DIRS} ${LLVM_INCLUDE_DIRS} ${FMT_INCLUDE_DIRS} ${CURL_INCLUDE_DIRS} ${YARA_INCLUDE_DIRS} ${LIBBACKTRACE_INCLUDE_DIRS})
 target_link_directories(libimhex PUBLIC ${MBEDTLS_LIBRARY_DIR} ${CAPSTONE_LIBRARY_DIRS} ${MAGIC_LIBRARY_DIRS})
 
 if (WIN32)
@@ -70,4 +72,4 @@ elseif (APPLE)
 endif ()
 
 target_link_libraries(libimhex PRIVATE ${FMT_LIBRARIES})
-target_link_libraries(libimhex PUBLIC dl imgui ${NFD_LIBRARIES} magic ${CAPSTONE_LIBRARIES} LLVMDemangle microtar ${NLOHMANN_JSON_LIBRARIES} ${YARA_LIBRARIES} ${LIBCURL_LIBRARIES} ${MBEDTLS_LIBRARIES} libpl intervaltree)
+target_link_libraries(libimhex PUBLIC dl imgui ${NFD_LIBRARIES} magic ${CAPSTONE_LIBRARIES} LLVMDemangle microtar ${NLOHMANN_JSON_LIBRARIES} ${YARA_LIBRARIES} ${LIBCURL_LIBRARIES} ${MBEDTLS_LIBRARIES} ${LIBBACKTRACE_LIBRARIES} libpl intervaltree ${MINIAUDIO_LIBRARIES})

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

@@ -9,9 +9,10 @@
 
 #include <functional>
 #include <map>
-#include <unordered_map>
+#include <span>
 #include <string>
 #include <string_view>
+#include <unordered_map>
 #include <vector>
 
 #include <nlohmann/json_fwd.hpp>
@@ -117,6 +118,8 @@ namespace hex {
         /* Pattern Language Function Registry. Allows adding of new functions that may be used inside the pattern language */
         namespace PatternLanguage {
 
+            using VisualizerFunctionCallback = std::function<void(pl::ptrn::Pattern&, pl::ptrn::Iteratable&, bool, std::span<const pl::core::Token::Literal>)>;
+
             namespace impl {
 
                 struct FunctionDefinition {
@@ -129,6 +132,13 @@ namespace hex {
                     bool dangerous;
                 };
 
+                struct Visualizer {
+                    u32 parameterCount;
+                    VisualizerFunctionCallback callback;
+                };
+
+                std::map<std::string, Visualizer> &getVisualizers();
+
             }
 
             void configureRuntime(pl::PatternLanguage &runtime, prv::Provider *provider);
@@ -138,6 +148,8 @@ namespace hex {
             void addFunction(const pl::api::Namespace &ns, const std::string &name, pl::api::FunctionParameterCount parameterCount, const pl::api::FunctionCallback &func);
             void addDangerousFunction(const pl::api::Namespace &ns, const std::string &name, pl::api::FunctionParameterCount parameterCount, const pl::api::FunctionCallback &func);
 
+            void addVisualizer(const std::string &name, const VisualizerFunctionCallback &func, u32 parameterCount);
+
             std::map<std::string, pl::api::PragmaHandler> &getPragmas();
             std::vector<impl::FunctionDefinition> &getFunctions();
 
@@ -436,11 +448,12 @@ namespace hex {
                 public:
                     using Callback = std::function<std::vector<u8>(const Region&, prv::Provider *)>;
 
-                    Function(const Hash *type, std::string name, Callback callback)
+                    Function(Hash *type, std::string name, Callback callback)
                         : m_type(type), m_name(std::move(name)), m_callback(std::move(callback)) {
 
                     }
 
+                    [[nodiscard]] Hash *getType() { return this->m_type; }
                     [[nodiscard]] const Hash *getType() const { return this->m_type; }
                     [[nodiscard]] const std::string &getName() const { return this->m_name; }
 
@@ -457,7 +470,7 @@ namespace hex {
                     }
 
                 private:
-                    const Hash *m_type;
+                    Hash *m_type;
                     std::string m_name;
                     Callback m_callback;
 
@@ -467,12 +480,15 @@ namespace hex {
                 virtual void draw() { }
                 [[nodiscard]] virtual Function create(std::string name) = 0;
 
+                [[nodiscard]] virtual nlohmann::json store() const = 0;
+                virtual void load(const nlohmann::json &json) = 0;
+
                 [[nodiscard]] const std::string &getUnlocalizedName() const {
                     return this->m_unlocalizedName;
                 }
 
             protected:
-                [[nodiscard]] Function create(const std::string &name, const Function::Callback &callback) const {
+                [[nodiscard]] Function create(const std::string &name, const Function::Callback &callback) {
                     return { this, name, callback };
                 }
 

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

@@ -121,12 +121,13 @@ namespace hex {
     EVENT_DEF(EventFrameBegin);
     EVENT_DEF(EventFrameEnd);
     EVENT_DEF(EventWindowInitialized);
+    EVENT_DEF(EventSetTaskBarIconState, u32, u32, u32);
 
     EVENT_DEF(RequestOpenWindow, std::string);
     EVENT_DEF(RequestSelectionChange, Region);
     EVENT_DEF(RequestAddBookmark, Region, std::string, std::string, color_t);
     EVENT_DEF(RequestSetPatternLanguageCode, std::string);
-    EVENT_DEF(RequestChangeWindowTitle, std::string);
+    EVENT_DEF(RequestUpdateWindowTitle);
     EVENT_DEF(RequestCloseImHex, bool);
     EVENT_DEF(RequestRestartImHex);
     EVENT_DEF(RequestOpenFile, std::fs::path);
@@ -138,6 +139,6 @@ namespace hex {
     EVENT_DEF(RequestShowErrorPopup, std::string);
     EVENT_DEF(RequestShowFatalErrorPopup, std::string);
     EVENT_DEF(RequestShowYesNoQuestionPopup, std::string, std::function<void()>, std::function<void()>);
-    EVENT_DEF(RequestShowFileChooserPopup, std::vector<std::fs::path>, std::vector<nfdfilteritem_t>, std::function<void(std::fs::path)>);
+    EVENT_DEF(RequestShowFileChooserPopup, std::vector<std::fs::path>, std::vector<nfdfilteritem_t>, std::function<void(std::fs::path)>, bool);
 
 }

lib/libimhex/include/hex/api/imhex_api.hpp

@@ -191,6 +191,20 @@ namespace hex {
                 char **envp;
             };
 
+            enum class TaskProgressState {
+                Reset,
+                Progress,
+                Flash
+            };
+
+            enum class TaskProgressType {
+                Normal,
+                Warning,
+                Error
+            };
+
+            void setTaskBarProgress(TaskProgressState state, TaskProgressType type, u32 progress);
+
             const ProgramArguments &getProgramArguments();
             std::optional<std::u8string> getProgramArgument(int index);
 

lib/libimhex/include/hex/api/keybinding.hpp

@@ -184,6 +184,24 @@ namespace hex {
     constexpr static auto SHIFT = Key(static_cast<Keys>(0x4000'0000));
     constexpr static auto SUPER = Key(static_cast<Keys>(0x8000'0000));
 
+#if defined(OS_MACOS)
+    constexpr static auto CTRLCMD = SUPER;
+
+    constexpr static auto CTRL_NAME    = "CTRL";
+    constexpr static auto ALT_NAME     = "OPT";
+    constexpr static auto SHIFT_NAME   = "SHIFT";
+    constexpr static auto SUPER_NAME   = "CMD";
+    constexpr static auto CTRLCMD_NAME = SUPER_NAME;
+#else
+    constexpr static auto CTRLCMD = CTRL;
+
+    constexpr static auto CTRL_NAME    = "CTRL";
+    constexpr static auto ALT_NAME     = "ALT";
+    constexpr static auto SHIFT_NAME   = "SHIFT";
+    constexpr static auto SUPER_NAME   = "SUPER";
+    constexpr static auto CTRLCMD_NAME = CTRL_NAME;
+#endif
+
     class ShortcutManager {
     public:
         static void addGlobalShortcut(const Shortcut &shortcut, const std::function<void()> &callback);

lib/libimhex/include/hex/api/project_file_manager.hpp

@@ -34,6 +34,9 @@ namespace hex {
         static bool store(std::optional<std::fs::path> filePath = std::nullopt);
 
         static bool hasPath();
+        static void clearPath();
+        static std::fs::path getPath();
+        static void setPath(const std::fs::path &path);
 
         static void registerHandler(const Handler &handler) {
             getHandlers().push_back(handler);

lib/libimhex/include/hex/api/theme_manager.hpp

@@ -24,6 +24,8 @@ namespace hex::api {
         static const std::string &getThemeImagePostfix();
 
         static std::optional<ImColor> parseColorString(const std::string &colorString);
+
+        static void reset();
     private:
         ThemeManager() = default;
 

lib/libimhex/include/hex/data_processor/attribute.hpp

@@ -38,9 +38,18 @@ namespace hex::dp {
         void removeConnectedAttribute(int linkId) { this->m_connectedAttributes.erase(linkId); }
         [[nodiscard]] std::map<int, Attribute *> &getConnectedAttributes() { return this->m_connectedAttributes; }
 
-        [[nodiscard]] Node *getParentNode() { return this->m_parentNode; }
+        [[nodiscard]] Node *getParentNode() const { return this->m_parentNode; }
 
-        [[nodiscard]] std::optional<std::vector<u8>> &getOutputData() { return this->m_outputData; }
+        [[nodiscard]] std::vector<u8>& getOutputData() {
+            if (!this->m_outputData.empty())
+                return this->m_outputData;
+            else
+                return this->m_defaultData;
+        }
+
+        void clearOutputData() { this->m_outputData.clear(); }
+
+        [[nodiscard]] std::vector<u8>& getDefaultData() { return this->m_defaultData; }
 
         static void setIdCounter(int id) {
             if (id > Attribute::s_idCounter)
@@ -55,7 +64,8 @@ namespace hex::dp {
         std::map<int, Attribute *> m_connectedAttributes;
         Node *m_parentNode = nullptr;
 
-        std::optional<std::vector<u8>> m_outputData;
+        std::vector<u8> m_outputData;
+        std::vector<u8> m_defaultData;
 
         friend class Node;
         void setParentNode(Node *node) { this->m_parentNode = node; }

lib/libimhex/include/hex/data_processor/link.hpp

@@ -9,7 +9,7 @@ namespace hex::dp {
         Link(int from, int to);
 
         [[nodiscard]] int getId() const { return this->m_id; }
-        void setID(int id) { this->m_id = id; }
+        void setId(int id) { this->m_id = id; }
 
         [[nodiscard]] int getFromId() const { return this->m_from; }
         [[nodiscard]] int getToId() const { return this->m_to; }

lib/libimhex/include/hex/data_processor/node.hpp

@@ -31,7 +31,10 @@ namespace hex::dp {
         void setUnlocalizedName(const std::string &unlocalizedName) { this->m_unlocalizedName = unlocalizedName; }
 
         [[nodiscard]] const std::string &getUnlocalizedTitle() const { return this->m_unlocalizedTitle; }
+        void setUnlocalizedTitle(std::string title) { this->m_unlocalizedTitle = std::move(title); }
+
         [[nodiscard]] std::vector<Attribute> &getAttributes() { return this->m_attributes; }
+        [[nodiscard]] const std::vector<Attribute> &getAttributes() const { return this->m_attributes; }
 
         void setCurrentOverlay(prv::Overlay *overlay) {
             this->m_overlay = overlay;
@@ -40,8 +43,8 @@ namespace hex::dp {
         virtual void drawNode() { }
         virtual void process() = 0;
 
-        virtual void store(nlohmann::json &j) { hex::unused(j); }
-        virtual void load(nlohmann::json &j) { hex::unused(j); }
+        virtual void store(nlohmann::json &j) const { hex::unused(j); }
+        virtual void load(const nlohmann::json &j) { hex::unused(j); }
 
         struct NodeError {
             Node *node;
@@ -50,7 +53,7 @@ namespace hex::dp {
 
         void resetOutputData() {
             for (auto &attribute : this->m_attributes)
-                attribute.getOutputData().reset();
+                attribute.clearOutputData();
         }
 
         void resetProcessedInputs() {
@@ -70,6 +73,14 @@ namespace hex::dp {
                 Node::s_idCounter = id;
         }
 
+        const std::vector<u8>& getBufferOnInput(u32 index);
+        const i128& getIntegerOnInput(u32 index);
+        const long double& getFloatOnInput(u32 index);
+
+        void setBufferOnOutput(u32 index, const std::vector<u8> &data);
+        void setIntegerOnOutput(u32 index, i128 integer);
+        void setFloatOnOutput(u32 index, long double floatingPoint);
+
     private:
         int m_id;
         std::string m_unlocalizedTitle, m_unlocalizedName;
@@ -80,11 +91,15 @@ namespace hex::dp {
 
         static int s_idCounter;
 
-        Attribute *getConnectedInputAttribute(u32 index) {
+        Attribute& getAttribute(u32 index) {
             if (index >= this->getAttributes().size())
                 throw std::runtime_error("Attribute index out of bounds!");
 
-            auto &connectedAttribute = this->getAttributes()[index].getConnectedAttributes();
+            return this->getAttributes()[index];
+        }
+
+        Attribute *getConnectedInputAttribute(u32 index) {
+            const auto &connectedAttribute = this->getAttribute(index).getConnectedAttributes();
 
             if (connectedAttribute.empty())
                 return nullptr;
@@ -103,15 +118,14 @@ namespace hex::dp {
             throw NodeError { this, message };
         }
 
-        std::vector<u8> getBufferOnInput(u32 index);
-        i128 getIntegerOnInput(u32 index);
-        long double getFloatOnInput(u32 index);
-
-        void setBufferOnOutput(u32 index, const std::vector<u8> &data);
-        void setIntegerOnOutput(u32 index, i128 integer);
-        void setFloatOnOutput(u32 index, long double floatingPoint);
-
         void setOverlayData(u64 address, const std::vector<u8> &data);
+
+        void setAttributes(std::vector<Attribute> attributes) {
+            this->m_attributes = std::move(attributes);
+
+            for (auto &attr : this->m_attributes)
+                attr.setParentNode(this);
+        }
     };
 
 }

lib/libimhex/include/hex/helpers/crypto.hpp

@@ -16,7 +16,7 @@ namespace hex::crypt {
     void initialize();
     void exit();
 
-    u16 crc8(prv::Provider *&data, u64 offset, size_t size, u32 polynomial, u32 init, u32 xorout, bool reflectIn, bool reflectOut);
+    u8 crc8(prv::Provider *&data, u64 offset, size_t size, u32 polynomial, u32 init, u32 xorout, bool reflectIn, bool reflectOut);
     u16 crc16(prv::Provider *&data, u64 offset, size_t size, u32 polynomial, u32 init, u32 xorout, bool reflectIn, bool reflectOut);
     u32 crc32(prv::Provider *&data, u64 offset, size_t size, u32 polynomial, u32 init, u32 xorout, bool reflectIn, bool reflectOut);
 

lib/libimhex/include/hex/helpers/encoding_file.hpp

@@ -5,6 +5,7 @@
 #include <map>
 #include <string_view>
 #include <vector>
+#include <span>
 
 #include <hex/helpers/fs.hpp>
 #include <hex/helpers/file.hpp>
@@ -21,7 +22,7 @@ namespace hex {
         EncodingFile() = default;
         EncodingFile(Type type, const std::fs::path &path);
 
-        [[nodiscard]] std::pair<std::string_view, size_t> getEncodingFor(const std::vector<u8> &buffer) const;
+        [[nodiscard]] std::pair<std::string_view, size_t> getEncodingFor(std::span<u8> buffer) const;
         [[nodiscard]] size_t getLongestSequence() const { return this->m_longestSequence; }
 
         [[nodiscard]] bool valid() const { return this->m_valid; }

lib/libimhex/include/hex/helpers/fs.hpp

@@ -84,7 +84,7 @@ namespace hex::fs {
     };
 
     void setFileBrowserErrorCallback(const std::function<void()> &callback);
-    bool openFileBrowser(DialogMode mode, const std::vector<nfdfilteritem_t> &validExtensions, const std::function<void(std::fs::path)> &callback, const std::string &defaultPath = {});
+    bool openFileBrowser(DialogMode mode, const std::vector<nfdfilteritem_t> &validExtensions, const std::function<void(std::fs::path)> &callback, const std::string &defaultPath = {}, bool multiple = false);
 
     enum class ImHexPath : u32 {
         Patterns = 0,
@@ -101,6 +101,8 @@ namespace hex::fs {
         Scripts,
         Inspectors,
         Themes,
+        Libraries,
+        Nodes,
 
         END
     };

lib/libimhex/include/hex/helpers/intrinsics.hpp

@@ -2,10 +2,6 @@
 
 namespace hex {
 
-    [[noreturn]] inline void unreachable() {
-        __builtin_unreachable();
-    }
-
     inline void unused(auto && ... x) {
         ((void)x, ...);
     }

lib/libimhex/include/hex/helpers/magic.hpp

@@ -21,4 +21,6 @@ namespace hex::magic {
     std::string getMIMEType(const std::vector<u8> &data);
     std::string getMIMEType(prv::Provider *provider, size_t size = 100_KiB);
 
+    bool isValidMIMEType(const std::string &mimeType);
+
 }

lib/libimhex/include/hex/helpers/opengl.hpp

@@ -0,0 +1,209 @@
+#pragma once
+
+#include <hex.hpp>
+
+#include <hex/helpers/concepts.hpp>
+
+#include <cmath>
+#include <map>
+#include <span>
+#include <string>
+
+#include <imgui_impl_opengl3_loader.h>
+
+namespace hex::gl {
+
+    namespace {
+
+        template<typename T>
+        GLuint getType() {
+            if constexpr (std::is_same_v<T, float>)
+                return GL_FLOAT;
+            else if constexpr (std::is_same_v<T, u32>)
+                return GL_UNSIGNED_INT;
+            else
+                static_assert(hex::always_false<T>::value, "Unsupported type");
+        }
+
+    }
+
+    template<typename T, size_t Size>
+    class Vector {
+    public:
+        Vector() = default;
+        Vector(std::array<T, Size> data) : m_data(data) { }
+
+        T &operator[](size_t index) { return this->m_data[index]; }
+        const T &operator[](size_t index) const { return this->m_data[index]; }
+
+        T *data() { return this->m_data.data(); }
+        const T *data() const { return this->m_data.data(); }
+
+        [[nodiscard]] size_t size() const { return this->m_data.size(); }
+
+        auto operator+(const Vector<T, Size>& other) {
+            auto copy = *this;
+            for (size_t i = 0; i < Size; i++)
+                copy[i] += other[i];
+            return copy;
+        }
+
+        auto operator-(const Vector<T, Size>& other) {
+            auto copy = *this;
+            for (size_t i = 0; i < Size; i++)
+                copy[i] -= other[i];
+            return copy;
+        }
+
+        auto dot(const Vector<T, Size>& other) {
+            T result = 0;
+            for (size_t i = 0; i < Size; i++)
+                result += this->m_data[i] * other[i];
+            return result;
+        }
+
+        auto cross(const Vector<T, Size>& other) {
+            static_assert(Size == 3, "Cross product is only defined for 3D vectors");
+            return Vector<T, Size>({ this->m_data[1] * other[2] - this->m_data[2] * other[1], this->m_data[2] * other[0] - this->m_data[0] * other[2], this->m_data[0] * other[1] - this->m_data[1] * other[0] });
+        }
+
+        auto normalize() {
+            auto copy = *this;
+            auto length = std::sqrt(copy.dot(copy));
+            for (size_t i = 0; i < Size; i++)
+                copy[i] /= length;
+            return copy;
+        }
+
+    private:
+        std::array<T, Size> m_data;
+    };
+
+
+    class Shader {
+    public:
+        Shader() = default;
+        Shader(std::string_view vertexSource, std::string_view fragmentSource);
+        ~Shader();
+
+        Shader(const Shader&) = delete;
+        Shader(Shader&& other) noexcept;
+
+        Shader& operator=(const Shader&) = delete;
+        Shader& operator=(Shader&& other) noexcept;
+
+        void bind() const;
+        void unbind() const;
+
+        void setUniform(std::string_view name, const float &value);
+        void setUniform(std::string_view name, const Vector<float, 3> &value);
+
+    private:
+        void compile(GLuint shader, std::string_view source);
+        GLint getUniformLocation(std::string_view name);
+
+    private:
+        GLuint m_program = 0;
+        std::map<std::string, GLint> m_uniforms;
+    };
+
+    enum class BufferType {
+        Vertex = GL_ARRAY_BUFFER,
+        Index = GL_ELEMENT_ARRAY_BUFFER
+    };
+
+    template<typename T>
+    class Buffer {
+    public:
+        Buffer() = default;
+        Buffer(BufferType type, std::span<T> data);
+        ~Buffer();
+        Buffer(const Buffer&) = delete;
+        Buffer(Buffer&& other) noexcept;
+
+        Buffer& operator=(const Buffer&) = delete;
+        Buffer& operator=(Buffer&& other) noexcept;
+
+        void bind() const;
+        void unbind() const;
+
+        void draw() const;
+
+        size_t getSize() const;
+    private:
+        GLuint m_buffer = 0;
+        size_t m_size = 0;
+        GLuint m_type = 0;
+    };
+
+    extern template class Buffer<float>;
+    extern template class Buffer<u32>;
+
+    class VertexArray {
+    public:
+        VertexArray();
+        ~VertexArray();
+        VertexArray(const VertexArray&) = delete;
+        VertexArray(VertexArray&& other) noexcept;
+
+        VertexArray& operator=(const VertexArray&) = delete;
+        VertexArray& operator=(VertexArray&& other) noexcept;
+
+        template<typename T>
+        void addBuffer(u32 index, const Buffer<T> &buffer) const {
+            glEnableVertexAttribArray(index);
+            buffer.bind();
+            glVertexAttribPointer(index, 3, getType<T>(), GL_FALSE, 3 * sizeof(T), nullptr);
+            buffer.unbind();
+        }
+
+        void bind() const;
+        void unbind() const;
+
+    private:
+        GLuint m_array;
+    };
+
+    class Texture {
+    public:
+        Texture(u32 width, u32 height);
+        ~Texture();
+        Texture(const Texture&) = delete;
+        Texture(Texture&& other) noexcept;
+
+        Texture& operator=(const Texture&) = delete;
+        Texture& operator=(Texture&& other) noexcept;
+
+        void bind() const;
+        void unbind() const;
+
+        GLuint getTexture() const;
+        u32 getWidth() const;
+        u32 getHeight() const;
+
+        GLuint release();
+    private:
+        GLuint m_texture;
+        u32 m_width, m_height;
+    };
+
+    class FrameBuffer {
+    public:
+        FrameBuffer();
+        ~FrameBuffer();
+        FrameBuffer(const FrameBuffer&) = delete;
+        FrameBuffer(FrameBuffer&& other) noexcept;
+
+        FrameBuffer& operator=(const FrameBuffer&) = delete;
+        FrameBuffer& operator=(FrameBuffer&& other) noexcept;
+
+        void bind() const;
+        void unbind() const;
+
+        void attachTexture(const Texture &texture) const;
+
+    private:
+        GLuint m_frameBuffer, m_renderBuffer;
+    };
+
+}

lib/libimhex/include/hex/helpers/patches.hpp

@@ -4,14 +4,23 @@
 
 #include <map>
 #include <vector>
+#include <expected>
 
 namespace hex {
 
     using Patches = std::map<u64, u8>;
 
-    std::vector<u8> generateIPSPatch(const Patches &patches);
-    std::vector<u8> generateIPS32Patch(const Patches &patches);
+    enum class IPSError {
+        AddressOutOfRange,
+        PatchTooLarge,
+        InvalidPatchHeader,
+        InvalidPatchFormat,
+        MissingEOF
+    };
 
-    Patches loadIPSPatch(const std::vector<u8> &ipsPatch);
-    Patches loadIPS32Patch(const std::vector<u8> &ipsPatch);
+    std::expected<std::vector<u8>, IPSError> generateIPSPatch(const Patches &patches);
+    std::expected<std::vector<u8>, IPSError> generateIPS32Patch(const Patches &patches);
+
+    std::expected<Patches, IPSError> loadIPSPatch(const std::vector<u8> &ipsPatch);
+    std::expected<Patches, IPSError> loadIPS32Patch(const std::vector<u8> &ipsPatch);
 }

lib/libimhex/include/hex/helpers/stacktrace.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <hex.hpp>
+
+#include <string>
+#include <vector>
+
+namespace hex::stacktrace {
+
+    struct StackFrame {
+        std::string file;
+        std::string function;
+        u32 line;
+    };
+
+    void initialize();
+
+    std::vector<StackFrame> getStackTrace(); 
+
+}

lib/libimhex/include/hex/helpers/utils_macos.hpp

@@ -2,9 +2,12 @@
 
 #if defined(OS_MACOS)
 
-    #include <string>
+    extern "C" {
 
-    extern "C" void openWebpageMacos(const char *url);
-    extern "C" bool isMacosSystemDarkModeEnabled();
+        void openWebpageMacos(const char *url);
+        bool isMacosSystemDarkModeEnabled();
+        float getBackingScaleFactor();
+
+    }
 
 #endif

lib/libimhex/include/hex/providers/buffered_reader.hpp

@@ -14,7 +14,7 @@ namespace hex::prv {
     public:
         explicit BufferedReader(Provider *provider, size_t bufferSize = 16_MiB)
         : m_provider(provider), m_bufferAddress(provider->getBaseAddress()), m_maxBufferSize(bufferSize),
-          m_startAddress(provider->getBaseAddress()), m_endAddress(provider->getBaseAddress() + provider->getActualSize() - 1),
+          m_startAddress(provider->getBaseAddress()), m_endAddress(provider->getBaseAddress() + provider->getActualSize() - 1LLU),
           m_buffer(bufferSize) {
 
         }

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

@@ -64,7 +64,8 @@ namespace hex::prv {
         [[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 std::vector<std::pair<std::string, std::string>> getDataDescription() const = 0;
+        [[nodiscard]] virtual std::variant<std::string, i128> queryInformation(const std::string &category, const std::string &argument);
 
         [[nodiscard]] virtual bool open() = 0;
         virtual void close() = 0;

lib/libimhex/include/hex/ui/imgui_imhex_extensions.h

@@ -36,6 +36,7 @@ namespace ImGui {
         Texture() = default;
         Texture(const ImU8 *buffer, int size, int width = 0, int height = 0);
         explicit Texture(const char *path);
+        Texture(unsigned int texture, int width, int height);
         Texture(const Texture&) = delete;
         Texture(Texture&& other) noexcept;
 
@@ -48,7 +49,7 @@ namespace ImGui {
             return this->m_textureId != nullptr;
         }
 
-        [[nodiscard]] constexpr operator ImTextureID() {
+        [[nodiscard]] constexpr operator ImTextureID() const noexcept {
             return this->m_textureId;
         }
 
@@ -87,7 +88,7 @@ namespace ImGui {
     bool ToolBarButton(const char *symbol, ImVec4 color);
     bool IconButton(const char *symbol, ImVec4 color, ImVec2 size_arg = ImVec2(0, 0));
 
-    bool InputIntegerPrefix(const char* label, const char *prefix, void *value, ImGuiDataType type, ImGuiInputTextFlags flags = ImGuiInputTextFlags_None);
+    bool InputIntegerPrefix(const char* label, const char *prefix, void *value, ImGuiDataType type, const char *format, ImGuiInputTextFlags flags = ImGuiInputTextFlags_None);
     bool InputHexadecimal(const char* label, u32 *value, ImGuiInputTextFlags flags = ImGuiInputTextFlags_None);
     bool InputHexadecimal(const char* label, u64 *value, ImGuiInputTextFlags flags = ImGuiInputTextFlags_None);
 

lib/libimhex/include/hex/ui/view.hpp

@@ -39,7 +39,7 @@ namespace hex {
         static void showFatalPopup(const std::string &message);
         static void showYesNoQuestionPopup(const std::string &message, const std::function<void()> &yesCallback, const std::function<void()> &noCallback);
 
-        static void showFileChooserPopup(const std::vector<std::fs::path> &paths, const std::vector<nfdfilteritem_t> &validExtensions, const std::function<void(std::fs::path)> &callback);
+        static void showFileChooserPopup(const std::vector<std::fs::path> &paths, const std::vector<nfdfilteritem_t> &validExtensions, bool multiple, const std::function<void(std::fs::path)> &callback);
 
         [[nodiscard]] virtual bool hasViewMenuItemEntry() const;
         [[nodiscard]] virtual ImVec2 getMinSize() const;

lib/libimhex/include/hex/ui/widgets.hpp

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <hex.hpp>
+
+#include <vector>
+#include <string>
+#include <atomic>
+
+#include <hex/api/task.hpp>
+
+#include <imgui.h>
+#include <hex/ui/imgui_imhex_extensions.h>
+
+namespace hex::ui {
+
+    template<typename T>
+    class SearchableWidget {
+    public:
+        SearchableWidget(const std::function<bool(const std::string&, const T&)> &comparator) : m_comparator(comparator) {
+
+        }
+
+        const std::vector<const T*> &draw(const auto &entries) {
+            if (this->m_filteredEntries.empty() && this->m_searchBuffer.empty()) {
+                for (auto &entry : entries)
+                    this->m_filteredEntries.push_back(&entry);
+            }
+
+            if (ImGui::InputText("##search", this->m_searchBuffer)) {
+                this->m_pendingUpdate = true;
+            }
+
+            if (this->m_pendingUpdate && !this->m_updateTask.isRunning()) {
+                this->m_pendingUpdate = false;
+                this->m_filteredEntries.clear();
+                this->m_filteredEntries.reserve(entries.size());
+
+                this->m_updateTask = TaskManager::createBackgroundTask("Searching", [this, &entries, searchBuffer = this->m_searchBuffer](Task&) {
+                    for (auto &entry : entries) {
+                        if (searchBuffer.empty() || this->m_comparator(searchBuffer, entry))
+                            this->m_filteredEntries.push_back(&entry);
+                    }
+                });
+
+            }
+
+            return this->m_filteredEntries;
+        }
+
+        void reset() {
+            this->m_filteredEntries.clear();
+        }
+    private:
+        std::atomic<bool> m_pendingUpdate = false;
+        TaskHolder m_updateTask;
+
+        std::string m_searchBuffer;
+        std::vector<const T*> m_filteredEntries;
+        std::function<bool(const std::string&, const T&)> m_comparator;
+    };
+
+}

lib/libimhex/source/api/content_registry.cpp

@@ -299,6 +299,18 @@ namespace hex {
             });
         }
 
+
+        std::map<std::string, impl::Visualizer> &impl::getVisualizers() {
+            static std::map<std::string, impl::Visualizer> visualizers;
+
+            return visualizers;
+        }
+
+        void addVisualizer(const std::string &name, const VisualizerFunctionCallback &function, u32 parameterCount) {
+            log::debug("Registered new pattern visualizer function: {}", name);
+            impl::getVisualizers()[name] = impl::Visualizer { parameterCount, function };
+        }
+
         std::map<std::string, pl::api::PragmaHandler> &getPragmas() {
             static std::map<std::string, pl::api::PragmaHandler> pragmas;
 
@@ -400,6 +412,9 @@ namespace hex {
     namespace ContentRegistry::Language {
 
         void addLocalization(const nlohmann::json &data) {
+            if (!data.is_object())
+                return;
+
             if (!data.contains("code") || !data.contains("country") || !data.contains("language") || !data.contains("translations")) {
                 log::error("Localization data is missing required fields!");
                 return;

lib/libimhex/source/api/imhex_api.cpp

@@ -409,6 +409,10 @@ namespace hex {
         }
 
 
+        void setTaskBarProgress(TaskProgressState state, TaskProgressType type, u32 progress) {
+            EventManager::post<EventSetTaskBarIconState>(u32(state), u32(type), progress);
+        }
+
         const ProgramArguments &getProgramArguments() {
             return impl::s_programArguments;
         }

lib/libimhex/source/api/localization.cpp

@@ -9,7 +9,7 @@ namespace hex {
 
     LanguageDefinition::LanguageDefinition(std::map<std::string, std::string> &&entries) {
         for (const auto &[key, value] : entries) {
-            if (value == "***** MISSING TRANSLATION *****")
+            if (value.empty())
                 continue;
 
             this->m_entries.insert({ key, value });

lib/libimhex/source/api/project_file_manager.cpp

@@ -17,6 +17,13 @@ namespace hex {
     std::fs::path ProjectFile::s_currProjectPath;
 
     bool ProjectFile::load(const std::fs::path &filePath) {
+        auto originalPath = ProjectFile::s_currProjectPath;
+
+        ProjectFile::s_currProjectPath = filePath;
+        auto resetPath = SCOPE_GUARD {
+            ProjectFile::s_currProjectPath = originalPath;
+        };
+
         if (!fs::exists(filePath) || !fs::isRegularFile(filePath))
             return false;
         if (filePath.extension() != ".hexproj")
@@ -36,17 +43,20 @@ namespace hex {
                 return false;
         }
 
-        for (const auto &provider : ImHexApi::Provider::getProviders()) {
+        auto providers = auto(ImHexApi::Provider::getProviders());
+        for (const auto &provider : providers) {
             ImHexApi::Provider::remove(provider);
         }
 
         bool result = true;
         for (const auto &handler : ProjectFile::getHandlers()) {
             try {
-                if (!handler.load(handler.basePath, tar))
+                if (!handler.load(handler.basePath, tar)) {
+                    log::warn("Project file handler for {} failed to load {}", filePath.string(), handler.basePath.string());
                     result = false;
+                }
             } catch (std::exception &e) {
-                log::info("{}", e.what());
+                log::warn("Project file handler for {} failed to load {}: {}", filePath.string(), handler.basePath.string(), e.what());
                 result = false;
             }
 
@@ -72,15 +82,23 @@ namespace hex {
             }
         }
 
-        ProjectFile::s_currProjectPath = filePath;
+        resetPath.release();
+        EventManager::post<RequestUpdateWindowTitle>();
 
         return true;
     }
 
     bool ProjectFile::store(std::optional<std::fs::path> filePath) {
+        auto originalPath = ProjectFile::s_currProjectPath;
+
         if (!filePath.has_value())
             filePath = ProjectFile::s_currProjectPath;
 
+        ProjectFile::s_currProjectPath = filePath.value();
+        auto resetPath = SCOPE_GUARD {
+            ProjectFile::s_currProjectPath = originalPath;
+        };
+
         Tar tar(*filePath, Tar::Mode::Create);
         if (!tar.isValid())
             return false;
@@ -113,9 +131,8 @@ namespace hex {
             tar.write(MetadataPath, metadataContent);
         }
 
-        ProjectFile::s_currProjectPath = filePath.value();
-
         ImHexApi::Provider::resetDirty();
+        resetPath.release();
 
         return result;
     }
@@ -124,4 +141,16 @@ namespace hex {
         return !ProjectFile::s_currProjectPath.empty();
     }
 
+    void ProjectFile::clearPath() {
+        ProjectFile::s_currProjectPath.clear();
+    }
+
+    std::fs::path ProjectFile::getPath() {
+        return ProjectFile::s_currProjectPath;
+    }
+
+    void ProjectFile::setPath(const std::fs::path &path) {
+        ProjectFile::s_currProjectPath = path;
+    }
+
 }

lib/libimhex/source/api/theme_manager.cpp

@@ -52,7 +52,6 @@ namespace hex::api {
     void ThemeManager::changeTheme(std::string name) {
         if (!s_themes.contains(name)) {
             if (s_themes.empty()) {
-                hex::log::error("Theme '{}' does not exist and no other themes are available!", name);
                 return;
             } else {
                 const std::string &defaultTheme = s_themes.begin()->first;
@@ -115,4 +114,11 @@ namespace hex::api {
         return themeNames;
     }
 
+    void ThemeManager::reset() {
+        ThemeManager::s_themes.clear();
+        ThemeManager::s_styleHandlers.clear();
+        ThemeManager::s_themeHandlers.clear();
+        ThemeManager::s_imagePostfix.clear();
+    }
+
 }

lib/libimhex/source/data_processor/node.cpp

@@ -14,7 +14,7 @@ namespace hex::dp {
             attr.setParentNode(this);
     }
 
-    std::vector<u8> Node::getBufferOnInput(u32 index) {
+    const std::vector<u8>& Node::getBufferOnInput(u32 index) {
         auto attribute = this->getConnectedInputAttribute(index);
 
         if (attribute == nullptr)
@@ -28,58 +28,62 @@ namespace hex::dp {
 
         auto &outputData = attribute->getOutputData();
 
-        if (!outputData.has_value())
+        if (outputData.empty())
             throwNodeError("No data available at connected attribute");
 
-        return outputData.value();
+        return outputData;
     }
 
-    i128 Node::getIntegerOnInput(u32 index) {
+    const i128& Node::getIntegerOnInput(u32 index) {
         auto attribute = this->getConnectedInputAttribute(index);
 
-        if (attribute == nullptr)
-            throwNodeError(hex::format("Nothing connected to input '{0}'", LangEntry(this->m_attributes[index].getUnlocalizedName())));
+        auto &outputData = [&] -> std::vector<u8>& {
+            if (attribute != nullptr) {
+                if (attribute->getType() != Attribute::Type::Integer)
+                    throwNodeError("Tried to read integer from non-integer attribute");
 
-        if (attribute->getType() != Attribute::Type::Integer)
-            throwNodeError("Tried to read integer from non-integer attribute");
+                markInputProcessed(index);
+                attribute->getParentNode()->process();
 
-        markInputProcessed(index);
-        attribute->getParentNode()->process();
+                return attribute->getOutputData();
+            } else {
+                return this->getAttribute(index).getOutputData();
+            }
+        }();
 
-        auto &outputData = attribute->getOutputData();
-
-        if (!outputData.has_value())
+        if (outputData.empty())
             throwNodeError("No data available at connected attribute");
 
-        if (outputData->size() < sizeof(u64))
+        if (outputData.size() < sizeof(i128))
             throwNodeError("Not enough data provided for integer");
 
-        return *reinterpret_cast<i64 *>(outputData->data());
+        return *reinterpret_cast<i128 *>(outputData.data());
     }
 
-    long double Node::getFloatOnInput(u32 index) {
+    const long double& Node::getFloatOnInput(u32 index) {
         auto attribute = this->getConnectedInputAttribute(index);
 
-        if (attribute == nullptr)
-            throwNodeError(hex::format("Nothing connected to input '{0}'", LangEntry(this->m_attributes[index].getUnlocalizedName())));
+        auto &outputData = [&] -> std::vector<u8>& {
+            if (attribute != nullptr) {
+                if (attribute->getType() != Attribute::Type::Float)
+                    throwNodeError("Tried to read integer from non-float attribute");
 
-        if (attribute->getType() != Attribute::Type::Float)
-            throwNodeError("Tried to read float from non-float attribute");
+                markInputProcessed(index);
+                attribute->getParentNode()->process();
 
-        markInputProcessed(index);
-        attribute->getParentNode()->process();
+                return attribute->getOutputData();
+            } else {
+                return this->getAttribute(index).getOutputData();
+            }
+        }();
 
-        auto &outputData = attribute->getOutputData();
-
-        if (!outputData.has_value())
+        if (outputData.empty())
             throwNodeError("No data available at connected attribute");
 
-        if (outputData->size() < sizeof(long double))
+        if (outputData.size() < sizeof(long double))
             throwNodeError("Not enough data provided for float");
 
-        long double result = 0;
-        std::memcpy(&result, outputData->data(), sizeof(long double));
-        return result;
+        return *reinterpret_cast<long double *>(outputData.data());
     }
 
     void Node::setBufferOnOutput(u32 index, const std::vector<u8> &data) {

lib/libimhex/source/helpers/crypto.cpp

@@ -157,7 +157,7 @@ namespace hex::crypt {
         return crc.checksum();
     }
 
-    u16 crc8(prv::Provider *&data, u64 offset, size_t size, u32 polynomial, u32 init, u32 xorOut, bool reflectIn, bool reflectOut) {
+    u8 crc8(prv::Provider *&data, u64 offset, size_t size, u32 polynomial, u32 init, u32 xorOut, bool reflectIn, bool reflectOut) {
         return calcCrc<8>(data, offset, size, polynomial, init, xorOut, reflectIn, reflectOut);
     }
 

lib/libimhex/source/helpers/encoding_file.cpp

@@ -17,7 +17,7 @@ namespace hex {
         this->m_valid = true;
     }
 
-    std::pair<std::string_view, size_t> EncodingFile::getEncodingFor(const std::vector<u8> &buffer) const {
+    std::pair<std::string_view, size_t> EncodingFile::getEncodingFor(std::span<u8> buffer) const {
         for (auto riter = this->m_mapping.crbegin(); riter != this->m_mapping.crend(); ++riter) {
             const auto &[size, mapping] = *riter;
 

lib/libimhex/source/helpers/fs.cpp

@@ -1,10 +1,11 @@
 #include <hex/helpers/fs.hpp>
 
 #include <hex/api/content_registry.hpp>
+#include <hex/api/project_file_manager.hpp>
+
 #include <hex/helpers/fs_macos.hpp>
 #include <hex/helpers/file.hpp>
 #include <hex/helpers/intrinsics.hpp>
-#include <hex/helpers/net.hpp>
 #include <hex/helpers/utils.hpp>
 
 #include <xdg.hpp>
@@ -80,31 +81,44 @@ namespace hex::fs {
         s_fileBrowserErrorCallback = callback;
     }
 
-    bool openFileBrowser(DialogMode mode, const std::vector<nfdfilteritem_t> &validExtensions, const std::function<void(std::fs::path)> &callback, const std::string &defaultPath) {
+    bool openFileBrowser(DialogMode mode, const std::vector<nfdfilteritem_t> &validExtensions, const std::function<void(std::fs::path)> &callback, const std::string &defaultPath, bool multiple) {
         NFD::Init();
 
-        nfdchar_t *outPath = nullptr;
+        NFD::UniquePathU8 outPath;
+        NFD::UniquePathSet outPaths;
         nfdresult_t result;
         switch (mode) {
             case DialogMode::Open:
-                result = NFD::OpenDialog(outPath, validExtensions.data(), validExtensions.size(), defaultPath.c_str());
+                if (multiple)
+                    result = NFD::OpenDialogMultiple(outPaths, validExtensions.data(), validExtensions.size(), defaultPath.empty() ? nullptr : defaultPath.c_str());
+                else
+                    result = NFD::OpenDialog(outPath, validExtensions.data(), validExtensions.size(), defaultPath.empty() ? nullptr : defaultPath.c_str());
                 break;
             case DialogMode::Save:
-                result = NFD::SaveDialog(outPath, validExtensions.data(), validExtensions.size(), defaultPath.c_str());
+                result = NFD::SaveDialog(outPath, validExtensions.data(), validExtensions.size(), defaultPath.empty() ? nullptr : defaultPath.c_str());
                 break;
             case DialogMode::Folder:
-                result = NFD::PickFolder(outPath, defaultPath.c_str());
+                result = NFD::PickFolder(outPath, defaultPath.empty() ? nullptr : defaultPath.c_str());
                 break;
             default:
-                hex::unreachable();
+                std::unreachable();
         }
 
         if (result == NFD_OKAY){
             if(outPath != nullptr) {
-                callback(reinterpret_cast<char8_t*>(outPath));
-                NFD::FreePath(outPath);
+                callback(reinterpret_cast<char8_t*>(outPath.get()));
             }
-        } else if (result==NFD_ERROR) {
+            if (outPaths != nullptr) {
+                nfdpathsetsize_t numPaths = 0;
+                if (NFD::PathSet::Count(outPaths, numPaths) == NFD_OKAY) {
+                    for (size_t i = 0; i < numPaths; i++) {
+                        NFD::UniquePathSetPath path;
+                        if (NFD::PathSet::GetPath(outPaths, i, path) == NFD_OKAY)
+                            callback(reinterpret_cast<char8_t*>(path.get()));
+                    }
+                }
+            }
+        } else if (result == NFD_ERROR) {
             if (s_fileBrowserErrorCallback != nullptr)
                     s_fileBrowserErrorCallback();
         }
@@ -166,6 +180,10 @@ namespace hex::fs {
         auto additionalDirs = ImHexApi::System::getAdditionalFolderPaths();
         std::copy(additionalDirs.begin(), additionalDirs.end(), std::back_inserter(paths));
 
+        if (ProjectFile::hasPath()) {
+            paths.push_back(ProjectFile::getPath().parent_path());
+        }
+
         return paths;
     }
 
@@ -226,6 +244,9 @@ namespace hex::fs {
             case ImHexPath::Plugins:
                 result = appendPath(getPluginPaths(), "plugins");
                 break;
+            case ImHexPath::Libraries:
+                result = appendPath(getPluginPaths(), "lib");
+                break;
             case ImHexPath::Resources:
                 result = appendPath(getDataPaths(), "resources");
                 break;
@@ -250,6 +271,9 @@ namespace hex::fs {
             case ImHexPath::Inspectors:
                 result = appendPath(getDefaultPaths(ImHexPath::Scripts), "inspectors");
                 break;
+            case ImHexPath::Nodes:
+                result = appendPath(getDefaultPaths(ImHexPath::Scripts), "nodes");
+                break;
             case ImHexPath::Themes:
                 result = appendPath(getDataPaths(), "themes");
                 break;

lib/libimhex/source/helpers/magic.cpp

@@ -96,4 +96,18 @@ namespace hex::magic {
         return getMIMEType(buffer);
     }
 
+    bool isValidMIMEType(const std::string &mimeType) {
+        // MIME types always contain a slash
+        if (!mimeType.contains("/"))
+            return false;
+
+        // The MIME type "application/octet-stream" is a fallback type for arbitrary binary data.
+        // Specifying this in a pattern would make it get suggested for every single unknown binary that's being loaded.
+        // We don't want that, so we ignore it here
+        if (mimeType == "application/octet-stream")
+            return false;
+
+        return true;
+    }
+
 }

lib/libimhex/source/helpers/opengl.cpp

@@ -0,0 +1,291 @@
+#include <hex/helpers/opengl.hpp>
+
+#include <hex/helpers/utils.hpp>
+#include <hex/helpers/logger.hpp>
+
+namespace hex::gl {
+
+    Shader::Shader(std::string_view vertexSource, std::string_view fragmentSource) {
+        auto vertexShader = glCreateShader(GL_VERTEX_SHADER);
+        this->compile(vertexShader, vertexSource);
+
+        auto fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
+        this->compile(fragmentShader, fragmentSource);
+
+        ON_SCOPE_EXIT { glDeleteShader(vertexShader); glDeleteShader(fragmentShader); };
+
+        this->m_program = glCreateProgram();
+
+        glAttachShader(this->m_program, vertexShader);
+        glAttachShader(this->m_program, fragmentShader);
+        glLinkProgram(this->m_program);
+
+        int result = false;
+        glGetProgramiv(this->m_program, GL_LINK_STATUS, &result);
+        if (!result) {
+            std::vector<char> log(512);
+            glGetShaderInfoLog(this->m_program, log.size(), nullptr, log.data());
+            log::error("Failed to link shader: {}", log.data());
+        }
+    }
+
+    Shader::~Shader() {
+        if (this->m_program != 0)
+            glDeleteProgram(this->m_program);
+    }
+
+    Shader::Shader(Shader &&other) noexcept {
+        this->m_program = other.m_program;
+        other.m_program = 0;
+    }
+
+    Shader& Shader::operator=(Shader &&other) noexcept {
+        this->m_program = other.m_program;
+        other.m_program = 0;
+        return *this;
+    }
+
+    void Shader::bind() const {
+        glUseProgram(this->m_program);
+    }
+
+    void Shader::unbind() const {
+        glUseProgram(0);
+    }
+
+    void Shader::setUniform(std::string_view name, const float &value) {
+        glUniform1f(getUniformLocation(name), value);
+    }
+
+    void Shader::setUniform(std::string_view name, const Vector<float, 3> &value) {
+        glUniform3f(getUniformLocation(name), value[0], value[1], value[2]);
+    }
+
+    GLint Shader::getUniformLocation(std::string_view name) {
+        auto uniform = this->m_uniforms.find(name.data());
+        if (uniform == this->m_uniforms.end()) {
+            auto location = glGetUniformLocation(this->m_program, name.data());
+            if (location == -1) {
+                log::warn("Uniform '{}' not found in shader", name);
+                return -1;
+            }
+
+            this->m_uniforms[name.data()] = location;
+            uniform = this->m_uniforms.find(name.data());
+        }
+
+        return uniform->second;
+    }
+
+    void Shader::compile(GLuint shader, std::string_view source) {
+        auto sourcePtr = source.data();
+
+        glShaderSource(shader, 1, &sourcePtr, nullptr);
+        glCompileShader(shader);
+
+        int result = false;
+        glGetShaderiv(shader, GL_COMPILE_STATUS, &result);
+        if (!result) {
+            std::vector<char> log(512);
+            glGetShaderInfoLog(shader, log.size(), nullptr, log.data());
+            log::error("Failed to compile shader: {}", log.data());
+        }
+    }
+
+
+    template<typename T>
+    Buffer<T>::Buffer(BufferType type, std::span<T> data) : m_size(data.size()), m_type(GLuint(type)) {
+        glGenBuffers(1, &this->m_buffer);
+        glBindBuffer(this->m_type, this->m_buffer);
+        glBufferData(this->m_type, data.size_bytes(), data.data(), GL_STATIC_DRAW);
+        glBindBuffer(this->m_type, 0);
+    }
+
+    template<typename T>
+    Buffer<T>::~Buffer() {
+        glDeleteBuffers(1, &this->m_buffer);
+    }
+
+    template<typename T>
+    Buffer<T>::Buffer(Buffer<T> &&other) noexcept {
+        this->m_buffer = other.m_buffer;
+        this->m_size = other.m_size;
+        this->m_type = other.m_type;
+        other.m_buffer = -1;
+    }
+
+    template<typename T>
+    Buffer<T>& Buffer<T>::operator=(Buffer<T> &&other) noexcept {
+        this->m_buffer = other.m_buffer;
+        this->m_size = other.m_size;
+        this->m_type = other.m_type;
+        other.m_buffer = -1;
+        return *this;
+    }
+
+    template<typename T>
+    void Buffer<T>::bind() const {
+        glBindBuffer(this->m_type, this->m_buffer);
+    }
+
+    template<typename T>
+    void Buffer<T>::unbind() const {
+        glBindBuffer(this->m_type, 0);
+    }
+
+    template<typename T>
+    size_t Buffer<T>::getSize() const {
+        return this->m_size;
+    }
+
+    template<typename T>
+    void Buffer<T>::draw() const {
+        switch (this->m_type) {
+            case GL_ARRAY_BUFFER:
+                glDrawArrays(GL_TRIANGLES, 0, this->m_size);
+                break;
+            case GL_ELEMENT_ARRAY_BUFFER:
+                glDrawElements(GL_TRIANGLES, this->m_size, getType<T>(), nullptr);
+                break;
+        }
+    }
+
+    template class Buffer<float>;
+    template class Buffer<u32>;
+
+
+    VertexArray::VertexArray() {
+        glGenVertexArrays(1, &this->m_array);
+    }
+
+    VertexArray::~VertexArray() {
+        glDeleteVertexArrays(1, &this->m_array);
+    }
+
+    VertexArray::VertexArray(VertexArray &&other) noexcept {
+        this->m_array = other.m_array;
+        other.m_array = -1;
+    }
+
+    VertexArray& VertexArray::operator=(VertexArray &&other) noexcept {
+        this->m_array = other.m_array;
+        other.m_array = -1;
+        return *this;
+    }
+
+    void VertexArray::bind() const {
+        glBindVertexArray(this->m_array);
+    }
+
+    void VertexArray::unbind() const {
+        glBindVertexArray(0);
+    }
+
+
+    Texture::Texture(u32 width, u32 height) : m_texture(0), m_width(width), m_height(height) {
+        glGenTextures(1, &this->m_texture);
+        glBindTexture(GL_TEXTURE_2D, this->m_texture);
+
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+        glBindTexture(GL_TEXTURE_2D, 0);
+    }
+
+    Texture::~Texture() {
+        if (this->m_texture != 0)
+            glDeleteTextures(1, &this->m_texture);
+    }
+
+    Texture::Texture(Texture &&other) noexcept {
+        this->m_texture = other.m_texture;
+        other.m_texture = -1;
+    }
+
+    Texture& Texture::operator=(Texture &&other) noexcept {
+        this->m_texture = other.m_texture;
+        other.m_texture = -1;
+        return *this;
+    }
+
+    void Texture::bind() const {
+        glBindTexture(GL_TEXTURE_2D, this->m_texture);
+    }
+
+    void Texture::unbind() const {
+        glBindTexture(GL_TEXTURE_2D, 0);
+    }
+
+    GLuint Texture::getTexture() const {
+        return this->m_texture;
+    }
+
+    u32 Texture::getWidth() const {
+        return this->m_width;
+    }
+
+    u32 Texture::getHeight() const {
+        return this->m_height;
+    }
+
+    GLuint Texture::release() {
+        auto copy = this->m_texture;
+        this->m_texture = -1;
+
+        return copy;
+    }
+
+
+    FrameBuffer::FrameBuffer() {
+        glGenFramebuffers(1, &this->m_frameBuffer);
+        glBindFramebuffer(GL_FRAMEBUFFER, this->m_frameBuffer);
+
+        glGenRenderbuffers(1, &this->m_renderBuffer);
+        glBindRenderbuffer(GL_RENDERBUFFER, this->m_renderBuffer);
+        glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 1280, 720);
+        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, this->m_renderBuffer);
+
+        glBindRenderbuffer(GL_RENDERBUFFER, 0);
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    }
+
+    FrameBuffer::~FrameBuffer() {
+        glDeleteFramebuffers(1, &this->m_frameBuffer);
+        glDeleteRenderbuffers(1, &this->m_renderBuffer);
+    }
+
+    FrameBuffer::FrameBuffer(FrameBuffer &&other) noexcept {
+        this->m_frameBuffer = other.m_frameBuffer;
+        other.m_frameBuffer = -1;
+        this->m_renderBuffer = other.m_renderBuffer;
+        other.m_renderBuffer = -1;
+    }
+
+    FrameBuffer& FrameBuffer::operator=(FrameBuffer &&other) noexcept {
+        this->m_frameBuffer = other.m_frameBuffer;
+        other.m_frameBuffer = -1;
+        this->m_renderBuffer = other.m_renderBuffer;
+        other.m_renderBuffer = -1;
+        return *this;
+    }
+
+    void FrameBuffer::bind() const {
+        glBindFramebuffer(GL_FRAMEBUFFER, this->m_frameBuffer);
+    }
+
+    void FrameBuffer::unbind() const {
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    }
+
+    void FrameBuffer::attachTexture(const Texture &texture) const {
+        glBindFramebuffer(GL_FRAMEBUFFER, this->m_frameBuffer);
+        texture.bind();
+
+        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture.getTexture(), 0);
+
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    }
+
+}

lib/libimhex/source/helpers/patches.cpp

@@ -18,7 +18,7 @@ namespace hex {
         std::memcpy((&buffer.back() - sizeof(T)) + 1, &bytes, sizeof(T));
     }
 
-    std::vector<u8> generateIPSPatch(const Patches &patches) {
+    std::expected<std::vector<u8>, IPSError> generateIPSPatch(const Patches &patches) {
         std::vector<u8> result;
 
         pushStringBack(result, "PATCH");
@@ -42,8 +42,10 @@ namespace hex {
             } else {
                 bytes.push_back(values[i]);
 
-                if (bytes.size() > 0xFFFF || startAddress > 0xFF'FFFF)
-                    return {};
+                if (bytes.size() > 0xFFFF)
+                    return std::unexpected(IPSError::PatchTooLarge);
+                if (startAddress > 0xFFFF'FFFF)
+                    return std::unexpected(IPSError::AddressOutOfRange);
 
                 u32 address       = startAddress.value();
                 auto addressBytes = reinterpret_cast<u8 *>(&address);
@@ -66,7 +68,7 @@ namespace hex {
         return result;
     }
 
-    std::vector<u8> generateIPS32Patch(const Patches &patches) {
+    std::expected<std::vector<u8>, IPSError> generateIPS32Patch(const Patches &patches) {
         std::vector<u8> result;
 
         pushStringBack(result, "IPS32");
@@ -90,8 +92,10 @@ namespace hex {
             } else {
                 bytes.push_back(values[i]);
 
-                if (bytes.size() > 0xFFFF || startAddress > 0xFFFF'FFFF)
-                    return {};
+                if (bytes.size() > 0xFFFF)
+                    return std::unexpected(IPSError::PatchTooLarge);
+                if (startAddress > 0xFFFF'FFFF)
+                    return std::unexpected(IPSError::AddressOutOfRange);
 
                 u32 address       = startAddress.value();
                 auto addressBytes = reinterpret_cast<u8 *>(&address);
@@ -115,12 +119,12 @@ namespace hex {
         return result;
     }
 
-    Patches loadIPSPatch(const std::vector<u8> &ipsPatch) {
+    std::expected<Patches, IPSError> loadIPSPatch(const std::vector<u8> &ipsPatch) {
         if (ipsPatch.size() < (5 + 3))
-            return {};
+            return std::unexpected(IPSError::InvalidPatchHeader);
 
         if (std::memcmp(ipsPatch.data(), "PATCH", 5) != 0)
-            return {};
+            return std::unexpected(IPSError::InvalidPatchHeader);
 
         Patches result;
         bool foundEOF = false;
@@ -135,7 +139,7 @@ namespace hex {
             // Handle normal record
             if (size > 0x0000) {
                 if (ipsOffset + size > ipsPatch.size() - 3)
-                    return {};
+                    return std::unexpected(IPSError::InvalidPatchFormat);
 
                 for (u16 i = 0; i < size; i++)
                     result[offset + i] = ipsPatch[ipsOffset + i];
@@ -144,7 +148,7 @@ namespace hex {
             // Handle RLE record
             else {
                 if (ipsOffset + 3 > ipsPatch.size() - 3)
-                    return {};
+                    return std::unexpected(IPSError::InvalidPatchFormat);
 
                 u16 rleSize = ipsPatch[ipsOffset + 0] | (ipsPatch[ipsOffset + 1] << 8);
 
@@ -156,22 +160,22 @@ namespace hex {
                 ipsOffset += 1;
             }
 
-            if (std::memcmp(ipsPatch.data(), "EOF", 3) == 0)
+            if (std::memcmp(ipsPatch.data() + ipsOffset, "EOF", 3) == 0)
                 foundEOF = true;
         }
 
         if (foundEOF)
             return result;
         else
-            return {};
+            return std::unexpected(IPSError::MissingEOF);
     }
 
-    Patches loadIPS32Patch(const std::vector<u8> &ipsPatch) {
+    std::expected<Patches, IPSError> loadIPS32Patch(const std::vector<u8> &ipsPatch) {
         if (ipsPatch.size() < (5 + 4))
-            return {};
+            return std::unexpected(IPSError::InvalidPatchHeader);
 
         if (std::memcmp(ipsPatch.data(), "IPS32", 5) != 0)
-            return {};
+            return std::unexpected(IPSError::InvalidPatchHeader);
 
         Patches result;
         bool foundEEOF = false;
@@ -186,7 +190,7 @@ namespace hex {
             // Handle normal record
             if (size > 0x0000) {
                 if (ipsOffset + size > ipsPatch.size() - 3)
-                    return {};
+                    return std::unexpected(IPSError::InvalidPatchFormat);
 
                 for (u16 i = 0; i < size; i++)
                     result[offset + i] = ipsPatch[ipsOffset + i];
@@ -195,7 +199,7 @@ namespace hex {
             // Handle RLE record
             else {
                 if (ipsOffset + 3 > ipsPatch.size() - 3)
-                    return {};
+                    return std::unexpected(IPSError::InvalidPatchFormat);
 
                 u16 rleSize = ipsPatch[ipsOffset + 0] | (ipsPatch[ipsOffset + 1] << 8);
 
@@ -207,14 +211,14 @@ namespace hex {
                 ipsOffset += 1;
             }
 
-            if (std::memcmp(ipsPatch.data(), "EEOF", 4) == 0)
+            if (std::memcmp(ipsPatch.data() + ipsOffset, "EEOF", 4) == 0)
                 foundEEOF = true;
         }
 
         if (foundEEOF)
             return result;
         else
-            return {};
+            return std::unexpected(IPSError::MissingEOF);
     }
 
 }

lib/libimhex/source/helpers/stacktrace.cpp

@@ -0,0 +1,183 @@
+#include <hex/helpers/stacktrace.hpp>
+#include <hex/helpers/fs.hpp>
+
+#if defined(OS_WINDOWS)
+
+    #include <windows.h>
+    #include <dbghelp.h>
+    #include <llvm/Demangle/Demangle.h>
+
+    namespace hex::stacktrace {
+
+        void initialize() {
+
+        }
+
+        std::vector<StackFrame> getStackTrace() {
+            std::vector<StackFrame> stackTrace;
+
+            HANDLE process = GetCurrentProcess();
+            HANDLE thread = GetCurrentThread();
+
+            CONTEXT context;
+            memset(&context, 0, sizeof(CONTEXT));
+            context.ContextFlags = CONTEXT_FULL;
+            RtlCaptureContext(&context);
+
+            SymSetOptions(SYMOPT_UNDNAME | SYMOPT_LOAD_LINES);
+            SymInitialize(process, nullptr, true);
+
+            DWORD image;
+            STACKFRAME64 stackFrame;
+            ZeroMemory(&stackFrame, sizeof(STACKFRAME64));
+
+            image = IMAGE_FILE_MACHINE_AMD64;
+            stackFrame.AddrPC.Offset = context.Rip;
+            stackFrame.AddrPC.Mode = AddrModeFlat;
+            stackFrame.AddrFrame.Offset = context.Rsp;
+            stackFrame.AddrFrame.Mode = AddrModeFlat;
+            stackFrame.AddrStack.Offset = context.Rsp;
+            stackFrame.AddrStack.Mode = AddrModeFlat;
+
+            while (true) {
+
+                if (!StackWalk64(
+                        image, process, thread,
+                        &stackFrame, &context, nullptr,
+                        SymFunctionTableAccess64, SymGetModuleBase64, nullptr))
+                    break;
+
+                char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME * sizeof(TCHAR)];
+                auto symbol = (PSYMBOL_INFO)buffer;
+                symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
+                symbol->MaxNameLen = MAX_SYM_NAME;
+
+                DWORD64 displacementSymbol = 0;
+                const char* symbolName;
+                if (SymFromAddr(process, stackFrame.AddrPC.Offset, &displacementSymbol, symbol)) {
+                    symbolName = symbol->Name;
+                } else {
+                    symbolName = "??";
+                }
+
+                IMAGEHLP_LINE64 line;
+                line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
+
+                DWORD displacementLine = 0;
+                u32 lineNumber;
+                const char* fileName;
+
+                if (SymGetLineFromAddr64(process, stackFrame.AddrPC.Offset, &displacementLine, &line)) {
+                    lineNumber = line.LineNumber;
+                    fileName = line.FileName;
+                } else {
+                    lineNumber = 0;
+                    fileName = "??";
+                }
+
+                std::string demangledName;
+                if (auto variant1 = llvm::demangle(symbolName); variant1 != symbolName)
+                    demangledName = variant1;
+                else if (auto variant2 = llvm::demangle(std::string("_") + symbolName); variant2 != std::string("_") + symbolName)
+                    demangledName = variant2;
+                else
+                    demangledName = symbolName;
+
+                stackTrace.push_back(StackFrame { fileName, demangledName, lineNumber });
+
+            }
+
+            SymCleanup(process);
+
+            return stackTrace;
+        }
+
+    }
+
+#elif defined(HEX_HAS_EXECINFO)
+
+    #if __has_include(BACKTRACE_HEADER)
+
+        #include BACKTRACE_HEADER
+        #include <llvm/Demangle/Demangle.h>
+        #include <hex/helpers/logger.hpp>
+        #include <hex/helpers/utils.hpp>
+
+        namespace hex::stacktrace {
+
+            void initialize() {
+
+            }
+
+            std::vector<StackFrame> getStackTrace() {
+                static std::vector<StackFrame> result;
+
+                std::array<void*, 128> addresses;
+                auto count = backtrace(addresses.data(), addresses.size());
+                auto functions = backtrace_symbols(addresses.data(), count);
+
+                for (i32 i = 0; i < count; i++)
+                    result.push_back(StackFrame { "", functions[i], 0 });
+
+                return result;
+            }
+
+        }
+    #endif
+
+#elif defined(HEX_HAS_BACKTRACE)
+
+    #if __has_include(BACKTRACE_HEADER)
+
+        #include BACKTRACE_HEADER
+        #include <llvm/Demangle/Demangle.h>
+        #include <hex/helpers/logger.hpp>
+        #include <hex/helpers/utils.hpp>
+
+        namespace hex::stacktrace {
+
+            static struct backtrace_state *s_backtraceState;
+
+
+            void initialize() {
+                if (auto executablePath = fs::getExecutablePath(); executablePath.has_value()) {
+                    static std::string path = executablePath->string();
+                    s_backtraceState = backtrace_create_state(path.c_str(), 1, [](void *, const char *msg, int) { log::error("{}", msg); }, nullptr);
+                }
+            }
+
+            std::vector<StackFrame> getStackTrace() {
+                static std::vector<StackFrame> result;
+
+                result.clear();
+                if (s_backtraceState != nullptr) {
+                    backtrace_full(s_backtraceState, 0, [](void *, uintptr_t, const char *fileName, int lineNumber, const char *function) -> int {
+                        if (fileName == nullptr)
+                            fileName = "??";
+                        if (function == nullptr)
+                            function = "??";
+
+                        result.push_back(StackFrame { std::fs::path(fileName).filename().string(), llvm::demangle(function), u32(lineNumber) });
+
+                        return 0;
+                    }, nullptr, nullptr);
+
+                }
+
+                return result;
+            }
+
+        }
+
+    #endif
+
+#else
+
+    namespace hex::stacktrace {
+
+        void initialize() { }
+        std::vector<StackFrame> getStackTrace() { return { }; }
+
+    }
+    
+#endif

lib/libimhex/source/helpers/utils.cpp

@@ -276,8 +276,7 @@ namespace hex {
     }
 
     void openWebpage(std::string url) {
-
-        if (url.find("://") == std::string::npos)
+        if (!url.contains("://"))
             url = "https://" + url;
 
         #if defined(OS_WINDOWS)

lib/libimhex/source/helpers/utils_macos.m

@@ -4,6 +4,7 @@
     #include <ApplicationServices/ApplicationServices.h>
     #include <Foundation/NSUserDefaults.h>
     #include <Foundation/Foundation.h>
+    #include <AppKit/NSScreen.h>
 
     #include <string.h>
     #include <stdlib.h>
@@ -25,4 +26,8 @@
         }
     }
 
+    float getBackingScaleFactor(void) {
+        return [[NSScreen mainScreen] backingScaleFactor];
+    }
+
 #endif

lib/libimhex/source/providers/provider.cpp

@@ -8,6 +8,8 @@
 #include <map>
 #include <optional>
 
+#include <hex/helpers/magic.hpp>
+
 namespace hex::prv {
 
     u32 Provider::s_idCounter = 0;
@@ -301,4 +303,16 @@ namespace hex::prv {
             s_idCounter = id + 1;
     }
 
+
+    [[nodiscard]] std::variant<std::string, i128> Provider::queryInformation(const std::string &category, const std::string &) {
+        if (category == "mime")
+            return magic::getMIMEType(this);
+        else if (category == "description")
+            return magic::getDescription(this);
+        else if (category == "provider_type")
+            return this->getTypeName();
+        else
+            return 0;
+    }
+
 }

lib/libimhex/source/ui/imgui_imhex_extensions.cpp

@@ -69,7 +69,12 @@ namespace ImGui {
         this->m_textureId = reinterpret_cast<ImTextureID>(static_cast<intptr_t>(texture));
     }
 
+    Texture::Texture(unsigned int texture, int width, int height) : m_textureId(reinterpret_cast<ImTextureID>(static_cast<intptr_t>(texture))), m_width(width), m_height(height) {
+
+    }
+
     Texture::Texture(Texture&& other) noexcept {
+        glDeleteTextures(1, reinterpret_cast<GLuint*>(&this->m_textureId));
         this->m_textureId = other.m_textureId;
         this->m_width = other.m_width;
         this->m_height = other.m_height;
@@ -78,6 +83,7 @@ namespace ImGui {
     }
 
     Texture& Texture::operator=(Texture&& other) noexcept {
+        glDeleteTextures(1, reinterpret_cast<GLuint*>(&this->m_textureId));
         this->m_textureId = other.m_textureId;
         this->m_width = other.m_width;
         this->m_height = other.m_height;
@@ -507,7 +513,7 @@ namespace ImGui {
         return pressed;
     }
 
-    bool InputIntegerPrefix(const char *label, const char *prefix, void *value, ImGuiDataType type, ImGuiInputTextFlags flags) {
+    bool InputIntegerPrefix(const char *label, const char *prefix, void *value, ImGuiDataType type, const char *format, ImGuiInputTextFlags flags) {
         auto window             = ImGui::GetCurrentWindow();
         const ImGuiID id        = window->GetID(label);
         const ImGuiStyle &style = GImGui->Style;
@@ -520,11 +526,11 @@ namespace ImGui {
         ImGui::SetCursorPosX(ImGui::GetCursorPosX() + frame_size.x);
 
         char buf[64];
-        DataTypeFormatString(buf, IM_ARRAYSIZE(buf), type, value, "%llX");
+        DataTypeFormatString(buf, IM_ARRAYSIZE(buf), type, value, format);
 
         bool value_changed = false;
         if (InputTextEx(label, nullptr, buf, IM_ARRAYSIZE(buf), ImVec2(CalcItemWidth() - frame_size.x, label_size.y + style.FramePadding.y * 2.0f), flags))
-            value_changed = DataTypeApplyFromText(buf, ImGuiDataType_U64, value, "%llX");
+            value_changed = DataTypeApplyFromText(buf, type, value, format);
 
         if (value_changed)
             MarkItemEdited(GImGui->LastItemData.ID);
@@ -540,11 +546,11 @@ namespace ImGui {
     }
 
     bool InputHexadecimal(const char *label, u32 *value, ImGuiInputTextFlags flags) {
-        return InputIntegerPrefix(label, "0x", value, ImGuiDataType_U32, flags | ImGuiInputTextFlags_CharsHexadecimal);
+        return InputIntegerPrefix(label, "0x", value, ImGuiDataType_U32, "%lX", flags | ImGuiInputTextFlags_CharsHexadecimal);
     }
 
     bool InputHexadecimal(const char *label, u64 *value, ImGuiInputTextFlags flags) {
-        return InputIntegerPrefix(label, "0x", value, ImGuiDataType_U64, flags | ImGuiInputTextFlags_CharsHexadecimal);
+        return InputIntegerPrefix(label, "0x", value, ImGuiDataType_U64, "%llX", flags | ImGuiInputTextFlags_CharsHexadecimal);
     }
 
     void SmallProgressBar(float fraction, float yOffset) {

lib/libimhex/source/ui/view.cpp

@@ -34,13 +34,13 @@ namespace hex {
 
     }
 
-    void View::showFileChooserPopup(const std::vector<std::fs::path> &paths, const std::vector<nfdfilteritem_t> &validExtensions, const std::function<void(std::fs::path)> &callback) {
+    void View::showFileChooserPopup(const std::vector<std::fs::path> &paths, const std::vector<nfdfilteritem_t> &validExtensions, bool multiple, const std::function<void(std::fs::path)> &callback) {
         if (paths.empty()) {
             fs::openFileBrowser(fs::DialogMode::Open, validExtensions, [callback](const auto &path) {
                 callback(path);
-            });
+            }, {}, multiple);
         } else {
-            EventManager::post<RequestShowFileChooserPopup>(paths, validExtensions, callback);
+            EventManager::post<RequestShowFileChooserPopup>(paths, validExtensions, callback, multiple);
         }
     }
 
@@ -49,7 +49,7 @@ namespace hex {
     }
 
     ImVec2 View::getMinSize() const {
-        return scaled(ImVec2(10, 10));
+        return scaled(ImVec2(300, 400));
     }
 
     ImVec2 View::getMaxSize() const {

main/source/init/splash_window.cpp

@@ -2,6 +2,7 @@
 
 #include <hex/api/imhex_api.hpp>
 #include <hex/helpers/utils.hpp>
+#include <hex/helpers/utils_macos.hpp>
 #include <hex/helpers/fmt.hpp>
 #include <hex/helpers/logger.hpp>
 
@@ -89,7 +90,7 @@ namespace hex::init {
     }
 
     bool WindowSplash::loop() {
-        auto splash                  = romfs::get("splash.png");
+        auto splash = romfs::get("splash.png");
         ImGui::Texture splashTexture = ImGui::Texture(reinterpret_cast<const ImU8 *>(splash.data()), splash.size());
 
         if (!splashTexture.isValid()) {
@@ -128,9 +129,9 @@ namespace hex::init {
             }
 
             ImGui::Render();
-            int display_w, display_h;
-            glfwGetFramebufferSize(this->m_window, &display_w, &display_h);
-            glViewport(0, 0, display_w, display_h);
+            int displayWidth, displayHeight;
+            glfwGetFramebufferSize(this->m_window, &displayWidth, &displayHeight);
+            glViewport(0, 0, displayWidth, displayHeight);
             glClearColor(0.00F, 0.00F, 0.00F, 0.00F);
             glClear(GL_COLOR_BUFFER_BIT);
             ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
@@ -205,7 +206,7 @@ namespace hex::init {
                 meanScale = 1.0F;
 
             #if defined(OS_MACOS)
-                meanScale /= 2.0F;
+                meanScale /= getBackingScaleFactor();
             #endif
 
             ImHexApi::System::impl::setGlobalScale(meanScale);

main/source/init/tasks.cpp

@@ -6,6 +6,7 @@
 
 #include <hex/api/content_registry.hpp>
 #include <hex/api/project_file_manager.hpp>
+#include <hex/api/theme_manager.hpp>
 #include <hex/ui/view.hpp>
 #include <hex/helpers/net.hpp>
 #include <hex/helpers/fs.hpp>
@@ -63,16 +64,6 @@ namespace hex::init {
 
         using enum fs::ImHexPath;
 
-        // Check if ImHex is installed in portable mode
-        {
-            if (const auto executablePath = fs::getExecutablePath(); executablePath.has_value()) {
-                const auto flagFile = executablePath->parent_path() / "PORTABLE";
-
-                if (fs::exists(flagFile) && fs::isRegularFile(flagFile))
-                    ImHexApi::System::impl::setPortableVersion(true);
-            }
-        }
-
         // Create all folders
         for (u32 path = 0; path < u32(fs::ImHexPath::END); path++) {
             for (auto &folder : fs::getDefaultPaths(static_cast<fs::ImHexPath>(path), true)) {
@@ -192,6 +183,7 @@ namespace hex::init {
 
         ContentRegistry::PatternLanguage::getFunctions().clear();
         ContentRegistry::PatternLanguage::getPragmas().clear();
+        ContentRegistry::PatternLanguage::impl::getVisualizers().clear();
 
         {
             auto &views = ContentRegistry::Views::getEntries();
@@ -227,6 +219,8 @@ namespace hex::init {
         ContentRegistry::FileHandler::getEntries().clear();
         ContentRegistry::Hashes::impl::getHashes().clear();
 
+        api::ThemeManager::reset();
+
         {
             auto &visualizers = ContentRegistry::HexEditor::impl::getVisualizers();
             for (auto &[name, visualizer] : visualizers)

main/source/main.cpp

@@ -2,7 +2,6 @@
 
 #include <hex/helpers/utils.hpp>
 #include <hex/helpers/logger.hpp>
-#include <hex/api/theme_manager.hpp>
 
 #include "window.hpp"
 
@@ -15,12 +14,18 @@ int main(int argc, char **argv, char **envp) {
     using namespace hex;
     ImHexApi::System::impl::setProgramArguments(argc, argv, envp);
 
-#if defined(OS_WINDOWS)
-    ImHexApi::System::impl::setBorderlessWindowMode(true);
-#endif
-
     bool shouldRestart = false;
 
+    // Check if ImHex is installed in portable mode
+    {
+        if (const auto executablePath = fs::getExecutablePath(); executablePath.has_value()) {
+            const auto flagFile = executablePath->parent_path() / "PORTABLE";
+
+            if (fs::exists(flagFile) && fs::isRegularFile(flagFile))
+                ImHexApi::System::impl::setPortableVersion(true);
+        }
+    }
+
     do {
         EventManager::subscribe<RequestRestartImHex>([&]{ shouldRestart = true; });
         shouldRestart = false;
@@ -51,7 +56,6 @@ int main(int argc, char **argv, char **envp) {
         // Main window
         {
             Window window;
-
             if (argc == 1)
                 ;    // No arguments provided
             else if (argc >= 2) {
@@ -61,6 +65,7 @@ int main(int argc, char **argv, char **envp) {
                 }
             }
 
+
             window.loop();
         }
 

main/source/window/linux_window.cpp

@@ -18,6 +18,12 @@
 namespace hex {
 
     void Window::initNative() {
+        // Add plugin library folders to dll search path
+        for (const auto &path : hex::fs::getDefaultPaths(fs::ImHexPath::Libraries))  {
+            if (std::fs::exists(path))
+                setenv("LD_LIBRARY_PATH", hex::format("{};{}", hex::getEnvironmentVariable("LD_LIBRARY_PATH").value_or(""), path.string().c_str()).c_str(), true);
+        }
+
         if (!isatty(STDOUT_FILENO)) {
             log::redirectToFile();
         }

main/source/window/macos_window.cpp

@@ -17,6 +17,12 @@
 namespace hex {
 
     void Window::initNative() {
+        // Add plugin library folders to dll search path
+        for (const auto &path : hex::fs::getDefaultPaths(fs::ImHexPath::Libraries))  {
+            if (std::fs::exists(path))
+                setenv("LD_LIBRARY_PATH", hex::format("{};{}", hex::getEnvironmentVariable("LD_LIBRARY_PATH").value_or(""), path.string().c_str()).c_str(), true);
+        }
+
         if (!isatty(STDOUT_FILENO)) {
             log::redirectToFile();
         }

main/source/window/win_window.cpp

@@ -11,16 +11,17 @@
     #include <imgui_internal.h>
     #include <fonts/codicons_font.h>
 
-    #include <nlohmann/json.hpp>
-
     #include <GLFW/glfw3.h>
     #define GLFW_EXPOSE_NATIVE_WIN32
     #include <GLFW/glfw3native.h>
     #undef GLFW_EXPOSE_NATIVE_WIN32
 
+    #include <winbase.h>
     #include <winuser.h>
     #include <dwmapi.h>
     #include <windowsx.h>
+    #include <shobjidl.h>
+    #include <wrl/client.h>
 
     #include <csignal>
 
@@ -31,6 +32,7 @@ namespace hex {
     static LONG_PTR g_oldWndProc;
     static float g_titleBarHeight;
     static ImGuiMouseCursor g_mouseCursorIcon;
+    static Microsoft::WRL::ComPtr<ITaskbarList4> g_taskbarList;
 
     static LRESULT commonWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
         switch (uMsg) {
@@ -187,6 +189,14 @@ namespace hex {
 
 
     void Window::initNative() {
+        ImHexApi::System::impl::setBorderlessWindowMode(true);
+
+        // Add plugin library folders to dll search path
+        for (const auto &path : hex::fs::getDefaultPaths(fs::ImHexPath::Libraries))  {
+            if (std::fs::exists(path))
+                AddDllDirectory(path.c_str());
+        }
+
         // Attach to parent console if one exists
         if (AttachConsole(ATTACH_PARENT_PROCESS)) {
 
@@ -291,6 +301,41 @@ namespace hex {
                 return EXCEPTION_CONTINUE_SEARCH;
             });
         }
+
+        if (SUCCEEDED(CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED))) {
+            CoCreateInstance(CLSID_TaskbarList, nullptr, CLSCTX_INPROC_SERVER, IID_ITaskbarList4, &g_taskbarList);
+        }
+
+
+        EventManager::subscribe<EventSetTaskBarIconState>([hwnd](u32 state, u32 type, u32 progress){
+            using enum ImHexApi::System::TaskProgressState;
+            switch (ImHexApi::System::TaskProgressState(state)) {
+                case Reset:
+                    g_taskbarList->SetProgressState(hwnd, TBPF_NOPROGRESS);
+                    g_taskbarList->SetProgressValue(hwnd, 0, 0);
+                    break;
+                case Flash:
+                    FlashWindow(hwnd, true);
+                    break;
+                case Progress:
+                    g_taskbarList->SetProgressState(hwnd, TBPF_INDETERMINATE);
+                    g_taskbarList->SetProgressValue(hwnd, progress, 100);
+                    break;
+            }
+
+            using enum ImHexApi::System::TaskProgressType;
+            switch (ImHexApi::System::TaskProgressType(type)) {
+                case Normal:
+                    g_taskbarList->SetProgressState(hwnd, TBPF_NORMAL);
+                    break;
+                case Warning:
+                    g_taskbarList->SetProgressState(hwnd, TBPF_PAUSED);
+                    break;
+                case Error:
+                    g_taskbarList->SetProgressState(hwnd, TBPF_ERROR);
+                    break;
+            }
+        });
     }
 
     void Window::beginNativeWindowFrame() {

main/source/window/window.cpp

@@ -9,16 +9,16 @@
 #include <hex/helpers/utils.hpp>
 #include <hex/helpers/fs.hpp>
 #include <hex/helpers/logger.hpp>
-#include <fmt/printf.h>
+#include <hex/helpers/stacktrace.hpp>
 
 #include <chrono>
 #include <csignal>
-#include <iostream>
 #include <set>
 #include <thread>
 #include <cassert>
 
 #include <romfs/romfs.hpp>
+#include <llvm/Demangle/Demangle.h>
 
 #include <imgui.h>
 #define IMGUI_DEFINE_MATH_OPERATORS
@@ -78,25 +78,43 @@ namespace hex {
             log::fatal("Uncaught exception thrown!");
         }
 
-        // Let's not loop on this...
-        std::signal(signalNumber, nullptr);
+        std::signal(signalNumber, SIG_DFL);
+
+        for (const auto &stackFrame : stacktrace::getStackTrace()) {
+            if (stackFrame.line == 0)
+                log::fatal("  {}", stackFrame.function);
+            else
+                log::fatal("  ({}:{}) | {}",  stackFrame.file, stackFrame.line, stackFrame.function);
+        }
+    
 
         #if defined(DEBUG)
-            assert(false);
+            assert(!"Debug build, triggering breakpoint");
         #else
             std::raise(signalNumber);
         #endif
     }
 
     Window::Window() {
+        stacktrace::initialize();
+
+        constexpr static auto openEmergencyPopup = [](const std::string &title){
+            TaskManager::doLater([title] {
+                for (const auto &provider : ImHexApi::Provider::getProviders())
+                    ImHexApi::Provider::remove(provider, false);
+
+                ImGui::OpenPopup(title.c_str());
+            });
+        };
+
         {
             for (const auto &[argument, value] : ImHexApi::System::getInitArguments()) {
                 if (argument == "no-plugins") {
-                    TaskManager::doLater([] { ImGui::OpenPopup("No Plugins"); });
+                    openEmergencyPopup("No Plugins");
                 } else if (argument == "no-builtin-plugin") {
-                    TaskManager::doLater([] { ImGui::OpenPopup("No Builtin Plugin"); });
+                    openEmergencyPopup("No Builtin Plugin");
                 } else if (argument == "multiple-builtin-plugins") {
-                    TaskManager::doLater([] { ImGui::OpenPopup("Multiple Builtin Plugins"); });
+                    openEmergencyPopup("Multiple Builtin Plugins");
                 }
             }
         }
@@ -115,13 +133,19 @@ namespace hex {
                 EventManager::post<EventWindowClosing>(this->m_window);
         });
 
-        EventManager::subscribe<RequestChangeWindowTitle>(this, [this](const std::string &windowTitle) {
+        EventManager::subscribe<RequestUpdateWindowTitle>(this, [this]() {
             std::string title = "ImHex";
 
-            if (ImHexApi::Provider::isValid()) {
+            if (ProjectFile::hasPath()) {
+                title += " - Project " + hex::limitStringLength(ProjectFile::getPath().stem().string(), 32);
+
+                if (ImHexApi::Provider::isDirty())
+                    title += " (*)";
+
+            } else if (ImHexApi::Provider::isValid()) {
                 auto provider = ImHexApi::Provider::get();
-                if (!windowTitle.empty() && provider != nullptr) {
-                    title += " - " + hex::limitStringLength(windowTitle, 32);
+                if (provider != nullptr) {
+                    title += " - " + hex::limitStringLength(provider->getName(), 32);
 
                     if (provider->isDirty())
                         title += " (*)";
@@ -164,7 +188,18 @@ namespace hex {
         HANDLE_SIGNAL(SIGABRT)
         HANDLE_SIGNAL(SIGFPE)
         #undef HANDLE_SIGNAL
-        std::set_terminate([]{ signalHandler(SIGABRT, "Unhandled C++ exception"); });
+        std::set_terminate([]{
+            try {
+                std::rethrow_exception(std::current_exception());
+            } catch (std::exception &ex) {
+                log::fatal(
+                        "Program terminated with uncaught exception: {}()::what() -> {}",
+                        llvm::itaniumDemangle(typeid(ex).name(), nullptr, nullptr, nullptr),
+                        ex.what()
+                );
+            }
+            EventManager::post<EventAbnormalTermination>(0);
+        });
 
         auto logoData      = romfs::get("logo.png");
         this->m_logoTexture = ImGui::Texture(reinterpret_cast<const ImU8 *>(logoData.data()), logoData.size());
@@ -177,7 +212,7 @@ namespace hex {
     Window::~Window() {
         EventManager::unsubscribe<EventProviderDeleted>(this);
         EventManager::unsubscribe<RequestCloseImHex>(this);
-        EventManager::unsubscribe<RequestChangeWindowTitle>(this);
+        EventManager::unsubscribe<RequestUpdateWindowTitle>(this);
         EventManager::unsubscribe<EventAbnormalTermination>(this);
         EventManager::unsubscribe<RequestOpenPopup>(this);
 
@@ -195,6 +230,7 @@ namespace hex {
 
                 bool frameRateUnlocked = ImGui::IsPopupOpen(ImGuiID(0), ImGuiPopupFlags_AnyPopupId) || TaskManager::getRunningTaskCount() > 0 || this->m_mouseButtonDown || this->m_hadEvent || !this->m_pressedKeys.empty();
                 const double timeout = std::max(0.0, (1.0 / 5.0) - (glfwGetTime() - this->m_lastFrameTime));
+                this->m_hadEvent = false;
 
                 if ((this->m_lastFrameTime - this->m_frameRateUnlockTime) > 5 && this->m_frameRateTemporarilyUnlocked && !frameRateUnlocked) {
                     this->m_frameRateTemporarilyUnlocked = false;
@@ -222,8 +258,6 @@ namespace hex {
             }
 
             this->m_lastFrameTime = glfwGetTime();
-
-            this->m_hadEvent = false;
         }
     }
 
@@ -692,7 +726,8 @@ namespace hex {
 
         io.ConfigFlags |= ImGuiConfigFlags_DockingEnable | ImGuiConfigFlags_NavEnableKeyboard;
         io.ConfigWindowsMoveFromTitleBarOnly = true;
-        io.FontGlobalScale = 1.0F;
+
+        io.FontGlobalScale = ImHexApi::System::getGlobalScale();
 
         if (glfwGetPrimaryMonitor() != nullptr) {
             auto sessionType = hex::getEnvironmentVariable("XDG_SESSION_TYPE");
@@ -781,14 +816,10 @@ namespace hex {
     void Window::exitImGui() {
         delete static_cast<ImGui::ImHexCustomData *>(ImGui::GetIO().UserData);
 
-        ImNodes::PopAttributeFlag();
-        ImNodes::PopAttributeFlag();
-
         ImGui::SaveIniSettingsToDisk(hex::toUTF8String(this->m_imguiSettingsPath).c_str());
 
         ImGui_ImplOpenGL3_Shutdown();
         ImGui_ImplGlfw_Shutdown();
-        ImNodes::DestroyContext();
         ImPlot::DestroyContext();
         ImGui::DestroyContext();
     }

plugins/builtin/CMakeLists.txt

@@ -10,6 +10,7 @@ add_library(${PROJECT_NAME} SHARED
         source/content/data_inspector.cpp
         source/content/pl_builtin_functions.cpp
         source/content/pl_pragmas.cpp
+        source/content/pl_visualizers.cpp
         source/content/settings_entries.cpp
         source/content/tools_entries.cpp
         source/content/data_processor_nodes.cpp

plugins/builtin/include/content/helpers/provider_extra_data.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <map>
+#include <hex/api/content_registry.hpp>
 #include <hex/providers/provider.hpp>
 
 #include <pl/pattern_language.hpp>
@@ -8,6 +8,11 @@
 #include <hex/data_processor/node.hpp>
 #include <hex/data_processor/link.hpp>
 
+#include <map>
+
+#include <imnodes.h>
+#include <imnodes_internal.h>
+
 namespace hex::plugin::builtin {
 
     class ProviderExtraData {
@@ -61,25 +66,58 @@ namespace hex::plugin::builtin {
             std::list<ImHexApi::Bookmarks::Entry> bookmarks;
 
             struct DataProcessor {
-                std::list<dp::Node*> endNodes;
-                std::list<std::unique_ptr<dp::Node>> nodes;
-                std::list<dp::Link> links;
+                struct Workspace {
+                    std::unique_ptr<ImNodesContext, void(*)(ImNodesContext*)> context = { []{
+                        ImNodesContext *ctx = ImNodes::CreateContext();
+                        ctx->Style = ImNodes::GetStyle();
+                        ctx->Io = ImNodes::GetIO();
+                        ctx->AttributeFlagStack = GImNodes->AttributeFlagStack;
 
-                std::vector<hex::prv::Overlay *> dataOverlays;
-                std::optional<dp::Node::NodeError> currNodeError;
+                        return ctx;
+                    }(), ImNodes::DestroyContext };
+
+                    std::list<std::unique_ptr<dp::Node>> nodes;
+                    std::list<dp::Node*> endNodes;
+                    std::list<dp::Link> links;
+                    std::vector<hex::prv::Overlay *> dataOverlays;
+                    std::optional<dp::Node::NodeError> currNodeError;
+                };
+
+                Workspace mainWorkspace;
+                std::vector<Workspace*> workspaceStack;
             } dataProcessor;
 
             struct HexEditor {
                 std::optional<u64> selectionStart, selectionEnd;
                 float scrollPosition = 0.0F;
             } editor;
+
+            struct Hashes {
+                std::vector<ContentRegistry::Hashes::Hash::Function> hashFunctions;
+            } hashes;
+
+            struct Yara {
+                struct YaraMatch {
+                    std::string identifier;
+                    std::string variable;
+                    u64 address;
+                    size_t size;
+                    bool wholeDataMatch;
+
+                    mutable u32 highlightId;
+                    mutable u32 tooltipId;
+                };
+
+                std::vector<std::pair<std::fs::path, std::fs::path>> rules;
+                std::vector<YaraMatch> matches;
+            } yara;
         };
 
         static Data& getCurrent() {
             return get(ImHexApi::Provider::get());
         }
 
-        static Data& get(hex::prv::Provider *provider) {
+        static Data& get(const hex::prv::Provider *provider) {
             return s_data[provider];
         }
 
@@ -93,7 +131,7 @@ namespace hex::plugin::builtin {
 
     private:
         ProviderExtraData() = default;
-        static inline std::map<hex::prv::Provider*, Data> s_data = {};
+        static inline std::map<const hex::prv::Provider*, Data> s_data = {};
     };
 
 }

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

@@ -34,7 +34,7 @@ namespace hex::plugin::builtin {
         void close() override;
 
         [[nodiscard]] std::string getName() const override;
-        [[nodiscard]] std::vector<std::pair<std::string, std::string>> getDataInformation() const override;
+        [[nodiscard]] std::vector<std::pair<std::string, std::string>> getDataDescription() const override;
 
         [[nodiscard]] bool hasLoadInterface() const override { return true; }
         void drawLoadInterface() override;
@@ -47,6 +47,7 @@ namespace hex::plugin::builtin {
         }
 
         [[nodiscard]] std::pair<Region, bool> getRegionValidity(u64 address) const override;
+        std::variant<std::string, i128> queryInformation(const std::string &category, const std::string &argument) override;
 
     protected:
         void reloadDrives();

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

@@ -47,7 +47,8 @@ namespace hex::plugin::builtin {
         void saveAs(const std::fs::path &path) override;
 
         [[nodiscard]] std::string getName() const override;
-        [[nodiscard]] std::vector<std::pair<std::string, std::string>> getDataInformation() const override;
+        [[nodiscard]] std::vector<std::pair<std::string, std::string>> getDataDescription() const override;
+        std::variant<std::string, i128> queryInformation(const std::string &category, const std::string &argument) override;
 
         [[nodiscard]] bool hasFilePicker() const override { return true; }
         [[nodiscard]] bool handleFilePicker() override;

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

@@ -32,7 +32,7 @@ namespace hex::plugin::builtin {
         void saveAs(const std::fs::path &path) override;
 
         [[nodiscard]] std::string getName() const override;
-        [[nodiscard]] std::vector<std::pair<std::string, std::string>> getDataInformation() const override;
+        [[nodiscard]] std::vector<std::pair<std::string, std::string>> getDataDescription() const override;
 
         [[nodiscard]] bool open() override;
         void close() override;
@@ -50,6 +50,7 @@ namespace hex::plugin::builtin {
         }
 
         [[nodiscard]] std::pair<Region, bool> getRegionValidity(u64 address) const override;
+        std::variant<std::string, i128> queryInformation(const std::string &category, const std::string &argument) override;
 
     protected:
         hex::Socket m_socket;

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

@@ -27,7 +27,7 @@ namespace hex::plugin::builtin {
         void close() override;
 
         [[nodiscard]] std::string getName() const override;
-        [[nodiscard]] std::vector<std::pair<std::string, std::string>> getDataInformation() const override { return { }; }
+        [[nodiscard]] std::vector<std::pair<std::string, std::string>> getDataDescription() const override { return { }; }
 
         void loadSettings(const nlohmann::json &settings) override;
         [[nodiscard]] nlohmann::json storeSettings(nlohmann::json settings) const override;

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

@@ -31,7 +31,7 @@ namespace hex::plugin::builtin {
         void saveAs(const std::fs::path &path) override;
 
         [[nodiscard]] std::string getName() const override { return LangEntry("hex.builtin.provider.mem_file.unsaved"); }
-        [[nodiscard]] std::vector<std::pair<std::string, std::string>> getDataInformation() const override { return { }; }
+        [[nodiscard]] std::vector<std::pair<std::string, std::string>> getDataDescription() const override { return { }; }
 
         [[nodiscard]] std::string getTypeName() const override {
             return "hex.builtin.provider.mem_file";

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

@@ -23,7 +23,7 @@ namespace hex::plugin::builtin {
         [[nodiscard]] size_t getActualSize() const override { return 0x00; }
 
         [[nodiscard]] std::string getName() const override { return "None"; }
-        [[nodiscard]] std::vector<std::pair<std::string, std::string>> getDataInformation() const override { return { }; }
+        [[nodiscard]] std::vector<std::pair<std::string, std::string>> getDataDescription() const override { return { }; }
 
         void loadSettings(const nlohmann::json &settings) override { hex::unused(settings); }
         [[nodiscard]] nlohmann::json storeSettings(nlohmann::json settings) const override { return settings; }

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

@@ -10,11 +10,26 @@ namespace hex::plugin::builtin {
         explicit ViewProvider() = default;
         ~ViewProvider() override = default;
 
-        [[nodiscard]] bool isAvailable() const override { return this->m_provider != nullptr; }
-        [[nodiscard]] bool isReadable()  const override { return this->m_provider->isReadable(); }
-        [[nodiscard]] bool isWritable()  const override { return this->m_provider->isWritable(); }
+        [[nodiscard]] bool isAvailable() const override {
+            if (this->m_provider == nullptr)
+                return false;
+            else
+                return this->m_provider->isAvailable();
+        }
+        [[nodiscard]] bool isReadable() const override {
+            if (this->m_provider == nullptr)
+                return false;
+            else
+                return this->m_provider->isReadable();
+        }
+        [[nodiscard]] bool isWritable() const override {
+            if (this->m_provider == nullptr)
+                return false;
+            else
+                return this->m_provider->isWritable();
+        }
         [[nodiscard]] bool isResizable() const override { return true; }
-        [[nodiscard]] bool isSavable()   const override { return true; }
+        [[nodiscard]] bool isSavable() const override { return true; }
 
         void save() override {
             this->m_provider->save();
@@ -27,21 +42,49 @@ namespace hex::plugin::builtin {
             this->m_size = newSize;
         }
         void insert(u64 offset, size_t size) override {
+            if (this->m_provider == nullptr)
+                return;
+
             this->m_size += size;
             this->m_provider->insert(offset + this->m_startAddress, size);
         }
 
         void remove(u64 offset, size_t size) override {
+            if (this->m_provider == nullptr)
+                return;
+
             this->m_size -= size;
             this->m_provider->remove(offset + this->m_startAddress, size);
         }
 
-        void readRaw(u64 offset, void *buffer, size_t size) override { this->m_provider->read(offset + this->m_startAddress, buffer, size); }
-        void writeRaw(u64 offset, const void *buffer, size_t size) override { this->m_provider->write(offset + this->m_startAddress, buffer, size); }
+        void readRaw(u64 offset, void *buffer, size_t size) override {
+            if (this->m_provider == nullptr)
+                return;
+
+            this->m_provider->read(offset + this->m_startAddress, buffer, size);
+        }
+
+        void writeRaw(u64 offset, const void *buffer, size_t size) override {
+            if (this->m_provider == nullptr)
+                return;
+
+            this->m_provider->write(offset + this->m_startAddress, buffer, size);
+        }
+
         [[nodiscard]] size_t getActualSize() const override { return this->m_size; }
 
-        [[nodiscard]] std::string getName() const override { return hex::format("{} View", this->m_provider->getName()); }
-        [[nodiscard]] std::vector<std::pair<std::string, std::string>> getDataInformation() const override { return this->m_provider->getDataInformation(); }
+        [[nodiscard]] std::string getName() const override {
+            if (this->m_provider == nullptr)
+                return "View";
+            else
+                return hex::format("{} View", this->m_provider->getName());
+        }
+        [[nodiscard]] std::vector<std::pair<std::string, std::string>> getDataDescription() const override {
+            if (this->m_provider == nullptr)
+                return { };
+
+            return this->m_provider->getDataDescription();
+        }
 
         void loadSettings(const nlohmann::json &settings) override { hex::unused(settings); }
         [[nodiscard]] nlohmann::json storeSettings(nlohmann::json settings) const override { return settings; }

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

@@ -7,6 +7,8 @@
 #include <hex/data_processor/node.hpp>
 #include <hex/data_processor/link.hpp>
 
+#include "content/helpers/provider_extra_data.hpp"
+
 #include <array>
 #include <string>
 
@@ -14,24 +16,38 @@ namespace hex::plugin::builtin {
 
     class ViewDataProcessor : public View {
     public:
+        using Workspace = ProviderExtraData::Data::DataProcessor::Workspace;
+
         ViewDataProcessor();
         ~ViewDataProcessor() override;
 
         void drawContent() override;
 
+        static nlohmann::json saveNode(const dp::Node *node);
+        static nlohmann::json saveNodes(const Workspace &workspace);
+
+        static std::unique_ptr<dp::Node> loadNode(const nlohmann::json &data);
+        static void loadNodes(Workspace &workspace, const nlohmann::json &data);
+
     private:
-        bool m_justSwitchedProvider = false;
+        static void eraseLink(Workspace &workspace, int id);
+        static void eraseNodes(Workspace &workspace, const std::vector<int> &ids);
+        static void processNodes(Workspace &workspace);
+
+        void reloadCustomNodes();
+    private:
+        bool m_updateNodePositions = false;
         int m_rightClickedId = -1;
         ImVec2 m_rightClickedCoords;
 
         bool m_continuousEvaluation = false;
 
-        void eraseLink(int id);
-        void eraseNodes(const std::vector<int> &ids);
-        void processNodes();
+        struct CustomNode {
+            std::string name;
+            nlohmann::json data;
+        };
 
-        std::string saveNodes(prv::Provider *provider);
-        void loadNodes(prv::Provider *provider, const std::string &data);
+        std::vector<CustomNode> m_customNodes;
     };
 
 }

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

@@ -17,11 +17,13 @@ namespace hex::plugin::builtin {
 
         void drawContent() override;
 
+    private:
+        static bool importHashes(prv::Provider *provider, const nlohmann::json &json);
+        static bool exportHashes(prv::Provider *provider, nlohmann::json &json);
+
     private:
         ContentRegistry::Hashes::Hash *m_selectedHash = nullptr;
         std::string m_newHashName;
-
-        std::vector<ContentRegistry::Hashes::Hash::Function> m_hashFunctions;
     };
 
 }

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

@@ -19,7 +19,6 @@ namespace hex::plugin::builtin {
         void drawContent() override;
 
     private:
-        std::map<hex::prv::Provider *, std::vector<pl::ptrn::Pattern*>> m_sortedPatterns;
         ui::PatternDrawer m_patternDrawer;
     };
 

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

@@ -44,8 +44,8 @@ namespace hex::plugin::builtin {
         [[nodiscard]] bool isAvailable() const override { return true; }
         [[nodiscard]] bool hasViewMenuItemEntry() const override { return false; }
 
-        [[nodiscard]] ImVec2 getMinSize() const override { return { 500, 400 }; }
-        [[nodiscard]] ImVec2 getMaxSize() const override { return { 500, 400 }; }
+        [[nodiscard]] ImVec2 getMinSize() const override { return { 600, 400 }; }
+        [[nodiscard]] ImVec2 getMaxSize() const override { return { 800, 600 }; }
 
     private:
         Net m_net;

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

@@ -17,25 +17,11 @@ namespace hex::plugin::builtin {
         void drawContent() override;
 
     private:
-        struct YaraMatch {
-            std::string identifier;
-            std::string variable;
-            u64 address;
-            size_t size;
-            bool wholeDataMatch;
-
-            u32 highlightId;
-            u32 tooltipId;
-        };
-
-        std::vector<std::pair<std::fs::path, std::fs::path>> m_rules;
-        std::vector<YaraMatch> m_matches;
         u32 m_selectedRule = 0;
         TaskHolder m_matcherTask;
 
         std::vector<std::string> m_consoleMessages;
 
-        void reloadRules();
         void applyRules();
         void clearResult();
     };

plugins/builtin/include/ui/hex_editor.hpp

@@ -132,6 +132,10 @@ namespace hex::plugin::builtin::ui {
             this->m_characterCellPadding = characterCellPadding;
         }
 
+        [[nodiscard]] const std::optional<EncodingFile>& getCustomEncoding() const {
+            return this->m_currCustomEncoding;
+        }
+
         void setCustomEncoding(EncodingFile encoding) {
             this->m_currCustomEncoding = std::move(encoding);
         }

plugins/builtin/include/ui/pattern_drawer.hpp

@@ -12,6 +12,15 @@ namespace hex::plugin::builtin::ui {
 
         void draw(const std::vector<std::shared_ptr<pl::ptrn::Pattern>> &patterns, float height = 0.0F);
 
+        enum class TreeStyle {
+            Default         = 0,
+            AutoExpanded    = 1,
+            Flattened       = 2
+        };
+
+        void setTreeStyle(TreeStyle style) { this->m_treeStyle = style; }
+        void reset();
+
     private:
         void draw(pl::ptrn::Pattern& pattern);
 
@@ -41,12 +50,29 @@ namespace hex::plugin::builtin::ui {
         void drawArray(pl::ptrn::Pattern& pattern, pl::ptrn::Iteratable &iteratable, bool isInlined);
         u64& getDisplayEnd(const pl::ptrn::Pattern& pattern);
         void makeSelectable(const pl::ptrn::Pattern &pattern);
+
+        void drawVisualizerButton(pl::ptrn::Pattern& pattern, pl::ptrn::Iteratable &iteratable);
+        void drawVisualizer(const std::vector<pl::core::Token::Literal> &arguments, pl::ptrn::Pattern &pattern, pl::ptrn::Iteratable &iteratable, bool reset);
+
+        void createLeafNode(const pl::ptrn::Pattern& pattern);
+        bool createTreeNode(const pl::ptrn::Pattern& pattern);
         void createDefaultEntry(pl::ptrn::Pattern &pattern);
+        void closeTreeNode(bool inlined);
+
+        bool isEditingPattern(const pl::ptrn::Pattern& pattern) const;
+        void resetEditing();
 
     private:
         std::map<const pl::ptrn::Pattern*, u64> m_displayEnd;
         std::vector<pl::ptrn::Pattern*> m_sortedPatterns;
 
         const pl::ptrn::Pattern *m_editingPattern = nullptr;
+        u64 m_editingPatternOffset = 0;
+
+        TreeStyle m_treeStyle = TreeStyle::Default;
+        pl::ptrn::Pattern *m_currVisualizedPattern = nullptr;
+
+        std::set<pl::ptrn::Pattern*> m_visualizedPatterns;
+        std::string m_lastVisualizerError;
     };
 }

plugins/builtin/romfs/lang/base.json

@@ -0,0 +1,840 @@
+[
+  "hex.builtin.command.calc.desc",
+  "hex.builtin.command.cmd.desc",
+  "hex.builtin.command.cmd.result",
+  "hex.builtin.command.web.desc",
+  "hex.builtin.command.web.result",
+  "hex.builtin.common.address",
+  "hex.builtin.common.big",
+  "hex.builtin.common.big_endian",
+  "hex.builtin.common.browse",
+  "hex.builtin.common.bytes",
+  "hex.builtin.common.cancel",
+  "hex.builtin.common.choose_file",
+  "hex.builtin.common.close",
+  "hex.builtin.common.comment",
+  "hex.builtin.common.count",
+  "hex.builtin.common.decimal",
+  "hex.builtin.common.dont_show_again",
+  "hex.builtin.common.encoding.ascii",
+  "hex.builtin.common.encoding.utf16be",
+  "hex.builtin.common.encoding.utf16le",
+  "hex.builtin.common.encoding.utf8",
+  "hex.builtin.common.endian",
+  "hex.builtin.common.error",
+  "hex.builtin.common.fatal",
+  "hex.builtin.common.file",
+  "hex.builtin.common.filter",
+  "hex.builtin.common.hexadecimal",
+  "hex.builtin.common.info",
+  "hex.builtin.common.instruction",
+  "hex.builtin.common.link",
+  "hex.builtin.common.little",
+  "hex.builtin.common.little_endian",
+  "hex.builtin.common.load",
+  "hex.builtin.common.match_selection",
+  "hex.builtin.common.name",
+  "hex.builtin.common.no",
+  "hex.builtin.common.number_format",
+  "hex.builtin.common.octal",
+  "hex.builtin.common.offset",
+  "hex.builtin.common.okay",
+  "hex.builtin.common.open",
+  "hex.builtin.common.percentage",
+  "hex.builtin.common.processing",
+  "hex.builtin.common.question",
+  "hex.builtin.common.range",
+  "hex.builtin.common.range.entire_data",
+  "hex.builtin.common.range.selection",
+  "hex.builtin.common.region",
+  "hex.builtin.common.set",
+  "hex.builtin.common.size",
+  "hex.builtin.common.type",
+  "hex.builtin.common.type.f32",
+  "hex.builtin.common.type.f64",
+  "hex.builtin.common.type.i16",
+  "hex.builtin.common.type.i24",
+  "hex.builtin.common.type.i32",
+  "hex.builtin.common.type.i48",
+  "hex.builtin.common.type.i64",
+  "hex.builtin.common.type.i8",
+  "hex.builtin.common.type.u16",
+  "hex.builtin.common.type.u24",
+  "hex.builtin.common.type.u32",
+  "hex.builtin.common.type.u48",
+  "hex.builtin.common.type.u64",
+  "hex.builtin.common.type.u8",
+  "hex.builtin.common.value",
+  "hex.builtin.common.yes",
+  "hex.builtin.hash.crc.iv",
+  "hex.builtin.hash.crc.poly",
+  "hex.builtin.hash.crc.refl_in",
+  "hex.builtin.hash.crc.refl_out",
+  "hex.builtin.hash.crc.xor_out",
+  "hex.builtin.hash.crc16",
+  "hex.builtin.hash.crc32",
+  "hex.builtin.hash.crc8",
+  "hex.builtin.hash.md5",
+  "hex.builtin.hash.sha1",
+  "hex.builtin.hash.sha224",
+  "hex.builtin.hash.sha256",
+  "hex.builtin.hash.sha384",
+  "hex.builtin.hash.sha512",
+  "hex.builtin.hex_editor.data_size",
+  "hex.builtin.hex_editor.no_bytes",
+  "hex.builtin.hex_editor.page",
+  "hex.builtin.hex_editor.region",
+  "hex.builtin.hex_editor.selection",
+  "hex.builtin.hex_editor.selection.none",
+  "hex.builtin.inspector.ascii",
+  "hex.builtin.inspector.binary",
+  "hex.builtin.inspector.bool",
+  "hex.builtin.inspector.dos_date",
+  "hex.builtin.inspector.dos_time",
+  "hex.builtin.inspector.double",
+  "hex.builtin.inspector.float",
+  "hex.builtin.inspector.float16",
+  "hex.builtin.inspector.guid",
+  "hex.builtin.inspector.i16",
+  "hex.builtin.inspector.i24",
+  "hex.builtin.inspector.i32",
+  "hex.builtin.inspector.i48",
+  "hex.builtin.inspector.i64",
+  "hex.builtin.inspector.i8",
+  "hex.builtin.inspector.long_double",
+  "hex.builtin.inspector.rgb565",
+  "hex.builtin.inspector.rgba8",
+  "hex.builtin.inspector.sleb128",
+  "hex.builtin.inspector.string",
+  "hex.builtin.inspector.string16",
+  "hex.builtin.inspector.time",
+  "hex.builtin.inspector.time32",
+  "hex.builtin.inspector.time64",
+  "hex.builtin.inspector.u16",
+  "hex.builtin.inspector.u24",
+  "hex.builtin.inspector.u32",
+  "hex.builtin.inspector.u48",
+  "hex.builtin.inspector.u64",
+  "hex.builtin.inspector.u8",
+  "hex.builtin.inspector.uleb128",
+  "hex.builtin.inspector.utf8",
+  "hex.builtin.inspector.wide",
+  "hex.builtin.layouts.default",
+  "hex.builtin.menu.edit",
+  "hex.builtin.menu.edit.bookmark.create",
+  "hex.builtin.menu.edit.redo",
+  "hex.builtin.menu.edit.undo",
+  "hex.builtin.menu.file",
+  "hex.builtin.menu.file.bookmark.export",
+  "hex.builtin.menu.file.bookmark.import",
+  "hex.builtin.menu.file.clear_recent",
+  "hex.builtin.menu.file.close",
+  "hex.builtin.menu.file.create_file",
+  "hex.builtin.menu.file.export",
+  "hex.builtin.menu.file.export.base64",
+  "hex.builtin.menu.file.export.base64.popup.export_error",
+  "hex.builtin.menu.file.export.ips.popup.export_error",
+  "hex.builtin.menu.file.export.ips.popup.invalid_patch_header_error",
+  "hex.builtin.menu.file.export.ips.popup.address_out_of_range_error",
+  "hex.builtin.menu.file.export.ips.popup.patch_too_large_error",
+  "hex.builtin.menu.file.export.ips.popup.invalid_patch_format_error",
+  "hex.builtin.menu.file.export.ips.popup.missing_eof_error",
+  "hex.builtin.menu.file.export.ips",
+  "hex.builtin.menu.file.export.ips32",
+  "hex.builtin.menu.file.export.popup.create",
+  "hex.builtin.menu.file.export.title",
+  "hex.builtin.menu.file.import",
+  "hex.builtin.menu.file.import.base64",
+  "hex.builtin.menu.file.import.base64.popup.import_error",
+  "hex.builtin.menu.file.import.base64.popup.open_error",
+  "hex.builtin.menu.file.import.ips",
+  "hex.builtin.menu.file.import.ips32",
+  "hex.builtin.menu.file.open_file",
+  "hex.builtin.menu.file.open_other",
+  "hex.builtin.menu.file.open_project",
+  "hex.builtin.menu.file.open_recent",
+  "hex.builtin.menu.file.quit",
+  "hex.builtin.menu.file.reload_file",
+  "hex.builtin.menu.file.save_project",
+  "hex.builtin.menu.file.save_project_as",
+  "hex.builtin.menu.help",
+  "hex.builtin.menu.layout",
+  "hex.builtin.menu.view",
+  "hex.builtin.menu.view.demo",
+  "hex.builtin.menu.view.fps",
+  "hex.builtin.nodes.arithmetic",
+  "hex.builtin.nodes.arithmetic.add",
+  "hex.builtin.nodes.arithmetic.add.header",
+  "hex.builtin.nodes.arithmetic.average",
+  "hex.builtin.nodes.arithmetic.average.header",
+  "hex.builtin.nodes.arithmetic.div",
+  "hex.builtin.nodes.arithmetic.div.header",
+  "hex.builtin.nodes.arithmetic.median",
+  "hex.builtin.nodes.arithmetic.median.header",
+  "hex.builtin.nodes.arithmetic.mod",
+  "hex.builtin.nodes.arithmetic.mod.header",
+  "hex.builtin.nodes.arithmetic.mul",
+  "hex.builtin.nodes.arithmetic.mul.header",
+  "hex.builtin.nodes.arithmetic.sub",
+  "hex.builtin.nodes.arithmetic.sub.header",
+  "hex.builtin.nodes.bitwise",
+  "hex.builtin.nodes.bitwise.and",
+  "hex.builtin.nodes.bitwise.and.header",
+  "hex.builtin.nodes.bitwise.not",
+  "hex.builtin.nodes.bitwise.not.header",
+  "hex.builtin.nodes.bitwise.or",
+  "hex.builtin.nodes.bitwise.or.header",
+  "hex.builtin.nodes.bitwise.xor",
+  "hex.builtin.nodes.bitwise.xor.header",
+  "hex.builtin.nodes.buffer",
+  "hex.builtin.nodes.buffer.combine",
+  "hex.builtin.nodes.buffer.combine.header",
+  "hex.builtin.nodes.buffer.patch",
+  "hex.builtin.nodes.buffer.patch.header",
+  "hex.builtin.nodes.buffer.patch.input.patch",
+  "hex.builtin.nodes.buffer.repeat",
+  "hex.builtin.nodes.buffer.repeat.header",
+  "hex.builtin.nodes.buffer.repeat.input.buffer",
+  "hex.builtin.nodes.buffer.repeat.input.count",
+  "hex.builtin.nodes.buffer.slice",
+  "hex.builtin.nodes.buffer.slice.header",
+  "hex.builtin.nodes.buffer.slice.input.buffer",
+  "hex.builtin.nodes.buffer.slice.input.from",
+  "hex.builtin.nodes.buffer.slice.input.to",
+  "hex.builtin.nodes.casting",
+  "hex.builtin.nodes.casting.buffer_to_float",
+  "hex.builtin.nodes.casting.buffer_to_float.header",
+  "hex.builtin.nodes.casting.buffer_to_int",
+  "hex.builtin.nodes.casting.buffer_to_int.header",
+  "hex.builtin.nodes.casting.float_to_buffer",
+  "hex.builtin.nodes.casting.float_to_buffer.header",
+  "hex.builtin.nodes.casting.int_to_buffer",
+  "hex.builtin.nodes.casting.int_to_buffer.header",
+  "hex.builtin.nodes.common.height",
+  "hex.builtin.nodes.common.input",
+  "hex.builtin.nodes.common.input.a",
+  "hex.builtin.nodes.common.input.b",
+  "hex.builtin.nodes.common.output",
+  "hex.builtin.nodes.common.width",
+  "hex.builtin.nodes.constants",
+  "hex.builtin.nodes.constants.buffer",
+  "hex.builtin.nodes.constants.buffer.header",
+  "hex.builtin.nodes.constants.buffer.size",
+  "hex.builtin.nodes.constants.comment",
+  "hex.builtin.nodes.constants.comment.header",
+  "hex.builtin.nodes.constants.float",
+  "hex.builtin.nodes.constants.float.header",
+  "hex.builtin.nodes.constants.int",
+  "hex.builtin.nodes.constants.int.header",
+  "hex.builtin.nodes.constants.nullptr",
+  "hex.builtin.nodes.constants.nullptr.header",
+  "hex.builtin.nodes.constants.rgba8",
+  "hex.builtin.nodes.constants.rgba8.header",
+  "hex.builtin.nodes.constants.rgba8.output.a",
+  "hex.builtin.nodes.constants.rgba8.output.b",
+  "hex.builtin.nodes.constants.rgba8.output.g",
+  "hex.builtin.nodes.constants.rgba8.output.r",
+  "hex.builtin.nodes.constants.string",
+  "hex.builtin.nodes.constants.string.header",
+  "hex.builtin.nodes.control_flow",
+  "hex.builtin.nodes.control_flow.and",
+  "hex.builtin.nodes.control_flow.and.header",
+  "hex.builtin.nodes.control_flow.equals",
+  "hex.builtin.nodes.control_flow.equals.header",
+  "hex.builtin.nodes.control_flow.gt",
+  "hex.builtin.nodes.control_flow.gt.header",
+  "hex.builtin.nodes.control_flow.if",
+  "hex.builtin.nodes.control_flow.if.condition",
+  "hex.builtin.nodes.control_flow.if.false",
+  "hex.builtin.nodes.control_flow.if.header",
+  "hex.builtin.nodes.control_flow.if.true",
+  "hex.builtin.nodes.control_flow.lt",
+  "hex.builtin.nodes.control_flow.lt.header",
+  "hex.builtin.nodes.control_flow.not",
+  "hex.builtin.nodes.control_flow.not.header",
+  "hex.builtin.nodes.control_flow.or",
+  "hex.builtin.nodes.control_flow.or.header",
+  "hex.builtin.nodes.crypto",
+  "hex.builtin.nodes.crypto.aes",
+  "hex.builtin.nodes.crypto.aes.header",
+  "hex.builtin.nodes.crypto.aes.iv",
+  "hex.builtin.nodes.crypto.aes.key",
+  "hex.builtin.nodes.crypto.aes.key_length",
+  "hex.builtin.nodes.crypto.aes.mode",
+  "hex.builtin.nodes.crypto.aes.nonce",
+  "hex.builtin.nodes.data_access",
+  "hex.builtin.nodes.data_access.read",
+  "hex.builtin.nodes.data_access.read.address",
+  "hex.builtin.nodes.data_access.read.data",
+  "hex.builtin.nodes.data_access.read.header",
+  "hex.builtin.nodes.data_access.read.size",
+  "hex.builtin.nodes.data_access.selection",
+  "hex.builtin.nodes.data_access.selection.address",
+  "hex.builtin.nodes.data_access.selection.header",
+  "hex.builtin.nodes.data_access.selection.size",
+  "hex.builtin.nodes.data_access.size",
+  "hex.builtin.nodes.data_access.size.header",
+  "hex.builtin.nodes.data_access.size.size",
+  "hex.builtin.nodes.data_access.write",
+  "hex.builtin.nodes.data_access.write.address",
+  "hex.builtin.nodes.data_access.write.data",
+  "hex.builtin.nodes.data_access.write.header",
+  "hex.builtin.nodes.decoding",
+  "hex.builtin.nodes.decoding.base64",
+  "hex.builtin.nodes.decoding.base64.header",
+  "hex.builtin.nodes.decoding.hex",
+  "hex.builtin.nodes.decoding.hex.header",
+  "hex.builtin.nodes.display",
+  "hex.builtin.nodes.display.buffer",
+  "hex.builtin.nodes.display.buffer.header",
+  "hex.builtin.nodes.display.float",
+  "hex.builtin.nodes.display.float.header",
+  "hex.builtin.nodes.display.int",
+  "hex.builtin.nodes.display.int.header",
+  "hex.builtin.nodes.display.string",
+  "hex.builtin.nodes.display.string.header",
+  "hex.builtin.nodes.pattern_language",
+  "hex.builtin.nodes.pattern_language.out_var",
+  "hex.builtin.nodes.pattern_language.out_var.header",
+  "hex.builtin.nodes.visualizer",
+  "hex.builtin.nodes.visualizer.byte_distribution",
+  "hex.builtin.nodes.visualizer.byte_distribution.header",
+  "hex.builtin.nodes.visualizer.digram",
+  "hex.builtin.nodes.visualizer.digram.header",
+  "hex.builtin.nodes.visualizer.image",
+  "hex.builtin.nodes.visualizer.image.header",
+  "hex.builtin.nodes.visualizer.image_rgba",
+  "hex.builtin.nodes.visualizer.image_rgba.header",
+  "hex.builtin.nodes.visualizer.layered_dist",
+  "hex.builtin.nodes.visualizer.layered_dist.header",
+  "hex.builtin.pattern_drawer.color",
+  "hex.builtin.pattern_drawer.double_click",
+  "hex.builtin.pattern_drawer.offset",
+  "hex.builtin.pattern_drawer.size",
+  "hex.builtin.pattern_drawer.type",
+  "hex.builtin.pattern_drawer.value",
+  "hex.builtin.pattern_drawer.var_name",
+  "hex.builtin.pattern_drawer.visualizer.unknown",
+  "hex.builtin.pattern_drawer.visualizer.invalid_parameter_count",
+  "hex.builtin.popup.close_provider.desc",
+  "hex.builtin.popup.close_provider.title",
+  "hex.builtin.popup.error.create",
+  "hex.builtin.popup.error.file_dialog.common",
+  "hex.builtin.popup.error.file_dialog.portal",
+  "hex.builtin.popup.error.open",
+  "hex.builtin.popup.error.project.load",
+  "hex.builtin.popup.error.project.save",
+  "hex.builtin.popup.error.read_only",
+  "hex.builtin.popup.error.task_exception",
+  "hex.builtin.popup.exit_application.desc",
+  "hex.builtin.popup.exit_application.title",
+  "hex.builtin.popup.waiting_for_tasks.title",
+  "hex.builtin.popup.waiting_for_tasks.desc",
+  "hex.builtin.provider.disk",
+  "hex.builtin.provider.disk.disk_size",
+  "hex.builtin.provider.disk.reload",
+  "hex.builtin.provider.disk.sector_size",
+  "hex.builtin.provider.disk.selected_disk",
+  "hex.builtin.provider.file",
+  "hex.builtin.provider.file.access",
+  "hex.builtin.provider.file.creation",
+  "hex.builtin.provider.file.modification",
+  "hex.builtin.provider.file.path",
+  "hex.builtin.provider.file.size",
+  "hex.builtin.provider.gdb",
+  "hex.builtin.provider.gdb.ip",
+  "hex.builtin.provider.gdb.name",
+  "hex.builtin.provider.gdb.port",
+  "hex.builtin.provider.gdb.server",
+  "hex.builtin.provider.intel_hex",
+  "hex.builtin.provider.intel_hex.name",
+  "hex.builtin.provider.mem_file",
+  "hex.builtin.provider.mem_file.unsaved",
+  "hex.builtin.provider.motorola_srec",
+  "hex.builtin.provider.motorola_srec.name",
+  "hex.builtin.provider.view",
+  "hex.builtin.setting.folders",
+  "hex.builtin.setting.folders.add_folder",
+  "hex.builtin.setting.folders.description",
+  "hex.builtin.setting.folders.remove_folder",
+  "hex.builtin.setting.font",
+  "hex.builtin.setting.font.font_path",
+  "hex.builtin.setting.font.font_size",
+  "hex.builtin.setting.general",
+  "hex.builtin.setting.general.auto_load_patterns",
+  "hex.builtin.setting.general.check_for_updates",
+  "hex.builtin.setting.general.enable_unicode",
+  "hex.builtin.setting.general.show_tips",
+  "hex.builtin.setting.general.sync_pattern_source",
+  "hex.builtin.setting.hex_editor",
+  "hex.builtin.setting.hex_editor.advanced_decoding",
+  "hex.builtin.setting.hex_editor.ascii",
+  "hex.builtin.setting.hex_editor.byte_padding",
+  "hex.builtin.setting.hex_editor.bytes_per_row",
+  "hex.builtin.setting.hex_editor.char_padding",
+  "hex.builtin.setting.hex_editor.grey_zeros",
+  "hex.builtin.setting.hex_editor.highlight_color",
+  "hex.builtin.setting.hex_editor.sync_scrolling",
+  "hex.builtin.setting.hex_editor.uppercase_hex",
+  "hex.builtin.setting.hex_editor.visualizer",
+  "hex.builtin.setting.imhex",
+  "hex.builtin.setting.imhex.recent_files",
+  "hex.builtin.setting.interface",
+  "hex.builtin.setting.interface.color",
+  "hex.builtin.setting.interface.fps",
+  "hex.builtin.setting.interface.fps.unlocked",
+  "hex.builtin.setting.interface.language",
+  "hex.builtin.setting.interface.multi_windows",
+  "hex.builtin.setting.interface.pattern_tree_style",
+  "hex.builtin.setting.interface.pattern_tree_style.tree",
+  "hex.builtin.setting.interface.pattern_tree_style.auto_expanded",
+  "hex.builtin.setting.interface.pattern_tree_style.flattened",
+  "hex.builtin.setting.interface.scaling",
+  "hex.builtin.setting.interface.scaling.native",
+  "hex.builtin.setting.interface.scaling.x0_5",
+  "hex.builtin.setting.interface.scaling.x1_0",
+  "hex.builtin.setting.interface.scaling.x1_5",
+  "hex.builtin.setting.interface.scaling.x2_0",
+  "hex.builtin.setting.interface.scaling.x3_0",
+  "hex.builtin.setting.interface.scaling.x4_0",
+  "hex.builtin.setting.interface.wiki_explain_language",
+  "hex.builtin.setting.proxy",
+  "hex.builtin.setting.proxy.description",
+  "hex.builtin.setting.proxy.enable",
+  "hex.builtin.setting.proxy.url",
+  "hex.builtin.setting.proxy.url.tooltip",
+  "hex.builtin.tools.ascii_table",
+  "hex.builtin.tools.ascii_table.octal",
+  "hex.builtin.tools.base_converter",
+  "hex.builtin.tools.base_converter.bin",
+  "hex.builtin.tools.base_converter.dec",
+  "hex.builtin.tools.base_converter.hex",
+  "hex.builtin.tools.base_converter.oct",
+  "hex.builtin.tools.calc",
+  "hex.builtin.tools.color",
+  "hex.builtin.tools.demangler",
+  "hex.builtin.tools.demangler.demangled",
+  "hex.builtin.tools.demangler.mangled",
+  "hex.builtin.tools.error",
+  "hex.builtin.tools.file_tools",
+  "hex.builtin.tools.file_tools.combiner",
+  "hex.builtin.tools.file_tools.combiner.add",
+  "hex.builtin.tools.file_tools.combiner.add.picker",
+  "hex.builtin.tools.file_tools.combiner.clear",
+  "hex.builtin.tools.file_tools.combiner.combine",
+  "hex.builtin.tools.file_tools.combiner.combining",
+  "hex.builtin.tools.file_tools.combiner.delete",
+  "hex.builtin.tools.file_tools.combiner.error.open_output",
+  "hex.builtin.tools.file_tools.combiner.open_input",
+  "hex.builtin.tools.file_tools.combiner.output",
+  "hex.builtin.tools.file_tools.combiner.output.picker",
+  "hex.builtin.tools.file_tools.combiner.success",
+  "hex.builtin.tools.file_tools.shredder",
+  "hex.builtin.tools.file_tools.shredder.error.open",
+  "hex.builtin.tools.file_tools.shredder.fast",
+  "hex.builtin.tools.file_tools.shredder.input",
+  "hex.builtin.tools.file_tools.shredder.picker",
+  "hex.builtin.tools.file_tools.shredder.shred",
+  "hex.builtin.tools.file_tools.shredder.shredding",
+  "hex.builtin.tools.file_tools.shredder.success",
+  "hex.builtin.tools.file_tools.shredder.warning",
+  "hex.builtin.tools.file_tools.splitter",
+  "hex.builtin.tools.file_tools.splitter.input",
+  "hex.builtin.tools.file_tools.splitter.output",
+  "hex.builtin.tools.file_tools.splitter.picker.error.create",
+  "hex.builtin.tools.file_tools.splitter.picker.error.open",
+  "hex.builtin.tools.file_tools.splitter.picker.error.size",
+  "hex.builtin.tools.file_tools.splitter.picker.input",
+  "hex.builtin.tools.file_tools.splitter.picker.output",
+  "hex.builtin.tools.file_tools.splitter.picker.split",
+  "hex.builtin.tools.file_tools.splitter.picker.splitting",
+  "hex.builtin.tools.file_tools.splitter.picker.success",
+  "hex.builtin.tools.file_tools.splitter.sizes.3_5_floppy",
+  "hex.builtin.tools.file_tools.splitter.sizes.5_75_floppy",
+  "hex.builtin.tools.file_tools.splitter.sizes.cdrom650",
+  "hex.builtin.tools.file_tools.splitter.sizes.cdrom700",
+  "hex.builtin.tools.file_tools.splitter.sizes.custom",
+  "hex.builtin.tools.file_tools.splitter.sizes.fat32",
+  "hex.builtin.tools.file_tools.splitter.sizes.zip100",
+  "hex.builtin.tools.file_tools.splitter.sizes.zip200",
+  "hex.builtin.tools.file_uploader",
+  "hex.builtin.tools.file_uploader.control",
+  "hex.builtin.tools.file_uploader.done",
+  "hex.builtin.tools.file_uploader.error",
+  "hex.builtin.tools.file_uploader.invalid_response",
+  "hex.builtin.tools.file_uploader.recent",
+  "hex.builtin.tools.file_uploader.tooltip",
+  "hex.builtin.tools.file_uploader.upload",
+  "hex.builtin.tools.format.engineering",
+  "hex.builtin.tools.format.programmer",
+  "hex.builtin.tools.format.scientific",
+  "hex.builtin.tools.format.standard",
+  "hex.builtin.tools.history",
+  "hex.builtin.tools.ieee754",
+  "hex.builtin.tools.ieee754.description",
+  "hex.builtin.tools.ieee754.double_precision",
+  "hex.builtin.tools.ieee754.exponent",
+  "hex.builtin.tools.ieee754.exponent_size",
+  "hex.builtin.tools.ieee754.formula",
+  "hex.builtin.tools.ieee754.half_precision",
+  "hex.builtin.tools.ieee754.mantissa",
+  "hex.builtin.tools.ieee754.mantissa_size",
+  "hex.builtin.tools.ieee754.result.float",
+  "hex.builtin.tools.ieee754.result.hex",
+  "hex.builtin.tools.ieee754.result.title",
+  "hex.builtin.tools.ieee754.sign",
+  "hex.builtin.tools.ieee754.singe_precision",
+  "hex.builtin.tools.ieee754.type",
+  "hex.builtin.tools.invariant_multiplication",
+  "hex.builtin.tools.invariant_multiplication.description",
+  "hex.builtin.tools.invariant_multiplication.num_bits",
+  "hex.builtin.tools.input",
+  "hex.builtin.tools.name",
+  "hex.builtin.tools.permissions",
+  "hex.builtin.tools.permissions.absolute",
+  "hex.builtin.tools.permissions.perm_bits",
+  "hex.builtin.tools.permissions.setgid_error",
+  "hex.builtin.tools.permissions.setuid_error",
+  "hex.builtin.tools.permissions.sticky_error",
+  "hex.builtin.tools.regex_replacer",
+  "hex.builtin.tools.regex_replacer.input",
+  "hex.builtin.tools.regex_replacer.output",
+  "hex.builtin.tools.regex_replacer.pattern",
+  "hex.builtin.tools.regex_replacer.replace",
+  "hex.builtin.tools.value",
+  "hex.builtin.tools.wiki_explain",
+  "hex.builtin.tools.wiki_explain.control",
+  "hex.builtin.tools.wiki_explain.invalid_response",
+  "hex.builtin.tools.wiki_explain.results",
+  "hex.builtin.tools.wiki_explain.search",
+  "hex.builtin.view.bookmarks.address",
+  "hex.builtin.view.bookmarks.button.jump",
+  "hex.builtin.view.bookmarks.button.remove",
+  "hex.builtin.view.bookmarks.default_title",
+  "hex.builtin.view.bookmarks.header.color",
+  "hex.builtin.view.bookmarks.header.comment",
+  "hex.builtin.view.bookmarks.header.name",
+  "hex.builtin.view.bookmarks.name",
+  "hex.builtin.view.bookmarks.no_bookmarks",
+  "hex.builtin.view.bookmarks.title.info",
+  "hex.builtin.view.command_palette.name",
+  "hex.builtin.view.constants.name",
+  "hex.builtin.view.constants.row.category",
+  "hex.builtin.view.constants.row.desc",
+  "hex.builtin.view.constants.row.name",
+  "hex.builtin.view.constants.row.value",
+  "hex.builtin.view.data_inspector.invert",
+  "hex.builtin.view.data_inspector.name",
+  "hex.builtin.view.data_inspector.no_data",
+  "hex.builtin.view.data_inspector.table.name",
+  "hex.builtin.view.data_inspector.table.value",
+  "hex.builtin.view.data_processor.help_text",
+  "hex.builtin.view.data_processor.menu.file.load_processor",
+  "hex.builtin.view.data_processor.menu.file.save_processor",
+  "hex.builtin.view.data_processor.menu.remove_link",
+  "hex.builtin.view.data_processor.menu.remove_node",
+  "hex.builtin.view.data_processor.menu.remove_selection",
+  "hex.builtin.view.data_processor.name",
+  "hex.builtin.view.diff.name",
+  "hex.builtin.view.disassembler.16bit",
+  "hex.builtin.view.disassembler.32bit",
+  "hex.builtin.view.disassembler.64bit",
+  "hex.builtin.view.disassembler.arch",
+  "hex.builtin.view.disassembler.arm.arm",
+  "hex.builtin.view.disassembler.arm.armv8",
+  "hex.builtin.view.disassembler.arm.cortex_m",
+  "hex.builtin.view.disassembler.arm.default",
+  "hex.builtin.view.disassembler.arm.thumb",
+  "hex.builtin.view.disassembler.base",
+  "hex.builtin.view.disassembler.bpf.classic",
+  "hex.builtin.view.disassembler.bpf.extended",
+  "hex.builtin.view.disassembler.disassemble",
+  "hex.builtin.view.disassembler.disassembling",
+  "hex.builtin.view.disassembler.disassembly.address",
+  "hex.builtin.view.disassembler.disassembly.bytes",
+  "hex.builtin.view.disassembler.disassembly.offset",
+  "hex.builtin.view.disassembler.disassembly.title",
+  "hex.builtin.view.disassembler.m680x.6301",
+  "hex.builtin.view.disassembler.m680x.6309",
+  "hex.builtin.view.disassembler.m680x.6800",
+  "hex.builtin.view.disassembler.m680x.6801",
+  "hex.builtin.view.disassembler.m680x.6805",
+  "hex.builtin.view.disassembler.m680x.6808",
+  "hex.builtin.view.disassembler.m680x.6809",
+  "hex.builtin.view.disassembler.m680x.6811",
+  "hex.builtin.view.disassembler.m680x.cpu12",
+  "hex.builtin.view.disassembler.m680x.hcs08",
+  "hex.builtin.view.disassembler.m68k.000",
+  "hex.builtin.view.disassembler.m68k.010",
+  "hex.builtin.view.disassembler.m68k.020",
+  "hex.builtin.view.disassembler.m68k.030",
+  "hex.builtin.view.disassembler.m68k.040",
+  "hex.builtin.view.disassembler.m68k.060",
+  "hex.builtin.view.disassembler.mips.micro",
+  "hex.builtin.view.disassembler.mips.mips2",
+  "hex.builtin.view.disassembler.mips.mips3",
+  "hex.builtin.view.disassembler.mips.mips32",
+  "hex.builtin.view.disassembler.mips.mips32R6",
+  "hex.builtin.view.disassembler.mips.mips64",
+  "hex.builtin.view.disassembler.mos65xx.6502",
+  "hex.builtin.view.disassembler.mos65xx.65816",
+  "hex.builtin.view.disassembler.mos65xx.65816_long_m",
+  "hex.builtin.view.disassembler.mos65xx.65816_long_mx",
+  "hex.builtin.view.disassembler.mos65xx.65816_long_x",
+  "hex.builtin.view.disassembler.mos65xx.65c02",
+  "hex.builtin.view.disassembler.mos65xx.w65c02",
+  "hex.builtin.view.disassembler.name",
+  "hex.builtin.view.disassembler.position",
+  "hex.builtin.view.disassembler.ppc.booke",
+  "hex.builtin.view.disassembler.ppc.qpx",
+  "hex.builtin.view.disassembler.ppc.spe",
+  "hex.builtin.view.disassembler.region",
+  "hex.builtin.view.disassembler.riscv.compressed",
+  "hex.builtin.view.disassembler.settings.header",
+  "hex.builtin.view.disassembler.settings.mode",
+  "hex.builtin.view.disassembler.sparc.v9",
+  "hex.builtin.view.find.binary_pattern",
+  "hex.builtin.view.find.context.copy",
+  "hex.builtin.view.find.context.copy_demangle",
+  "hex.builtin.view.find.demangled",
+  "hex.builtin.view.find.name",
+  "hex.builtin.view.find.regex",
+  "hex.builtin.view.find.regex.full_match",
+  "hex.builtin.view.find.regex.pattern",
+  "hex.builtin.view.find.search",
+  "hex.builtin.view.find.search.entries",
+  "hex.builtin.view.find.search.reset",
+  "hex.builtin.view.find.searching",
+  "hex.builtin.view.find.sequences",
+  "hex.builtin.view.find.strings",
+  "hex.builtin.view.find.strings.chars",
+  "hex.builtin.view.find.strings.line_feeds",
+  "hex.builtin.view.find.strings.lower_case",
+  "hex.builtin.view.find.strings.match_settings",
+  "hex.builtin.view.find.strings.min_length",
+  "hex.builtin.view.find.strings.null_term",
+  "hex.builtin.view.find.strings.numbers",
+  "hex.builtin.view.find.strings.spaces",
+  "hex.builtin.view.find.strings.symbols",
+  "hex.builtin.view.find.strings.underscores",
+  "hex.builtin.view.find.strings.upper_case",
+  "hex.builtin.view.find.value",
+  "hex.builtin.view.find.value.max",
+  "hex.builtin.view.find.value.min",
+  "hex.builtin.view.hashes.function",
+  "hex.builtin.view.hashes.hash",
+  "hex.builtin.view.hashes.hover_info",
+  "hex.builtin.view.hashes.name",
+  "hex.builtin.view.hashes.no_settings",
+  "hex.builtin.view.hashes.remove",
+  "hex.builtin.view.hashes.table.name",
+  "hex.builtin.view.hashes.table.result",
+  "hex.builtin.view.hashes.table.type",
+  "hex.builtin.view.help.about.contributor",
+  "hex.builtin.view.help.about.donations",
+  "hex.builtin.view.help.about.libs",
+  "hex.builtin.view.help.about.license",
+  "hex.builtin.view.help.about.name",
+  "hex.builtin.view.help.about.paths",
+  "hex.builtin.view.help.about.source",
+  "hex.builtin.view.help.about.thanks",
+  "hex.builtin.view.help.about.translator",
+  "hex.builtin.view.help.calc_cheat_sheet",
+  "hex.builtin.view.help.documentation",
+  "hex.builtin.view.help.name",
+  "hex.builtin.view.help.pattern_cheat_sheet",
+  "hex.builtin.view.hex_editor.copy.address",
+  "hex.builtin.view.hex_editor.copy.ascii",
+  "hex.builtin.view.hex_editor.copy.base64",
+  "hex.builtin.view.hex_editor.copy.c",
+  "hex.builtin.view.hex_editor.copy.cpp",
+  "hex.builtin.view.hex_editor.copy.crystal",
+  "hex.builtin.view.hex_editor.copy.csharp",
+  "hex.builtin.view.hex_editor.copy.custom_encoding",
+  "hex.builtin.view.hex_editor.copy.go",
+  "hex.builtin.view.hex_editor.copy.hex_view",
+  "hex.builtin.view.hex_editor.copy.html",
+  "hex.builtin.view.hex_editor.copy.java",
+  "hex.builtin.view.hex_editor.copy.js",
+  "hex.builtin.view.hex_editor.copy.lua",
+  "hex.builtin.view.hex_editor.copy.pascal",
+  "hex.builtin.view.hex_editor.copy.python",
+  "hex.builtin.view.hex_editor.copy.rust",
+  "hex.builtin.view.hex_editor.copy.swift",
+  "hex.builtin.view.hex_editor.goto.offset.absolute",
+  "hex.builtin.view.hex_editor.goto.offset.begin",
+  "hex.builtin.view.hex_editor.goto.offset.end",
+  "hex.builtin.view.hex_editor.goto.offset.relative",
+  "hex.builtin.view.hex_editor.menu.edit.copy",
+  "hex.builtin.view.hex_editor.menu.edit.copy_as",
+  "hex.builtin.view.hex_editor.menu.edit.insert",
+  "hex.builtin.view.hex_editor.menu.edit.jump_to",
+  "hex.builtin.view.hex_editor.menu.edit.open_in_new_provider",
+  "hex.builtin.view.hex_editor.menu.edit.paste",
+  "hex.builtin.view.hex_editor.menu.edit.paste_all",
+  "hex.builtin.view.hex_editor.menu.edit.remove",
+  "hex.builtin.view.hex_editor.menu.edit.resize",
+  "hex.builtin.view.hex_editor.menu.edit.select_all",
+  "hex.builtin.view.hex_editor.menu.edit.set_base",
+  "hex.builtin.view.hex_editor.menu.file.goto",
+  "hex.builtin.view.hex_editor.menu.file.load_encoding_file",
+  "hex.builtin.view.hex_editor.menu.file.save",
+  "hex.builtin.view.hex_editor.menu.file.save_as",
+  "hex.builtin.view.hex_editor.menu.file.search",
+  "hex.builtin.view.hex_editor.menu.file.select",
+  "hex.builtin.view.hex_editor.name",
+  "hex.builtin.view.hex_editor.search.find",
+  "hex.builtin.view.hex_editor.search.hex",
+  "hex.builtin.view.hex_editor.search.string",
+  "hex.builtin.view.hex_editor.select.offset.begin",
+  "hex.builtin.view.hex_editor.select.offset.end",
+  "hex.builtin.view.hex_editor.select.offset.region",
+  "hex.builtin.view.hex_editor.select.offset.size",
+  "hex.builtin.view.hex_editor.select.select",
+  "hex.builtin.view.information.analyze",
+  "hex.builtin.view.information.analyzing",
+  "hex.builtin.view.information.block_size",
+  "hex.builtin.view.information.block_size.desc",
+  "hex.builtin.view.information.byte_types",
+  "hex.builtin.view.information.control",
+  "hex.builtin.view.information.description",
+  "hex.builtin.view.information.digram",
+  "hex.builtin.view.information.distribution",
+  "hex.builtin.view.information.encrypted",
+  "hex.builtin.view.information.entropy",
+  "hex.builtin.view.information.file_entropy",
+  "hex.builtin.view.information.highest_entropy",
+  "hex.builtin.view.information.info_analysis",
+  "hex.builtin.view.information.layered_distribution",
+  "hex.builtin.view.information.magic",
+  "hex.builtin.view.information.magic_db_added",
+  "hex.builtin.view.information.mime",
+  "hex.builtin.view.information.name",
+  "hex.builtin.view.information.region",
+  "hex.builtin.view.information.plain_text",
+  "hex.builtin.view.information.plain_text_percentage",
+  "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.builtin.view.pattern_data.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.auto",
+  "hex.builtin.view.pattern_editor.console",
+  "hex.builtin.view.pattern_editor.dangerous_function.desc",
+  "hex.builtin.view.pattern_editor.dangerous_function.name",
+  "hex.builtin.view.pattern_editor.env_vars",
+  "hex.builtin.view.pattern_editor.evaluating",
+  "hex.builtin.view.pattern_editor.menu.edit.place_pattern",
+  "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin",
+  "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin.array",
+  "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin.single",
+  "hex.builtin.view.pattern_editor.menu.edit.place_pattern.custom",
+  "hex.builtin.view.pattern_editor.menu.file.load_pattern",
+  "hex.builtin.view.pattern_editor.menu.file.save_pattern",
+  "hex.builtin.view.pattern_editor.name",
+  "hex.builtin.view.pattern_editor.no_in_out_vars",
+  "hex.builtin.view.pattern_editor.open_pattern",
+  "hex.builtin.view.pattern_editor.section_popup",
+  "hex.builtin.view.pattern_editor.sections",
+  "hex.builtin.view.pattern_editor.settings",
+  "hex.builtin.view.provider_settings.load_error",
+  "hex.builtin.view.provider_settings.load_popup",
+  "hex.builtin.view.provider_settings.name",
+  "hex.builtin.view.settings.name",
+  "hex.builtin.view.settings.restart_question",
+  "hex.builtin.view.store.desc",
+  "hex.builtin.view.store.download",
+  "hex.builtin.view.store.download_error",
+  "hex.builtin.view.store.loading",
+  "hex.builtin.view.store.name",
+  "hex.builtin.view.store.netfailed",
+  "hex.builtin.view.store.reload",
+  "hex.builtin.view.store.remove",
+  "hex.builtin.view.store.row.description",
+  "hex.builtin.view.store.row.name",
+  "hex.builtin.view.store.tab.constants",
+  "hex.builtin.view.store.tab.encodings",
+  "hex.builtin.view.store.tab.libraries",
+  "hex.builtin.view.store.tab.magics",
+  "hex.builtin.view.store.tab.patterns",
+  "hex.builtin.view.store.tab.yara",
+  "hex.builtin.view.store.update",
+  "hex.builtin.view.tools.name",
+  "hex.builtin.view.yara.error",
+  "hex.builtin.view.yara.header.matches",
+  "hex.builtin.view.yara.header.rules",
+  "hex.builtin.view.yara.match",
+  "hex.builtin.view.yara.matches.identifier",
+  "hex.builtin.view.yara.matches.variable",
+  "hex.builtin.view.yara.matching",
+  "hex.builtin.view.yara.name",
+  "hex.builtin.view.yara.no_rules",
+  "hex.builtin.view.yara.reload",
+  "hex.builtin.view.yara.reset",
+  "hex.builtin.view.yara.rule_added",
+  "hex.builtin.view.yara.whole_data",
+  "hex.builtin.visualizer.decimal.signed.16bit",
+  "hex.builtin.visualizer.decimal.signed.32bit",
+  "hex.builtin.visualizer.decimal.signed.64bit",
+  "hex.builtin.visualizer.decimal.signed.8bit",
+  "hex.builtin.visualizer.decimal.unsigned.16bit",
+  "hex.builtin.visualizer.decimal.unsigned.32bit",
+  "hex.builtin.visualizer.decimal.unsigned.64bit",
+  "hex.builtin.visualizer.decimal.unsigned.8bit",
+  "hex.builtin.visualizer.floating_point.16bit",
+  "hex.builtin.visualizer.floating_point.32bit",
+  "hex.builtin.visualizer.floating_point.64bit",
+  "hex.builtin.visualizer.hexadecimal.16bit",
+  "hex.builtin.visualizer.hexadecimal.32bit",
+  "hex.builtin.visualizer.hexadecimal.64bit",
+  "hex.builtin.visualizer.hexadecimal.8bit",
+  "hex.builtin.visualizer.hexii",
+  "hex.builtin.visualizer.rgba8",
+  "hex.builtin.welcome.check_for_updates_text",
+  "hex.builtin.welcome.customize.settings.desc",
+  "hex.builtin.welcome.customize.settings.title",
+  "hex.builtin.welcome.header.customize",
+  "hex.builtin.welcome.header.help",
+  "hex.builtin.welcome.header.learn",
+  "hex.builtin.welcome.header.main",
+  "hex.builtin.welcome.header.plugins",
+  "hex.builtin.welcome.header.start",
+  "hex.builtin.welcome.header.update",
+  "hex.builtin.welcome.header.various",
+  "hex.builtin.welcome.help.discord",
+  "hex.builtin.welcome.help.discord.link",
+  "hex.builtin.welcome.help.gethelp",
+  "hex.builtin.welcome.help.gethelp.link",
+  "hex.builtin.welcome.help.repo",
+  "hex.builtin.welcome.help.repo.link",
+  "hex.builtin.welcome.learn.latest.desc",
+  "hex.builtin.welcome.learn.latest.link",
+  "hex.builtin.welcome.learn.latest.title",
+  "hex.builtin.welcome.learn.pattern.desc",
+  "hex.builtin.welcome.learn.pattern.link",
+  "hex.builtin.welcome.learn.pattern.title",
+  "hex.builtin.welcome.learn.plugins.desc",
+  "hex.builtin.welcome.learn.plugins.link",
+  "hex.builtin.welcome.learn.plugins.title",
+  "hex.builtin.welcome.plugins.author",
+  "hex.builtin.welcome.plugins.desc",
+  "hex.builtin.welcome.plugins.plugin",
+  "hex.builtin.welcome.safety_backup.delete",
+  "hex.builtin.welcome.safety_backup.desc",
+  "hex.builtin.welcome.safety_backup.restore",
+  "hex.builtin.welcome.safety_backup.title",
+  "hex.builtin.welcome.start.create_file",
+  "hex.builtin.welcome.start.open_file",
+  "hex.builtin.welcome.start.open_other",
+  "hex.builtin.welcome.start.open_project",
+  "hex.builtin.welcome.start.recent",
+  "hex.builtin.welcome.tip_of_the_day",
+  "hex.builtin.welcome.update.desc",
+  "hex.builtin.welcome.update.link",
+  "hex.builtin.welcome.update.title"
+]

plugins/builtin/romfs/lang/de_DE.json

@@ -12,6 +12,7 @@
         "hex.builtin.common.big": "Big",
         "hex.builtin.common.big_endian": "Big Endian",
         "hex.builtin.common.browse": "Durchsuchen...",
+        "hex.builtin.common.bytes": "Bytes",
         "hex.builtin.common.cancel": "Abbrechen",
         "hex.builtin.common.choose_file": "Datei auswählen",
         "hex.builtin.common.close": "Schliessen",
@@ -30,6 +31,7 @@
         "hex.builtin.common.filter": "Filter",
         "hex.builtin.common.hexadecimal": "Hexadezimal",
         "hex.builtin.common.info": "Information",
+        "hex.builtin.common.instruction": "Instruktion",
         "hex.builtin.common.link": "Link",
         "hex.builtin.common.little": "Little",
         "hex.builtin.common.little_endian": "Little Endian",
@@ -133,8 +135,15 @@
         "hex.builtin.menu.file.close": "Schliessen",
         "hex.builtin.menu.file.create_file": "Neue Datei...",
         "hex.builtin.menu.file.export": "Exportieren...",
-        "hex.builtin.menu.file.export.base64.popup.export_error": "Datei hat kein gültiges Base64 Format!",
+        "hex.builtin.menu.file.export.base64": "Base64",
+        "hex.builtin.menu.file.export.base64.popup.export_error": "Erstellen der Base64 Datei fehlgeschlagen!",
         "hex.builtin.menu.file.export.ips": "IPS Patch",
+        "hex.builtin.menu.file.export.ips.popup.address_out_of_range_error": "Ein Patch hat versucht eine Adresse zu patchen, welche nicht vorhanden ist!",
+        "hex.builtin.menu.file.export.ips.popup.export_error": "Erstellen der IPS Datei fehlgeschlagen!",
+        "hex.builtin.menu.file.export.ips.popup.invalid_patch_format_error": "Invalides IPS Patch Format!",
+        "hex.builtin.menu.file.export.ips.popup.invalid_patch_header_error": "Invalider IPS Patch Header!",
+        "hex.builtin.menu.file.export.ips.popup.missing_eof_error": "Fehlender IPS EOF Eintrag!",
+        "hex.builtin.menu.file.export.ips.popup.patch_too_large_error": "Ein Patch war grösser als die maximal erlaubte Grösse!",
         "hex.builtin.menu.file.export.ips32": "IPS32 Patch",
         "hex.builtin.menu.file.export.popup.create": "Daten konnten nicht exportiert werden. Datei konnte nicht erstellt werden!",
         "hex.builtin.menu.file.export.title": "Datei exportieren",
@@ -309,6 +318,8 @@
         "hex.builtin.pattern_drawer.type": "Typ",
         "hex.builtin.pattern_drawer.value": "Wert",
         "hex.builtin.pattern_drawer.var_name": "Name",
+        "hex.builtin.pattern_drawer.visualizer.invalid_parameter_count": "Falsche anzahl Parameter",
+        "hex.builtin.pattern_drawer.visualizer.unknown": "Unbekannter Visualizer",
         "hex.builtin.popup.close_provider.desc": "Es wurden ungespeicherte Änderungen an diesem Provider vorgenommen.\nBist du sicher, dass du ihn schliessen willst?",
         "hex.builtin.popup.close_provider.title": "Provider schliessen?",
         "hex.builtin.popup.error.create": "Erstellen der neuen Datei fehlgeschlagen!",
@@ -376,6 +387,10 @@
         "hex.builtin.setting.interface.fps.unlocked": "Unbegrenzt",
         "hex.builtin.setting.interface.language": "Sprache",
         "hex.builtin.setting.interface.multi_windows": "Multi-Window-Unterstützung aktivieren",
+        "hex.builtin.setting.interface.pattern_tree_style": "Pattern Baum Style",
+        "hex.builtin.setting.interface.pattern_tree_style.auto_expanded": "Automatisch geöffneter Baum",
+        "hex.builtin.setting.interface.pattern_tree_style.flattened": "Flach",
+        "hex.builtin.setting.interface.pattern_tree_style.tree": "Baum",
         "hex.builtin.setting.interface.scaling": "Skalierung",
         "hex.builtin.setting.interface.scaling.native": "Nativ",
         "hex.builtin.setting.interface.scaling.x0_5": "x0.5",
@@ -457,21 +472,25 @@
         "hex.builtin.tools.format.scientific": "Wissenschaftlich",
         "hex.builtin.tools.format.standard": "Standard",
         "hex.builtin.tools.history": "Verlauf",
-        "hex.builtin.tools.ieee756": "IEEE 756 Gleitkommazahl Tester",
-        "hex.builtin.tools.ieee756.double_precision": "Doppelte Genauigkeit",
-        "hex.builtin.tools.ieee756.exponent": "Exponent",
-        "hex.builtin.tools.ieee756.exponent_size": "Exponentengrösse",
-        "hex.builtin.tools.ieee756.formula": "Formel",
-        "hex.builtin.tools.ieee756.half_precision": "Halbe Genauigkeit",
-        "hex.builtin.tools.ieee756.mantissa": "Mantisse",
-        "hex.builtin.tools.ieee756.mantissa_size": "Mantissengrösse",
-        "hex.builtin.tools.ieee756.result.float": "Gleitkomma Resultat",
-        "hex.builtin.tools.ieee756.result.hex": "Hexadezimal Resultat",
-        "hex.builtin.tools.ieee756.result.title": "Resultat",
-        "hex.builtin.tools.ieee756.sign": "Vorzeichen",
-        "hex.builtin.tools.ieee756.singe_precision": "Einfache Genauigkeit",
-        "hex.builtin.tools.ieee756.type": "Typ",
+        "hex.builtin.tools.ieee754": "IEEE 754 Gleitkommazahl Tester",
+        "hex.builtin.tools.ieee754.description": "IEEE754 ist ein Standart zum representieren von Fliesskommazahlen welcher von den meisten modernen CPUs verwendet wird.\n\nDieses Tool visualisiert den internen aufbau einer Fliesskommazahl und ermöglicht das decodieren von Zahlen, welche eine nicht-standardmässige Anzahl von Mantissa oder Exponenten bits benutzen.",
+        "hex.builtin.tools.ieee754.double_precision": "Doppelte Genauigkeit",
+        "hex.builtin.tools.ieee754.exponent": "Exponent",
+        "hex.builtin.tools.ieee754.exponent_size": "Exponentengrösse",
+        "hex.builtin.tools.ieee754.formula": "Formel",
+        "hex.builtin.tools.ieee754.half_precision": "Halbe Genauigkeit",
+        "hex.builtin.tools.ieee754.mantissa": "Mantisse",
+        "hex.builtin.tools.ieee754.mantissa_size": "Mantissengrösse",
+        "hex.builtin.tools.ieee754.result.float": "Gleitkomma Resultat",
+        "hex.builtin.tools.ieee754.result.hex": "Hexadezimal Resultat",
+        "hex.builtin.tools.ieee754.result.title": "Resultat",
+        "hex.builtin.tools.ieee754.sign": "Vorzeichen",
+        "hex.builtin.tools.ieee754.singe_precision": "Einfache Genauigkeit",
+        "hex.builtin.tools.ieee754.type": "Typ",
         "hex.builtin.tools.input": "Input",
+        "hex.builtin.tools.invariant_multiplication": "Division durch invariante Multiplikation",
+        "hex.builtin.tools.invariant_multiplication.description": "Division durch invariante Multiplikation ist eine Technik, welche häuffig von Compilern verwendet wird um divisionen durch konstante Ganzzahlen in eine Multiplikation und ein Bitshift zu optimieren. Der Grund dafür ist, dass Divisionen meistens viel mehr Clock Zyklen benötigen als Multiplikationen.\n\nDieses Tool kann benutzt werden um diese Divisionen in Multiplikationen umzuwandeln und umgekehrt.",
+        "hex.builtin.tools.invariant_multiplication.num_bits": "Anzahl Bits",
         "hex.builtin.tools.name": "Name",
         "hex.builtin.tools.permissions": "UNIX Berechtigungsrechner",
         "hex.builtin.tools.permissions.absolute": "Absolute Notation",
@@ -634,7 +653,7 @@
         "hex.builtin.view.hex_editor.copy.crystal": "Crystal Array",
         "hex.builtin.view.hex_editor.copy.csharp": "C# Array",
         "hex.builtin.view.hex_editor.copy.go": "Go Array",
-        "hex.builtin.view.hex_editor.copy.hex": "Hex String",
+        "hex.builtin.view.hex_editor.copy.ascuu": "Hex String",
         "hex.builtin.view.hex_editor.copy.html": "HTML",
         "hex.builtin.view.hex_editor.copy.java": "Java Array",
         "hex.builtin.view.hex_editor.copy.js": "JavaScript Array",
@@ -692,9 +711,9 @@
         "hex.builtin.view.information.magic_db_added": "Magic Datenbank hinzugefügt!",
         "hex.builtin.view.information.mime": "MIME Typ:",
         "hex.builtin.view.information.name": "Dateninformationen",
-        "hex.builtin.view.information.region": "Analysierte Region",
         "hex.builtin.view.information.plain_text": "Diese Daten sind vermutlich einfacher Text.",
         "hex.builtin.view.information.plain_text_percentage": "Klartext Prozentanteil",
+        "hex.builtin.view.information.region": "Analysierte Region",
         "hex.builtin.view.patches.name": "Patches",
         "hex.builtin.view.patches.offset": "Offset",
         "hex.builtin.view.patches.orig": "Originalwert",
@@ -818,6 +837,10 @@
         "hex.builtin.welcome.tip_of_the_day": "Tipp des Tages",
         "hex.builtin.welcome.update.desc": "ImHex {0} wurde gerade released! Downloade die neue Version hier",
         "hex.builtin.welcome.update.link": "https://github.com/WerWolv/ImHex/releases/latest",
-        "hex.builtin.welcome.update.title": "Neues Update verfügbar!"
+        "hex.builtin.welcome.update.title": "Neues Update verfügbar!",
+        "hex.builtin.popup.waiting_for_tasks.title": "Warten auf Tasks",
+        "hex.builtin.popup.waiting_for_tasks.desc": "Einige Tasks laufen immer noch im Hintergrund.\nImHex wird geschlossen, nachdem diese Abgeschlossen wurden.",
+        "hex.builtin.view.hex_editor.copy.custom_encoding": "Benutzerdefinierte Codierung",
+        "hex.builtin.view.hex_editor.copy.hex_view": "Hex View"
     }
 }

plugins/builtin/romfs/lang/en_US.json

@@ -13,6 +13,7 @@
         "hex.builtin.common.big": "Big",
         "hex.builtin.common.big_endian": "Big Endian",
         "hex.builtin.common.browse": "Browse...",
+        "hex.builtin.common.bytes": "Bytes",
         "hex.builtin.common.cancel": "Cancel",
         "hex.builtin.common.choose_file": "Choose file",
         "hex.builtin.common.close": "Close",
@@ -31,6 +32,7 @@
         "hex.builtin.common.filter": "Filter",
         "hex.builtin.common.hexadecimal": "Hexadecimal",
         "hex.builtin.common.info": "Information",
+        "hex.builtin.common.instruction": "Instruction",
         "hex.builtin.common.link": "Link",
         "hex.builtin.common.little": "Little",
         "hex.builtin.common.little_endian": "Little Endian",
@@ -134,7 +136,14 @@
         "hex.builtin.menu.file.close": "Close",
         "hex.builtin.menu.file.create_file": "New File...",
         "hex.builtin.menu.file.export": "Export...",
-        "hex.builtin.menu.file.export.base64.popup.export_error": "File is not in a valid Base64 format!",
+        "hex.builtin.menu.file.export.base64": "Base64",
+        "hex.builtin.menu.file.export.base64.popup.export_error": "Failed to create new base64 file!",
+        "hex.builtin.menu.file.export.ips.popup.export_error": "Failed to create new IPS file!",
+        "hex.builtin.menu.file.export.ips.popup.invalid_patch_header_error": "Invalid IPS patch header!",
+        "hex.builtin.menu.file.export.ips.popup.address_out_of_range_error": "A patch tried to patch an address that is out of range!",
+        "hex.builtin.menu.file.export.ips.popup.patch_too_large_error": "A patch was larger than the maximally allowed size!",
+        "hex.builtin.menu.file.export.ips.popup.invalid_patch_format_error": "Invalid IPS patch format!",
+        "hex.builtin.menu.file.export.ips.popup.missing_eof_error": "Missing IPS EOF record!",
         "hex.builtin.menu.file.export.ips": "IPS Patch",
         "hex.builtin.menu.file.export.ips32": "IPS32 Patch",
         "hex.builtin.menu.file.export.popup.create": "Cannot export data. Failed to create file!",
@@ -145,6 +154,7 @@
         "hex.builtin.menu.file.import.base64.popup.open_error": "Failed to open file!",
         "hex.builtin.menu.file.import.ips": "IPS Patch",
         "hex.builtin.menu.file.import.ips32": "IPS32 Patch",
+        "hex.builtin.menu.file.import.modified_file": "Modified File",
         "hex.builtin.menu.file.open_file": "Open File...",
         "hex.builtin.menu.file.open_other": "Open Other...",
         "hex.builtin.menu.file.open_project": "Open Project...",
@@ -163,17 +173,25 @@
         "hex.builtin.nodes.arithmetic.add.header": "Add",
         "hex.builtin.nodes.arithmetic.average": "Average",
         "hex.builtin.nodes.arithmetic.average.header": "Average",
+        "hex.builtin.nodes.arithmetic.ceil": "Ceil",
+        "hex.builtin.nodes.arithmetic.ceil.header": "Ceil",
         "hex.builtin.nodes.arithmetic.div": "Division",
         "hex.builtin.nodes.arithmetic.div.header": "Divide",
+        "hex.builtin.nodes.arithmetic.floor": "Floor",
+        "hex.builtin.nodes.arithmetic.floor.header": "Floor",
         "hex.builtin.nodes.arithmetic.median": "Median",
         "hex.builtin.nodes.arithmetic.median.header": "Median",
         "hex.builtin.nodes.arithmetic.mod": "Modulus",
         "hex.builtin.nodes.arithmetic.mod.header": "Modulo",
         "hex.builtin.nodes.arithmetic.mul": "Multiplication",
         "hex.builtin.nodes.arithmetic.mul.header": "Multiply",
+        "hex.builtin.nodes.arithmetic.round": "Round",
+        "hex.builtin.nodes.arithmetic.round.header": "Round",
         "hex.builtin.nodes.arithmetic.sub": "Subtraction",
         "hex.builtin.nodes.arithmetic.sub.header": "Subtract",
         "hex.builtin.nodes.bitwise": "Bitwise operations",
+        "hex.builtin.nodes.bitwise.add": "ADD",
+        "hex.builtin.nodes.bitwise.add.header": "Bitwise ADD",
         "hex.builtin.nodes.bitwise.and": "AND",
         "hex.builtin.nodes.bitwise.and.header": "Bitwise AND",
         "hex.builtin.nodes.bitwise.not": "NOT",
@@ -192,6 +210,9 @@
         "hex.builtin.nodes.buffer.repeat.header": "Repeat buffer",
         "hex.builtin.nodes.buffer.repeat.input.buffer": "Input",
         "hex.builtin.nodes.buffer.repeat.input.count": "Count",
+        "hex.builtin.nodes.buffer.size": "Buffer Size",
+        "hex.builtin.nodes.buffer.size.header": "Buffer Size",
+        "hex.builtin.nodes.buffer.size.output": "Size",
         "hex.builtin.nodes.buffer.slice": "Slice",
         "hex.builtin.nodes.buffer.slice.header": "Slice buffer",
         "hex.builtin.nodes.buffer.slice.input.buffer": "Input",
@@ -258,6 +279,15 @@
         "hex.builtin.nodes.crypto.aes.key_length": "Key length",
         "hex.builtin.nodes.crypto.aes.mode": "Mode",
         "hex.builtin.nodes.crypto.aes.nonce": "Nonce",
+        "hex.builtin.nodes.custom": "Custom",
+        "hex.builtin.nodes.custom.custom": "New Node",
+        "hex.builtin.nodes.custom.custom.edit": "Edit",
+        "hex.builtin.nodes.custom.custom.edit_hint": "Hold down SHIFT to edit",
+        "hex.builtin.nodes.custom.custom.header": "Custom Node",
+        "hex.builtin.nodes.custom.input": "Custom Node Input",
+        "hex.builtin.nodes.custom.input.header": "Node Input",
+        "hex.builtin.nodes.custom.output": "Custom Node Output",
+        "hex.builtin.nodes.custom.output.header": "Node Output",
         "hex.builtin.nodes.data_access": "Data access",
         "hex.builtin.nodes.data_access.read": "Read",
         "hex.builtin.nodes.data_access.read.address": "Address",
@@ -310,11 +340,13 @@
         "hex.builtin.pattern_drawer.type": "Type",
         "hex.builtin.pattern_drawer.value": "Value",
         "hex.builtin.pattern_drawer.var_name": "Name",
-        "hex.builtin.popup.close_provider.desc": "You have unsaved changes made to this Provider.\nAre you sure you want to close it?",
+        "hex.builtin.pattern_drawer.visualizer.unknown": "Unknown visualizer",
+        "hex.builtin.pattern_drawer.visualizer.invalid_parameter_count": "Invalid parameter count",
+        "hex.builtin.popup.close_provider.desc": "There are unsaved changes made to this Provider\nthat haven't been saved to a Project yet.\n\nAre you sure you want to close it?",
         "hex.builtin.popup.close_provider.title": "Close Provider?",
         "hex.builtin.popup.error.create": "Failed to create new file!",
         "hex.builtin.popup.error.file_dialog.common": "An error occurred while opening the file browser!",
-        "hex.builtin.popup.error.file_dialog.portal": "There was an error while opening the file browser. This might be caused by your system not having a xdg-desktop-portal backend installed correctly.\n\nOn KDE, it's xdg-desktop-portal-kde.\nOn Gnome it's xdg-desktop-portal-gnome.\nOn wlroots it's xdg-desktop-portal-wlr.\nOtherwise, you can try to use xdg-desktop-portal-gtk.\n\nReboot your system after installing it.\n\nIf the file browser still doesn't work after this, submit an issue at https://github.com/WerWolv/ImHex/issues\n\nIn the meantime files can still be opened by dragging them onto the ImHex window!",
+        "hex.builtin.popup.error.file_dialog.portal": "There was an error while opening the file browser.\nThis might be caused by your system not having a xdg-desktop-portal backend installed correctly.\n\nOn KDE, it's xdg-desktop-portal-kde.\nOn Gnome it's xdg-desktop-portal-gnome.\nOn wlroots it's xdg-desktop-portal-wlr.\nOtherwise, you can try to use xdg-desktop-portal-gtk.\n\nReboot your system after installing it.\n\nIf the file browser still doesn't work after this, submit an issue at https://github.com/WerWolv/ImHex/issues\n\nIn the meantime files can still be opened by dragging them onto the ImHex window!",
         "hex.builtin.popup.error.open": "Failed to open file!",
         "hex.builtin.popup.error.project.load": "Failed to load project!",
         "hex.builtin.popup.error.project.save": "Failed to save project!",
@@ -322,6 +354,8 @@
         "hex.builtin.popup.error.task_exception": "Exception thrown in Task '{}':\n\n{}",
         "hex.builtin.popup.exit_application.desc": "You have unsaved changes made to your Project.\nAre you sure you want to exit?",
         "hex.builtin.popup.exit_application.title": "Exit Application?",
+        "hex.builtin.popup.waiting_for_tasks.title": "Waiting for Tasks",
+        "hex.builtin.popup.waiting_for_tasks.desc": "There are still tasks running in the background.\nImHex will close after they are finished.",
         "hex.builtin.provider.disk": "Raw Disk Provider",
         "hex.builtin.provider.disk.disk_size": "Disk Size",
         "hex.builtin.provider.disk.reload": "Reload",
@@ -377,6 +411,10 @@
         "hex.builtin.setting.interface.fps.unlocked": "Unlocked",
         "hex.builtin.setting.interface.language": "Language",
         "hex.builtin.setting.interface.multi_windows": "Enable Multi Window support",
+        "hex.builtin.setting.interface.pattern_tree_style": "Pattern Tree Style",
+        "hex.builtin.setting.interface.pattern_tree_style.tree": "Tree",
+        "hex.builtin.setting.interface.pattern_tree_style.auto_expanded": "Auto Expanded Tree",
+        "hex.builtin.setting.interface.pattern_tree_style.flattened": "Flattened",
         "hex.builtin.setting.interface.scaling": "Scaling",
         "hex.builtin.setting.interface.scaling.native": "Native",
         "hex.builtin.setting.interface.scaling.x0_5": "x0.5",
@@ -458,20 +496,24 @@
         "hex.builtin.tools.format.scientific": "Scientific",
         "hex.builtin.tools.format.standard": "Standard",
         "hex.builtin.tools.history": "History",
-        "hex.builtin.tools.ieee756": "IEEE 756 Floating Point Tester",
-        "hex.builtin.tools.ieee756.double_precision": "Double Precision",
-        "hex.builtin.tools.ieee756.exponent": "Exponent",
-        "hex.builtin.tools.ieee756.exponent_size": "Exponent Size",
-        "hex.builtin.tools.ieee756.formula": "Formula",
-        "hex.builtin.tools.ieee756.half_precision": "Half Precision",
-        "hex.builtin.tools.ieee756.mantissa": "Mantissa",
-        "hex.builtin.tools.ieee756.mantissa_size": "Mantissa Size",
-        "hex.builtin.tools.ieee756.result.float": "Floating Point Result",
-        "hex.builtin.tools.ieee756.result.hex": "Hexadecimal Result",
-        "hex.builtin.tools.ieee756.result.title": "Result",
-        "hex.builtin.tools.ieee756.sign": "Sign",
-        "hex.builtin.tools.ieee756.singe_precision": "Single Precision",
-        "hex.builtin.tools.ieee756.type": "Type",
+        "hex.builtin.tools.ieee754": "IEEE 754 Floating Point Decoder",
+        "hex.builtin.tools.ieee754.description": "IEEE754 is a standard for representing floating point numbers which is used by most modern CPUs.\n\nThis tool visualizes the internal representation of a floating point number and allows decoding of numbers with a non-standard number of mantissa or exponent bits.",
+        "hex.builtin.tools.ieee754.double_precision": "Double Precision",
+        "hex.builtin.tools.ieee754.exponent": "Exponent",
+        "hex.builtin.tools.ieee754.exponent_size": "Exponent Size",
+        "hex.builtin.tools.ieee754.formula": "Formula",
+        "hex.builtin.tools.ieee754.half_precision": "Half Precision",
+        "hex.builtin.tools.ieee754.mantissa": "Mantissa",
+        "hex.builtin.tools.ieee754.mantissa_size": "Mantissa Size",
+        "hex.builtin.tools.ieee754.result.float": "Floating Point Result",
+        "hex.builtin.tools.ieee754.result.hex": "Hexadecimal Result",
+        "hex.builtin.tools.ieee754.result.title": "Result",
+        "hex.builtin.tools.ieee754.sign": "Sign",
+        "hex.builtin.tools.ieee754.singe_precision": "Single Precision",
+        "hex.builtin.tools.ieee754.type": "Type",
+        "hex.builtin.tools.invariant_multiplication": "Division by invariant Multiplication",
+        "hex.builtin.tools.invariant_multiplication.description": "Division by invariant multiplication is a technique often used by compilers to optimize integer division by a constant into a multiplication followed by a shift. The reason for this is that divisions often take many times more clock cycles than multiplications do.\n\nThis tool can be used to calculate the multiplier from the divisor or the divisor from the multiplier.",
+        "hex.builtin.tools.invariant_multiplication.num_bits": "Number of Bits",
         "hex.builtin.tools.input": "Input",
         "hex.builtin.tools.name": "Name",
         "hex.builtin.tools.permissions": "UNIX Permissions Calculator",
@@ -518,6 +560,7 @@
         "hex.builtin.view.data_processor.menu.remove_link": "Remove Link",
         "hex.builtin.view.data_processor.menu.remove_node": "Remove Node",
         "hex.builtin.view.data_processor.menu.remove_selection": "Remove Selected",
+        "hex.builtin.view.data_processor.menu.save_node": "Save Node",
         "hex.builtin.view.data_processor.name": "Data Processor",
         "hex.builtin.view.diff.name": "Diffing",
         "hex.builtin.view.disassembler.16bit": "16-bit",
@@ -628,14 +671,15 @@
         "hex.builtin.view.help.name": "Help",
         "hex.builtin.view.help.pattern_cheat_sheet": "Pattern Language Cheat Sheet",
         "hex.builtin.view.hex_editor.copy.address": "Address",
-        "hex.builtin.view.hex_editor.copy.ascii": "Text Area",
+        "hex.builtin.view.hex_editor.copy.ascii": "ASCII String",
         "hex.builtin.view.hex_editor.copy.base64": "Base64",
         "hex.builtin.view.hex_editor.copy.c": "C Array",
         "hex.builtin.view.hex_editor.copy.cpp": "C++ Array",
         "hex.builtin.view.hex_editor.copy.crystal": "Crystal Array",
         "hex.builtin.view.hex_editor.copy.csharp": "C# Array",
+        "hex.builtin.view.hex_editor.copy.custom_encoding": "Custom Encoding",
         "hex.builtin.view.hex_editor.copy.go": "Go Array",
-        "hex.builtin.view.hex_editor.copy.hex": "Hex String",
+        "hex.builtin.view.hex_editor.copy.hex_view": "Hex View",
         "hex.builtin.view.hex_editor.copy.html": "HTML",
         "hex.builtin.view.hex_editor.copy.java": "Java Array",
         "hex.builtin.view.hex_editor.copy.js": "JavaScript Array",
@@ -696,7 +740,6 @@
         "hex.builtin.view.information.region": "Analyzed region",
         "hex.builtin.view.information.plain_text": "This data is most likely plain text.",
         "hex.builtin.view.information.plain_text_percentage": "Plain text percentage",
-
         "hex.builtin.view.patches.name": "Patches",
         "hex.builtin.view.patches.offset": "Offset",
         "hex.builtin.view.patches.orig": "Original value",

plugins/builtin/romfs/lang/it_IT.json

@@ -12,11 +12,12 @@
         "hex.builtin.common.big": "Big",
         "hex.builtin.common.big_endian": "Big Endian",
         "hex.builtin.common.browse": "Esplora...",
+        "hex.builtin.common.bytes": "",
         "hex.builtin.common.cancel": "Cancella",
         "hex.builtin.common.choose_file": "Scegli file",
         "hex.builtin.common.close": "Chiudi",
-        "hex.builtin.common.comment": "***** MISSING TRANSLATION *****",
-        "hex.builtin.common.count": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.comment": "",
+        "hex.builtin.common.count": "",
         "hex.builtin.common.decimal": "Decimale",
         "hex.builtin.common.dont_show_again": "Non mostrare di nuovo",
         "hex.builtin.common.encoding.ascii": "ASCII",
@@ -27,30 +28,32 @@
         "hex.builtin.common.error": "Errore",
         "hex.builtin.common.fatal": "Errore Fatale",
         "hex.builtin.common.file": "File",
-        "hex.builtin.common.filter": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.filter": "",
         "hex.builtin.common.hexadecimal": "Esadecimale",
         "hex.builtin.common.info": "Informazioni",
+        "hex.builtin.common.instruction": "",
         "hex.builtin.common.link": "Link",
         "hex.builtin.common.little": "Little",
         "hex.builtin.common.little_endian": "Little Endian",
         "hex.builtin.common.load": "Carica",
         "hex.builtin.common.match_selection": "Seleziona abbinamento",
-        "hex.builtin.common.name": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.name": "",
         "hex.builtin.common.no": "No",
-        "hex.builtin.common.number_format": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.number_format": "",
         "hex.builtin.common.octal": "Ottale",
         "hex.builtin.common.offset": "Offset",
         "hex.builtin.common.okay": "Okay",
         "hex.builtin.common.open": "Apri",
-        "hex.builtin.common.processing": "***** MISSING TRANSLATION *****",
-        "hex.builtin.common.question": "***** MISSING TRANSLATION *****",
-        "hex.builtin.common.range": "***** MISSING TRANSLATION *****",
-        "hex.builtin.common.range.entire_data": "***** MISSING TRANSLATION *****",
-        "hex.builtin.common.range.selection": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.percentage": "",
+        "hex.builtin.common.processing": "",
+        "hex.builtin.common.question": "",
+        "hex.builtin.common.range": "",
+        "hex.builtin.common.range.entire_data": "",
+        "hex.builtin.common.range.selection": "",
         "hex.builtin.common.region": "Regione",
         "hex.builtin.common.set": "Imposta",
         "hex.builtin.common.size": "Dimensione",
-        "hex.builtin.common.type": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.type": "",
         "hex.builtin.common.type.f32": "float",
         "hex.builtin.common.type.f64": "double",
         "hex.builtin.common.type.i16": "int16_t",
@@ -65,13 +68,13 @@
         "hex.builtin.common.type.u48": "uint48_t",
         "hex.builtin.common.type.u64": "uint64_t",
         "hex.builtin.common.type.u8": "uint8_t",
-        "hex.builtin.common.value": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.value": "",
         "hex.builtin.common.yes": "Sì",
         "hex.builtin.hash.crc.iv": "Valore Iniziale",
         "hex.builtin.hash.crc.poly": "Polinomio",
-        "hex.builtin.hash.crc.refl_in": "***** MISSING TRANSLATION *****",
-        "hex.builtin.hash.crc.refl_out": "***** MISSING TRANSLATION *****",
-        "hex.builtin.hash.crc.xor_out": "***** MISSING TRANSLATION *****",
+        "hex.builtin.hash.crc.refl_in": "",
+        "hex.builtin.hash.crc.refl_out": "",
+        "hex.builtin.hash.crc.xor_out": "",
         "hex.builtin.hash.crc16": "CRC16",
         "hex.builtin.hash.crc32": "CRC32",
         "hex.builtin.hash.crc8": "CRC8",
@@ -81,17 +84,17 @@
         "hex.builtin.hash.sha256": "SHA256",
         "hex.builtin.hash.sha384": "SHA384",
         "hex.builtin.hash.sha512": "SHA512",
-        "hex.builtin.hex_editor.data_size": "***** MISSING TRANSLATION *****",
-        "hex.builtin.hex_editor.no_bytes": "***** MISSING TRANSLATION *****",
-        "hex.builtin.hex_editor.page": "***** MISSING TRANSLATION *****",
-        "hex.builtin.hex_editor.region": "***** MISSING TRANSLATION *****",
-        "hex.builtin.hex_editor.selection": "***** MISSING TRANSLATION *****",
-        "hex.builtin.hex_editor.selection.none": "***** MISSING TRANSLATION *****",
+        "hex.builtin.hex_editor.data_size": "",
+        "hex.builtin.hex_editor.no_bytes": "",
+        "hex.builtin.hex_editor.page": "",
+        "hex.builtin.hex_editor.region": "",
+        "hex.builtin.hex_editor.selection": "",
+        "hex.builtin.hex_editor.selection.none": "",
         "hex.builtin.inspector.ascii": "ASCII Character",
         "hex.builtin.inspector.binary": "Binary (8 bit)",
         "hex.builtin.inspector.bool": "bool",
-        "hex.builtin.inspector.dos_date": "***** MISSING TRANSLATION *****",
-        "hex.builtin.inspector.dos_time": "***** MISSING TRANSLATION *****",
+        "hex.builtin.inspector.dos_date": "",
+        "hex.builtin.inspector.dos_time": "",
         "hex.builtin.inspector.double": "double (64 bit)",
         "hex.builtin.inspector.float": "float (32 bit)",
         "hex.builtin.inspector.float16": "half float (16 bit)",
@@ -105,7 +108,7 @@
         "hex.builtin.inspector.long_double": "long double (128 bit)",
         "hex.builtin.inspector.rgb565": "Colori RGB565",
         "hex.builtin.inspector.rgba8": "Colori RGBA8",
-        "hex.builtin.inspector.sleb128": "***** MISSING TRANSLATION *****",
+        "hex.builtin.inspector.sleb128": "",
         "hex.builtin.inspector.string": "String",
         "hex.builtin.inspector.string16": "Wide String",
         "hex.builtin.inspector.time": "time_t",
@@ -117,7 +120,7 @@
         "hex.builtin.inspector.u48": "uint48_t",
         "hex.builtin.inspector.u64": "uint64_t",
         "hex.builtin.inspector.u8": "uint8_t",
-        "hex.builtin.inspector.uleb128": "***** MISSING TRANSLATION *****",
+        "hex.builtin.inspector.uleb128": "",
         "hex.builtin.inspector.utf8": "UTF-8 code point",
         "hex.builtin.inspector.wide": "Wide Character",
         "hex.builtin.layouts.default": "Default",
@@ -126,21 +129,28 @@
         "hex.builtin.menu.edit.redo": "Ripeti",
         "hex.builtin.menu.edit.undo": "Annulla",
         "hex.builtin.menu.file": "File",
-        "hex.builtin.menu.file.bookmark.export": "***** MISSING TRANSLATION *****",
-        "hex.builtin.menu.file.bookmark.import": "***** MISSING TRANSLATION *****",
+        "hex.builtin.menu.file.bookmark.export": "",
+        "hex.builtin.menu.file.bookmark.import": "",
         "hex.builtin.menu.file.clear_recent": "Pulisci",
         "hex.builtin.menu.file.close": "Chiudi",
-        "hex.builtin.menu.file.create_file": "***** MISSING TRANSLATION *****",
+        "hex.builtin.menu.file.create_file": "",
         "hex.builtin.menu.file.export": "Esporta...",
-        "hex.builtin.menu.file.export.base64.popup.export_error": "***** MISSING TRANSLATION *****",
+        "hex.builtin.menu.file.export.base64": "",
+        "hex.builtin.menu.file.export.base64.popup.export_error": "",
         "hex.builtin.menu.file.export.ips": "IPS Patch",
+        "hex.builtin.menu.file.export.ips.popup.address_out_of_range_error": "",
+        "hex.builtin.menu.file.export.ips.popup.export_error": "",
+        "hex.builtin.menu.file.export.ips.popup.invalid_patch_format_error": "",
+        "hex.builtin.menu.file.export.ips.popup.invalid_patch_header_error": "",
+        "hex.builtin.menu.file.export.ips.popup.missing_eof_error": "",
+        "hex.builtin.menu.file.export.ips.popup.patch_too_large_error": "",
         "hex.builtin.menu.file.export.ips32": "IPS32 Patch",
-        "hex.builtin.menu.file.export.popup.create": "***** MISSING TRANSLATION *****",
+        "hex.builtin.menu.file.export.popup.create": "",
         "hex.builtin.menu.file.export.title": "Esporta File",
         "hex.builtin.menu.file.import": "Importa...",
         "hex.builtin.menu.file.import.base64": "Base64 File",
-        "hex.builtin.menu.file.import.base64.popup.import_error": "***** MISSING TRANSLATION *****",
-        "hex.builtin.menu.file.import.base64.popup.open_error": "***** MISSING TRANSLATION *****",
+        "hex.builtin.menu.file.import.base64.popup.import_error": "",
+        "hex.builtin.menu.file.import.base64.popup.open_error": "",
         "hex.builtin.menu.file.import.ips": "IPS Patch",
         "hex.builtin.menu.file.import.ips32": "IPS32 Patch",
         "hex.builtin.menu.file.open_file": "Apri File...",
@@ -148,9 +158,9 @@
         "hex.builtin.menu.file.open_project": "Apri un Progetto...",
         "hex.builtin.menu.file.open_recent": "File recenti",
         "hex.builtin.menu.file.quit": "Uscita ImHex",
-        "hex.builtin.menu.file.reload_file": "***** MISSING TRANSLATION *****",
+        "hex.builtin.menu.file.reload_file": "",
         "hex.builtin.menu.file.save_project": "Salva Progetto",
-        "hex.builtin.menu.file.save_project_as": "***** MISSING TRANSLATION *****",
+        "hex.builtin.menu.file.save_project_as": "",
         "hex.builtin.menu.help": "Aiuto",
         "hex.builtin.menu.layout": "Layout",
         "hex.builtin.menu.view": "Vista",
@@ -159,12 +169,12 @@
         "hex.builtin.nodes.arithmetic": "Aritmetica",
         "hex.builtin.nodes.arithmetic.add": "Addizione",
         "hex.builtin.nodes.arithmetic.add.header": "Aggiungi",
-        "hex.builtin.nodes.arithmetic.average": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.arithmetic.average.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.arithmetic.average": "",
+        "hex.builtin.nodes.arithmetic.average.header": "",
         "hex.builtin.nodes.arithmetic.div": "Divisione",
         "hex.builtin.nodes.arithmetic.div.header": "Dividi",
-        "hex.builtin.nodes.arithmetic.median": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.arithmetic.median.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.arithmetic.median": "",
+        "hex.builtin.nodes.arithmetic.median.header": "",
         "hex.builtin.nodes.arithmetic.mod": "Modulo",
         "hex.builtin.nodes.arithmetic.mod.header": "Modulo",
         "hex.builtin.nodes.arithmetic.mul": "Moltiplicazione",
@@ -183,9 +193,9 @@
         "hex.builtin.nodes.buffer": "Buffer",
         "hex.builtin.nodes.buffer.combine": "Combina",
         "hex.builtin.nodes.buffer.combine.header": "Combina buffer",
-        "hex.builtin.nodes.buffer.patch": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.buffer.patch.header": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.buffer.patch.input.patch": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.buffer.patch": "",
+        "hex.builtin.nodes.buffer.patch.header": "",
+        "hex.builtin.nodes.buffer.patch.input.patch": "",
         "hex.builtin.nodes.buffer.repeat": "Ripeti",
         "hex.builtin.nodes.buffer.repeat.header": "Ripeti buffer",
         "hex.builtin.nodes.buffer.repeat.input.buffer": "Input",
@@ -196,20 +206,20 @@
         "hex.builtin.nodes.buffer.slice.input.from": "Inizio",
         "hex.builtin.nodes.buffer.slice.input.to": "Fine",
         "hex.builtin.nodes.casting": "Conversione Dati",
-        "hex.builtin.nodes.casting.buffer_to_float": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.casting.buffer_to_float.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.casting.buffer_to_float": "",
+        "hex.builtin.nodes.casting.buffer_to_float.header": "",
         "hex.builtin.nodes.casting.buffer_to_int": "Da Buffer a Intero",
         "hex.builtin.nodes.casting.buffer_to_int.header": "Da Buffer a Integer",
-        "hex.builtin.nodes.casting.float_to_buffer": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.casting.float_to_buffer.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.casting.float_to_buffer": "",
+        "hex.builtin.nodes.casting.float_to_buffer.header": "",
         "hex.builtin.nodes.casting.int_to_buffer": "Da Intero a Buffer",
         "hex.builtin.nodes.casting.int_to_buffer.header": "Da Intero a Buffer",
-        "hex.builtin.nodes.common.height": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.common.height": "",
         "hex.builtin.nodes.common.input": "Input",
         "hex.builtin.nodes.common.input.a": "Input A",
         "hex.builtin.nodes.common.input.b": "Input B",
         "hex.builtin.nodes.common.output": "Output",
-        "hex.builtin.nodes.common.width": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.common.width": "",
         "hex.builtin.nodes.constants": "Costanti",
         "hex.builtin.nodes.constants.buffer": "Buffer",
         "hex.builtin.nodes.constants.buffer.header": "Buffer",
@@ -262,10 +272,10 @@
         "hex.builtin.nodes.data_access.read.data": "Dati",
         "hex.builtin.nodes.data_access.read.header": "Leggi",
         "hex.builtin.nodes.data_access.read.size": "Dimensione",
-        "hex.builtin.nodes.data_access.selection": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.data_access.selection.address": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.data_access.selection.header": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.data_access.selection.size": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.data_access.selection": "",
+        "hex.builtin.nodes.data_access.selection.address": "",
+        "hex.builtin.nodes.data_access.selection.header": "",
+        "hex.builtin.nodes.data_access.selection.size": "",
         "hex.builtin.nodes.data_access.size": "Dati Dimensione",
         "hex.builtin.nodes.data_access.size.header": "Dati Dimensione",
         "hex.builtin.nodes.data_access.size.size": "Dimensione",
@@ -279,45 +289,47 @@
         "hex.builtin.nodes.decoding.hex": "Esadecimale",
         "hex.builtin.nodes.decoding.hex.header": "Decodificatore Esadecimale",
         "hex.builtin.nodes.display": "Mostra",
-        "hex.builtin.nodes.display.buffer": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.display.buffer.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.display.buffer": "",
+        "hex.builtin.nodes.display.buffer.header": "",
         "hex.builtin.nodes.display.float": "Float",
         "hex.builtin.nodes.display.float.header": "Mostra Float",
         "hex.builtin.nodes.display.int": "Intero",
         "hex.builtin.nodes.display.int.header": "Mostra Intero",
-        "hex.builtin.nodes.display.string": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.display.string.header": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.pattern_language": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.pattern_language.out_var": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.pattern_language.out_var.header": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.visualizer": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.visualizer.byte_distribution": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.visualizer.byte_distribution.header": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.visualizer.digram": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.visualizer.digram.header": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.visualizer.image": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.visualizer.image.header": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.visualizer.image_rgba": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.visualizer.image_rgba.header": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.visualizer.layered_dist": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.visualizer.layered_dist.header": "***** MISSING TRANSLATION *****",
-        "hex.builtin.pattern_drawer.color": "***** MISSING TRANSLATION *****",
-        "hex.builtin.pattern_drawer.double_click": "***** MISSING TRANSLATION *****",
-        "hex.builtin.pattern_drawer.offset": "***** MISSING TRANSLATION *****",
-        "hex.builtin.pattern_drawer.size": "***** MISSING TRANSLATION *****",
-        "hex.builtin.pattern_drawer.type": "***** MISSING TRANSLATION *****",
-        "hex.builtin.pattern_drawer.value": "***** MISSING TRANSLATION *****",
-        "hex.builtin.pattern_drawer.var_name": "***** MISSING TRANSLATION *****",
-        "hex.builtin.popup.close_provider.desc": "***** MISSING TRANSLATION *****",
-        "hex.builtin.popup.close_provider.title": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.display.string": "",
+        "hex.builtin.nodes.display.string.header": "",
+        "hex.builtin.nodes.pattern_language": "",
+        "hex.builtin.nodes.pattern_language.out_var": "",
+        "hex.builtin.nodes.pattern_language.out_var.header": "",
+        "hex.builtin.nodes.visualizer": "",
+        "hex.builtin.nodes.visualizer.byte_distribution": "",
+        "hex.builtin.nodes.visualizer.byte_distribution.header": "",
+        "hex.builtin.nodes.visualizer.digram": "",
+        "hex.builtin.nodes.visualizer.digram.header": "",
+        "hex.builtin.nodes.visualizer.image": "",
+        "hex.builtin.nodes.visualizer.image.header": "",
+        "hex.builtin.nodes.visualizer.image_rgba": "",
+        "hex.builtin.nodes.visualizer.image_rgba.header": "",
+        "hex.builtin.nodes.visualizer.layered_dist": "",
+        "hex.builtin.nodes.visualizer.layered_dist.header": "",
+        "hex.builtin.pattern_drawer.color": "",
+        "hex.builtin.pattern_drawer.double_click": "",
+        "hex.builtin.pattern_drawer.offset": "",
+        "hex.builtin.pattern_drawer.size": "",
+        "hex.builtin.pattern_drawer.type": "",
+        "hex.builtin.pattern_drawer.value": "",
+        "hex.builtin.pattern_drawer.var_name": "",
+        "hex.builtin.pattern_drawer.visualizer.invalid_parameter_count": "",
+        "hex.builtin.pattern_drawer.visualizer.unknown": "",
+        "hex.builtin.popup.close_provider.desc": "",
+        "hex.builtin.popup.close_provider.title": "",
         "hex.builtin.popup.error.create": "Impossibile creare il nuovo File!",
-        "hex.builtin.popup.error.file_dialog.common": "***** MISSING TRANSLATION *****",
-        "hex.builtin.popup.error.file_dialog.portal": "***** MISSING TRANSLATION *****",
+        "hex.builtin.popup.error.file_dialog.common": "",
+        "hex.builtin.popup.error.file_dialog.portal": "",
         "hex.builtin.popup.error.open": "Impossibile aprire il File!",
-        "hex.builtin.popup.error.project.load": "***** MISSING TRANSLATION *****",
-        "hex.builtin.popup.error.project.save": "***** MISSING TRANSLATION *****",
+        "hex.builtin.popup.error.project.load": "",
+        "hex.builtin.popup.error.project.save": "",
         "hex.builtin.popup.error.read_only": "Impossibile scrivere sul File. File aperto solo in modalità lettura",
-        "hex.builtin.popup.error.task_exception": "***** MISSING TRANSLATION *****",
+        "hex.builtin.popup.error.task_exception": "",
         "hex.builtin.popup.exit_application.desc": "Hai delle modifiche non salvate nel tuo progetto.\nSei sicuro di voler uscire?",
         "hex.builtin.popup.exit_application.title": "Uscire dall'applicazione?",
         "hex.builtin.provider.disk": "Provider di dischi raw",
@@ -336,37 +348,37 @@
         "hex.builtin.provider.gdb.name": "Server GDB <{0}:{1}>",
         "hex.builtin.provider.gdb.port": "Porta",
         "hex.builtin.provider.gdb.server": "Server",
-        "hex.builtin.provider.intel_hex": "***** MISSING TRANSLATION *****",
-        "hex.builtin.provider.intel_hex.name": "***** MISSING TRANSLATION *****",
-        "hex.builtin.provider.mem_file": "***** MISSING TRANSLATION *****",
-        "hex.builtin.provider.mem_file.unsaved": "***** MISSING TRANSLATION *****",
-        "hex.builtin.provider.motorola_srec": "***** MISSING TRANSLATION *****",
-        "hex.builtin.provider.motorola_srec.name": "***** MISSING TRANSLATION *****",
-        "hex.builtin.provider.view": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.folders": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.folders.add_folder": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.folders.description": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.folders.remove_folder": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.font": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.font.font_path": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.font.font_size": "***** MISSING TRANSLATION *****",
+        "hex.builtin.provider.intel_hex": "",
+        "hex.builtin.provider.intel_hex.name": "",
+        "hex.builtin.provider.mem_file": "",
+        "hex.builtin.provider.mem_file.unsaved": "",
+        "hex.builtin.provider.motorola_srec": "",
+        "hex.builtin.provider.motorola_srec.name": "",
+        "hex.builtin.provider.view": "",
+        "hex.builtin.setting.folders": "",
+        "hex.builtin.setting.folders.add_folder": "",
+        "hex.builtin.setting.folders.description": "",
+        "hex.builtin.setting.folders.remove_folder": "",
+        "hex.builtin.setting.font": "",
+        "hex.builtin.setting.font.font_path": "",
+        "hex.builtin.setting.font.font_size": "",
         "hex.builtin.setting.general": "Generali",
         "hex.builtin.setting.general.auto_load_patterns": "Auto-caricamento del pattern supportato",
-        "hex.builtin.setting.general.check_for_updates": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.general.enable_unicode": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.general.check_for_updates": "",
+        "hex.builtin.setting.general.enable_unicode": "",
         "hex.builtin.setting.general.show_tips": "Mostra consigli all'avvio",
-        "hex.builtin.setting.general.sync_pattern_source": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.general.sync_pattern_source": "",
         "hex.builtin.setting.hex_editor": "Hex Editor",
         "hex.builtin.setting.hex_editor.advanced_decoding": "Mostra la colonna di decodifica avanzata",
         "hex.builtin.setting.hex_editor.ascii": "Mostra la colonna ASCII",
-        "hex.builtin.setting.hex_editor.byte_padding": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.hex_editor.bytes_per_row": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.hex_editor.char_padding": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.hex_editor.byte_padding": "",
+        "hex.builtin.setting.hex_editor.bytes_per_row": "",
+        "hex.builtin.setting.hex_editor.char_padding": "",
         "hex.builtin.setting.hex_editor.grey_zeros": "Taglia fuori gli zeri",
-        "hex.builtin.setting.hex_editor.highlight_color": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.hex_editor.sync_scrolling": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.hex_editor.highlight_color": "",
+        "hex.builtin.setting.hex_editor.sync_scrolling": "",
         "hex.builtin.setting.hex_editor.uppercase_hex": "Caratteri esadecimali maiuscoli",
-        "hex.builtin.setting.hex_editor.visualizer": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.hex_editor.visualizer": "",
         "hex.builtin.setting.imhex": "ImHex",
         "hex.builtin.setting.imhex.recent_files": "File recenti",
         "hex.builtin.setting.interface": "Interfaccia",
@@ -374,7 +386,11 @@
         "hex.builtin.setting.interface.fps": "Limite FPS",
         "hex.builtin.setting.interface.fps.unlocked": "Unblocca",
         "hex.builtin.setting.interface.language": "Lingua",
-        "hex.builtin.setting.interface.multi_windows": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.interface.multi_windows": "",
+        "hex.builtin.setting.interface.pattern_tree_style": "",
+        "hex.builtin.setting.interface.pattern_tree_style.auto_expanded": "",
+        "hex.builtin.setting.interface.pattern_tree_style.flattened": "",
+        "hex.builtin.setting.interface.pattern_tree_style.tree": "",
         "hex.builtin.setting.interface.scaling": "Scale",
         "hex.builtin.setting.interface.scaling.native": "Nativo",
         "hex.builtin.setting.interface.scaling.x0_5": "x0.5",
@@ -383,12 +399,12 @@
         "hex.builtin.setting.interface.scaling.x2_0": "x2.0",
         "hex.builtin.setting.interface.scaling.x3_0": "x3.0",
         "hex.builtin.setting.interface.scaling.x4_0": "x4.0",
-        "hex.builtin.setting.interface.wiki_explain_language": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.proxy": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.proxy.description": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.proxy.enable": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.proxy.url": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.proxy.url.tooltip": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.interface.wiki_explain_language": "",
+        "hex.builtin.setting.proxy": "",
+        "hex.builtin.setting.proxy.description": "",
+        "hex.builtin.setting.proxy.enable": "",
+        "hex.builtin.setting.proxy.url": "",
+        "hex.builtin.setting.proxy.url.tooltip": "",
         "hex.builtin.tools.ascii_table": "Tavola ASCII",
         "hex.builtin.tools.ascii_table.octal": "Mostra ottale",
         "hex.builtin.tools.base_converter": "Convertitore di Base",
@@ -456,21 +472,25 @@
         "hex.builtin.tools.format.scientific": "Scientifica",
         "hex.builtin.tools.format.standard": "Standard",
         "hex.builtin.tools.history": "Storia",
-        "hex.builtin.tools.ieee756": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.double_precision": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.exponent": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.exponent_size": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.formula": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.half_precision": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.mantissa": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.mantissa_size": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.result.float": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.result.hex": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.result.title": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.sign": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.singe_precision": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.type": "***** MISSING TRANSLATION *****",
+        "hex.builtin.tools.ieee754": "",
+        "hex.builtin.tools.ieee754.description": "",
+        "hex.builtin.tools.ieee754.double_precision": "",
+        "hex.builtin.tools.ieee754.exponent": "",
+        "hex.builtin.tools.ieee754.exponent_size": "",
+        "hex.builtin.tools.ieee754.formula": "",
+        "hex.builtin.tools.ieee754.half_precision": "",
+        "hex.builtin.tools.ieee754.mantissa": "",
+        "hex.builtin.tools.ieee754.mantissa_size": "",
+        "hex.builtin.tools.ieee754.result.float": "",
+        "hex.builtin.tools.ieee754.result.hex": "",
+        "hex.builtin.tools.ieee754.result.title": "",
+        "hex.builtin.tools.ieee754.sign": "",
+        "hex.builtin.tools.ieee754.singe_precision": "",
+        "hex.builtin.tools.ieee754.type": "",
         "hex.builtin.tools.input": "Input",
+        "hex.builtin.tools.invariant_multiplication": "",
+        "hex.builtin.tools.invariant_multiplication.description": "",
+        "hex.builtin.tools.invariant_multiplication.num_bits": "",
         "hex.builtin.tools.name": "Nome",
         "hex.builtin.tools.permissions": "Calcolatrice dei permessi UNIX",
         "hex.builtin.tools.permissions.absolute": "Notazione assoluta",
@@ -505,12 +525,12 @@
         "hex.builtin.view.constants.row.desc": "Descrizione",
         "hex.builtin.view.constants.row.name": "Nome",
         "hex.builtin.view.constants.row.value": "Valore",
-        "hex.builtin.view.data_inspector.invert": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.data_inspector.invert": "",
         "hex.builtin.view.data_inspector.name": "Ispezione Dati",
         "hex.builtin.view.data_inspector.no_data": "Nessun byte selezionato",
         "hex.builtin.view.data_inspector.table.name": "Nome",
         "hex.builtin.view.data_inspector.table.value": "Valore",
-        "hex.builtin.view.data_processor.help_text": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.data_processor.help_text": "",
         "hex.builtin.view.data_processor.menu.file.load_processor": "Caricare processore di dati...",
         "hex.builtin.view.data_processor.menu.file.save_processor": "Salva processore di dati...",
         "hex.builtin.view.data_processor.menu.remove_link": "Rimuovi Link",
@@ -573,45 +593,45 @@
         "hex.builtin.view.disassembler.region": "Regione del Codice",
         "hex.builtin.view.disassembler.riscv.compressed": "Compresso",
         "hex.builtin.view.disassembler.settings.header": "Impostazioni",
-        "hex.builtin.view.disassembler.settings.mode": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.disassembler.settings.mode": "",
         "hex.builtin.view.disassembler.sparc.v9": "Sparc V9",
-        "hex.builtin.view.find.binary_pattern": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.context.copy": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.context.copy_demangle": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.demangled": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.name": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.regex": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.regex.full_match": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.regex.pattern": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.search": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.search.entries": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.search.reset": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.searching": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.sequences": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.chars": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.line_feeds": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.lower_case": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.match_settings": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.min_length": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.null_term": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.numbers": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.spaces": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.symbols": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.underscores": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.upper_case": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.value": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.value.max": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.value.min": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.find.binary_pattern": "",
+        "hex.builtin.view.find.context.copy": "",
+        "hex.builtin.view.find.context.copy_demangle": "",
+        "hex.builtin.view.find.demangled": "",
+        "hex.builtin.view.find.name": "",
+        "hex.builtin.view.find.regex": "",
+        "hex.builtin.view.find.regex.full_match": "",
+        "hex.builtin.view.find.regex.pattern": "",
+        "hex.builtin.view.find.search": "",
+        "hex.builtin.view.find.search.entries": "",
+        "hex.builtin.view.find.search.reset": "",
+        "hex.builtin.view.find.searching": "",
+        "hex.builtin.view.find.sequences": "",
+        "hex.builtin.view.find.strings": "",
+        "hex.builtin.view.find.strings.chars": "",
+        "hex.builtin.view.find.strings.line_feeds": "",
+        "hex.builtin.view.find.strings.lower_case": "",
+        "hex.builtin.view.find.strings.match_settings": "",
+        "hex.builtin.view.find.strings.min_length": "",
+        "hex.builtin.view.find.strings.null_term": "",
+        "hex.builtin.view.find.strings.numbers": "",
+        "hex.builtin.view.find.strings.spaces": "",
+        "hex.builtin.view.find.strings.symbols": "",
+        "hex.builtin.view.find.strings.underscores": "",
+        "hex.builtin.view.find.strings.upper_case": "",
+        "hex.builtin.view.find.value": "",
+        "hex.builtin.view.find.value.max": "",
+        "hex.builtin.view.find.value.min": "",
         "hex.builtin.view.hashes.function": "Funzioni di Hash",
         "hex.builtin.view.hashes.hash": "Hash",
-        "hex.builtin.view.hashes.hover_info": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hashes.hover_info": "",
         "hex.builtin.view.hashes.name": "Hash",
-        "hex.builtin.view.hashes.no_settings": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hashes.remove": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hashes.table.name": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hashes.no_settings": "",
+        "hex.builtin.view.hashes.remove": "",
+        "hex.builtin.view.hashes.table.name": "",
         "hex.builtin.view.hashes.table.result": "Risultato",
-        "hex.builtin.view.hashes.table.type": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hashes.table.type": "",
         "hex.builtin.view.help.about.contributor": "Collaboratori",
         "hex.builtin.view.help.about.donations": "Donazioni",
         "hex.builtin.view.help.about.libs": "Librerie usate",
@@ -625,15 +645,13 @@
         "hex.builtin.view.help.documentation": "Documentazione di ImHex",
         "hex.builtin.view.help.name": "Aiuto",
         "hex.builtin.view.help.pattern_cheat_sheet": "Pattern Language Cheat Sheet",
-        "hex.builtin.view.hex_editor.copy.address": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.copy.ascii": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hex_editor.copy.address": "",
         "hex.builtin.view.hex_editor.copy.base64": "Base64",
         "hex.builtin.view.hex_editor.copy.c": "C Array",
         "hex.builtin.view.hex_editor.copy.cpp": "C++ Array",
         "hex.builtin.view.hex_editor.copy.crystal": "Crystal Array",
         "hex.builtin.view.hex_editor.copy.csharp": "C# Array",
         "hex.builtin.view.hex_editor.copy.go": "Go Array",
-        "hex.builtin.view.hex_editor.copy.hex": "Hex Stringa",
         "hex.builtin.view.hex_editor.copy.html": "HTML",
         "hex.builtin.view.hex_editor.copy.java": "Java Array",
         "hex.builtin.view.hex_editor.copy.js": "JavaScript Array",
@@ -645,15 +663,15 @@
         "hex.builtin.view.hex_editor.goto.offset.absolute": "Assoluto",
         "hex.builtin.view.hex_editor.goto.offset.begin": "Inizo",
         "hex.builtin.view.hex_editor.goto.offset.end": "Fine",
-        "hex.builtin.view.hex_editor.goto.offset.relative": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hex_editor.goto.offset.relative": "",
         "hex.builtin.view.hex_editor.menu.edit.copy": "Copia",
         "hex.builtin.view.hex_editor.menu.edit.copy_as": "Copia come...",
         "hex.builtin.view.hex_editor.menu.edit.insert": "Inserisci...",
-        "hex.builtin.view.hex_editor.menu.edit.jump_to": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.menu.edit.open_in_new_provider": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hex_editor.menu.edit.jump_to": "",
+        "hex.builtin.view.hex_editor.menu.edit.open_in_new_provider": "",
         "hex.builtin.view.hex_editor.menu.edit.paste": "Incolla",
-        "hex.builtin.view.hex_editor.menu.edit.paste_all": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.menu.edit.remove": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hex_editor.menu.edit.paste_all": "",
+        "hex.builtin.view.hex_editor.menu.edit.remove": "",
         "hex.builtin.view.hex_editor.menu.edit.resize": "Ridimensiona...",
         "hex.builtin.view.hex_editor.menu.edit.select_all": "Seleziona tutti",
         "hex.builtin.view.hex_editor.menu.edit.set_base": "Imposta indirizzo di base",
@@ -662,32 +680,37 @@
         "hex.builtin.view.hex_editor.menu.file.save": "Salva",
         "hex.builtin.view.hex_editor.menu.file.save_as": "Salva come...",
         "hex.builtin.view.hex_editor.menu.file.search": "Cerca",
-        "hex.builtin.view.hex_editor.menu.file.select": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hex_editor.menu.file.select": "",
         "hex.builtin.view.hex_editor.name": "Hex editor",
         "hex.builtin.view.hex_editor.search.find": "Cerca",
         "hex.builtin.view.hex_editor.search.hex": "Hex",
         "hex.builtin.view.hex_editor.search.string": "Stringa",
-        "hex.builtin.view.hex_editor.select.offset.begin": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.select.offset.end": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.select.offset.region": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.select.offset.size": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.select.select": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hex_editor.select.offset.begin": "",
+        "hex.builtin.view.hex_editor.select.offset.end": "",
+        "hex.builtin.view.hex_editor.select.offset.region": "",
+        "hex.builtin.view.hex_editor.select.offset.size": "",
+        "hex.builtin.view.hex_editor.select.select": "",
         "hex.builtin.view.information.analyze": "Analizza Pagina",
         "hex.builtin.view.information.analyzing": "Sto analizzando...",
         "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.byte_types": "",
         "hex.builtin.view.information.control": "Controllo",
         "hex.builtin.view.information.description": "Descrizione:",
+        "hex.builtin.view.information.digram": "",
         "hex.builtin.view.information.distribution": "Distribuzione dei Byte",
         "hex.builtin.view.information.encrypted": "Questi dati sono probabilmente codificati o compressi!",
         "hex.builtin.view.information.entropy": "Entropia",
         "hex.builtin.view.information.file_entropy": "Entropia dei File",
         "hex.builtin.view.information.highest_entropy": "Highest entropy block",
         "hex.builtin.view.information.info_analysis": "Informazioni dell'analisi",
+        "hex.builtin.view.information.layered_distribution": "",
         "hex.builtin.view.information.magic": "Informazione Magica",
         "hex.builtin.view.information.magic_db_added": "Database magico aggiunto!",
         "hex.builtin.view.information.mime": "Tipo di MIME:",
         "hex.builtin.view.information.name": "Informazione sui Dati",
+        "hex.builtin.view.information.plain_text": "",
+        "hex.builtin.view.information.plain_text_percentage": "",
         "hex.builtin.view.information.region": "Regione Analizzata",
         "hex.builtin.view.patches.name": "Patches",
         "hex.builtin.view.patches.offset": "Offset",
@@ -705,30 +728,30 @@
         "hex.builtin.view.pattern_editor.dangerous_function.name": "Vuoi consentire funzioni pericolose?",
         "hex.builtin.view.pattern_editor.env_vars": "Variabili d'ambiente",
         "hex.builtin.view.pattern_editor.evaluating": "Valutazione...",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin.array": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin.single": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.custom": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern": "",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin": "",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin.array": "",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin.single": "",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.custom": "",
         "hex.builtin.view.pattern_editor.menu.file.load_pattern": "Caricamento dei pattern...",
         "hex.builtin.view.pattern_editor.menu.file.save_pattern": "Salva pattern...",
         "hex.builtin.view.pattern_editor.name": "Editor dei Pattern",
         "hex.builtin.view.pattern_editor.no_in_out_vars": "Definisci alcune variabili globali con 'in' o 'out' per farle apparire qui.",
         "hex.builtin.view.pattern_editor.open_pattern": "Apri pattern",
-        "hex.builtin.view.pattern_editor.section_popup": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.sections": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.pattern_editor.section_popup": "",
+        "hex.builtin.view.pattern_editor.sections": "",
         "hex.builtin.view.pattern_editor.settings": "Impostazioni",
-        "hex.builtin.view.provider_settings.load_error": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.provider_settings.load_error": "",
         "hex.builtin.view.provider_settings.load_popup": "Apri Provider",
         "hex.builtin.view.provider_settings.name": "Impostazioni Provider",
         "hex.builtin.view.settings.name": "Impostazioni",
-        "hex.builtin.view.settings.restart_question": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.settings.restart_question": "",
         "hex.builtin.view.store.desc": "Scarica nuovi contenuti dal database online di ImHex",
         "hex.builtin.view.store.download": "Download",
         "hex.builtin.view.store.download_error": "Impossibile scaricare file! La cartella di destinazione non esiste.",
         "hex.builtin.view.store.loading": "Caricamento del content store...",
         "hex.builtin.view.store.name": "Content Store",
-        "hex.builtin.view.store.netfailed": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.store.netfailed": "",
         "hex.builtin.view.store.reload": "Ricarica",
         "hex.builtin.view.store.remove": "Rimuovi",
         "hex.builtin.view.store.row.description": "Descrizione",
@@ -751,27 +774,27 @@
         "hex.builtin.view.yara.name": "Regole di Yara",
         "hex.builtin.view.yara.no_rules": "Nessuna regola di YARA. Aggiungile in nella cartella 'yara' di 'ImHex'",
         "hex.builtin.view.yara.reload": "Ricarica",
-        "hex.builtin.view.yara.reset": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.yara.reset": "",
         "hex.builtin.view.yara.rule_added": "Regola di Yara aggiunta!",
         "hex.builtin.view.yara.whole_data": "Tutti i file combaciano!",
-        "hex.builtin.visualizer.decimal.signed.16bit": "***** MISSING TRANSLATION *****",
-        "hex.builtin.visualizer.decimal.signed.32bit": "***** MISSING TRANSLATION *****",
-        "hex.builtin.visualizer.decimal.signed.64bit": "***** MISSING TRANSLATION *****",
-        "hex.builtin.visualizer.decimal.signed.8bit": "***** MISSING TRANSLATION *****",
-        "hex.builtin.visualizer.decimal.unsigned.16bit": "***** MISSING TRANSLATION *****",
-        "hex.builtin.visualizer.decimal.unsigned.32bit": "***** MISSING TRANSLATION *****",
-        "hex.builtin.visualizer.decimal.unsigned.64bit": "***** MISSING TRANSLATION *****",
-        "hex.builtin.visualizer.decimal.unsigned.8bit": "***** MISSING TRANSLATION *****",
-        "hex.builtin.visualizer.floating_point.16bit": "***** MISSING TRANSLATION *****",
-        "hex.builtin.visualizer.floating_point.32bit": "***** MISSING TRANSLATION *****",
-        "hex.builtin.visualizer.floating_point.64bit": "***** MISSING TRANSLATION *****",
-        "hex.builtin.visualizer.hexadecimal.16bit": "***** MISSING TRANSLATION *****",
-        "hex.builtin.visualizer.hexadecimal.32bit": "***** MISSING TRANSLATION *****",
-        "hex.builtin.visualizer.hexadecimal.64bit": "***** MISSING TRANSLATION *****",
-        "hex.builtin.visualizer.hexadecimal.8bit": "***** MISSING TRANSLATION *****",
-        "hex.builtin.visualizer.hexii": "***** MISSING TRANSLATION *****",
-        "hex.builtin.visualizer.rgba8": "***** MISSING TRANSLATION *****",
-        "hex.builtin.welcome.check_for_updates_text": "***** MISSING TRANSLATION *****",
+        "hex.builtin.visualizer.decimal.signed.16bit": "",
+        "hex.builtin.visualizer.decimal.signed.32bit": "",
+        "hex.builtin.visualizer.decimal.signed.64bit": "",
+        "hex.builtin.visualizer.decimal.signed.8bit": "",
+        "hex.builtin.visualizer.decimal.unsigned.16bit": "",
+        "hex.builtin.visualizer.decimal.unsigned.32bit": "",
+        "hex.builtin.visualizer.decimal.unsigned.64bit": "",
+        "hex.builtin.visualizer.decimal.unsigned.8bit": "",
+        "hex.builtin.visualizer.floating_point.16bit": "",
+        "hex.builtin.visualizer.floating_point.32bit": "",
+        "hex.builtin.visualizer.floating_point.64bit": "",
+        "hex.builtin.visualizer.hexadecimal.16bit": "",
+        "hex.builtin.visualizer.hexadecimal.32bit": "",
+        "hex.builtin.visualizer.hexadecimal.64bit": "",
+        "hex.builtin.visualizer.hexadecimal.8bit": "",
+        "hex.builtin.visualizer.hexii": "",
+        "hex.builtin.visualizer.rgba8": "",
+        "hex.builtin.welcome.check_for_updates_text": "",
         "hex.builtin.welcome.customize.settings.desc": "Cambia le preferenze di ImHex",
         "hex.builtin.welcome.customize.settings.title": "Impostazioni",
         "hex.builtin.welcome.header.customize": "Personalizza",
@@ -806,7 +829,7 @@
         "hex.builtin.welcome.safety_backup.title": "Ripristina i dati persi",
         "hex.builtin.welcome.start.create_file": "Crea un nuovo File",
         "hex.builtin.welcome.start.open_file": "Apri un File",
-        "hex.builtin.welcome.start.open_other": "***** MISSING TRANSLATION *****",
+        "hex.builtin.welcome.start.open_other": "",
         "hex.builtin.welcome.start.open_project": "Apri un Progetto",
         "hex.builtin.welcome.start.recent": "File recenti",
         "hex.builtin.welcome.tip_of_the_day": "Consiglio del giorno",

plugins/builtin/romfs/lang/ja_JP.json

@@ -12,11 +12,12 @@
         "hex.builtin.common.big": "ビッグ",
         "hex.builtin.common.big_endian": "ビッグエンディアン",
         "hex.builtin.common.browse": "ファイルを参照…",
+        "hex.builtin.common.bytes": "",
         "hex.builtin.common.cancel": "キャンセル",
         "hex.builtin.common.choose_file": "ファイルを選択",
         "hex.builtin.common.close": "閉じる",
         "hex.builtin.common.comment": "コメント",
-        "hex.builtin.common.count": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.count": "",
         "hex.builtin.common.decimal": "10進数",
         "hex.builtin.common.dont_show_again": "再度表示しない",
         "hex.builtin.common.encoding.ascii": "ASCII",
@@ -30,27 +31,29 @@
         "hex.builtin.common.filter": "フィルタ",
         "hex.builtin.common.hexadecimal": "16進数",
         "hex.builtin.common.info": "情報",
+        "hex.builtin.common.instruction": "",
         "hex.builtin.common.link": "リンク",
         "hex.builtin.common.little": "リトル",
         "hex.builtin.common.little_endian": "リトルエンディアン",
         "hex.builtin.common.load": "読み込む",
         "hex.builtin.common.match_selection": "選択範囲と一致",
-        "hex.builtin.common.name": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.name": "",
         "hex.builtin.common.no": "いいえ",
-        "hex.builtin.common.number_format": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.number_format": "",
         "hex.builtin.common.octal": "8進数",
         "hex.builtin.common.offset": "オフセット",
         "hex.builtin.common.okay": "OK",
         "hex.builtin.common.open": "開く",
-        "hex.builtin.common.processing": "***** MISSING TRANSLATION *****",
-        "hex.builtin.common.question": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.percentage": "",
+        "hex.builtin.common.processing": "",
+        "hex.builtin.common.question": "",
         "hex.builtin.common.range": "範囲",
         "hex.builtin.common.range.entire_data": "データ全体",
         "hex.builtin.common.range.selection": "選択範囲",
         "hex.builtin.common.region": "領域",
         "hex.builtin.common.set": "セット",
         "hex.builtin.common.size": "サイズ",
-        "hex.builtin.common.type": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.type": "",
         "hex.builtin.common.type.f32": "float",
         "hex.builtin.common.type.f64": "double",
         "hex.builtin.common.type.i16": "int16_t",
@@ -82,7 +85,7 @@
         "hex.builtin.hash.sha384": "SHA384",
         "hex.builtin.hash.sha512": "SHA512",
         "hex.builtin.hex_editor.data_size": "ファイルサイズ",
-        "hex.builtin.hex_editor.no_bytes": "***** MISSING TRANSLATION *****",
+        "hex.builtin.hex_editor.no_bytes": "",
         "hex.builtin.hex_editor.page": "ページ",
         "hex.builtin.hex_editor.region": "ページの領域",
         "hex.builtin.hex_editor.selection": "選択中",
@@ -90,8 +93,8 @@
         "hex.builtin.inspector.ascii": "ASCII",
         "hex.builtin.inspector.binary": "バイナリ (8 bit)",
         "hex.builtin.inspector.bool": "bool",
-        "hex.builtin.inspector.dos_date": "***** MISSING TRANSLATION *****",
-        "hex.builtin.inspector.dos_time": "***** MISSING TRANSLATION *****",
+        "hex.builtin.inspector.dos_date": "",
+        "hex.builtin.inspector.dos_time": "",
         "hex.builtin.inspector.double": "double (64 bit)",
         "hex.builtin.inspector.float": "float (32 bit)",
         "hex.builtin.inspector.float16": "half float (16 bit)",
@@ -105,7 +108,7 @@
         "hex.builtin.inspector.long_double": "long double (128 bit)",
         "hex.builtin.inspector.rgb565": "RGB565 Color",
         "hex.builtin.inspector.rgba8": "RGBA8 Color",
-        "hex.builtin.inspector.sleb128": "***** MISSING TRANSLATION *****",
+        "hex.builtin.inspector.sleb128": "",
         "hex.builtin.inspector.string": "String",
         "hex.builtin.inspector.string16": "Wide String",
         "hex.builtin.inspector.time": "time_t",
@@ -117,7 +120,7 @@
         "hex.builtin.inspector.u48": "uint48_t",
         "hex.builtin.inspector.u64": "uint64_t",
         "hex.builtin.inspector.u8": "uint8_t",
-        "hex.builtin.inspector.uleb128": "***** MISSING TRANSLATION *****",
+        "hex.builtin.inspector.uleb128": "",
         "hex.builtin.inspector.utf8": "UTF-8 code point",
         "hex.builtin.inspector.wide": "Wide Character",
         "hex.builtin.layouts.default": "標準",
@@ -130,10 +133,17 @@
         "hex.builtin.menu.file.bookmark.import": "ブックマークをインポート…",
         "hex.builtin.menu.file.clear_recent": "リストをクリア",
         "hex.builtin.menu.file.close": "ファイルを閉じる",
-        "hex.builtin.menu.file.create_file": "***** MISSING TRANSLATION *****",
+        "hex.builtin.menu.file.create_file": "",
         "hex.builtin.menu.file.export": "エクスポート…",
-        "hex.builtin.menu.file.export.base64.popup.export_error": "有効なBase64形式ではありません。",
+        "hex.builtin.menu.file.export.base64": "",
+        "hex.builtin.menu.file.export.base64.popup.export_error": "",
         "hex.builtin.menu.file.export.ips": "IPSパッチ",
+        "hex.builtin.menu.file.export.ips.popup.address_out_of_range_error": "",
+        "hex.builtin.menu.file.export.ips.popup.export_error": "",
+        "hex.builtin.menu.file.export.ips.popup.invalid_patch_format_error": "",
+        "hex.builtin.menu.file.export.ips.popup.invalid_patch_header_error": "",
+        "hex.builtin.menu.file.export.ips.popup.missing_eof_error": "",
+        "hex.builtin.menu.file.export.ips.popup.patch_too_large_error": "",
         "hex.builtin.menu.file.export.ips32": "IPS32パッチ",
         "hex.builtin.menu.file.export.popup.create": "データをエクスポートできません。\nファイルの作成に失敗しました。",
         "hex.builtin.menu.file.export.title": "ファイルをエクスポート",
@@ -148,9 +158,9 @@
         "hex.builtin.menu.file.open_project": "プロジェクトを開く…",
         "hex.builtin.menu.file.open_recent": "最近使用したファイル",
         "hex.builtin.menu.file.quit": "ImHexを終了",
-        "hex.builtin.menu.file.reload_file": "***** MISSING TRANSLATION *****",
+        "hex.builtin.menu.file.reload_file": "",
         "hex.builtin.menu.file.save_project": "プロジェクトを保存",
-        "hex.builtin.menu.file.save_project_as": "***** MISSING TRANSLATION *****",
+        "hex.builtin.menu.file.save_project_as": "",
         "hex.builtin.menu.help": "ヘルプ",
         "hex.builtin.menu.layout": "レイアウト",
         "hex.builtin.menu.view": "表示",
@@ -159,12 +169,12 @@
         "hex.builtin.nodes.arithmetic": "演算",
         "hex.builtin.nodes.arithmetic.add": "加算＋",
         "hex.builtin.nodes.arithmetic.add.header": "加算",
-        "hex.builtin.nodes.arithmetic.average": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.arithmetic.average.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.arithmetic.average": "",
+        "hex.builtin.nodes.arithmetic.average.header": "",
         "hex.builtin.nodes.arithmetic.div": "除算÷",
         "hex.builtin.nodes.arithmetic.div.header": "除算",
-        "hex.builtin.nodes.arithmetic.median": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.arithmetic.median.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.arithmetic.median": "",
+        "hex.builtin.nodes.arithmetic.median.header": "",
         "hex.builtin.nodes.arithmetic.mod": "剰余（余り）",
         "hex.builtin.nodes.arithmetic.mod.header": "剰余",
         "hex.builtin.nodes.arithmetic.mul": "乗算×",
@@ -183,33 +193,33 @@
         "hex.builtin.nodes.buffer": "バッファ",
         "hex.builtin.nodes.buffer.combine": "結合",
         "hex.builtin.nodes.buffer.combine.header": "バッファを結合",
-        "hex.builtin.nodes.buffer.patch": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.buffer.patch.header": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.buffer.patch.input.patch": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.buffer.patch": "",
+        "hex.builtin.nodes.buffer.patch.header": "",
+        "hex.builtin.nodes.buffer.patch.input.patch": "",
         "hex.builtin.nodes.buffer.repeat": "繰り返し",
         "hex.builtin.nodes.buffer.repeat.header": "バッファを繰り返し",
-        "hex.builtin.nodes.buffer.repeat.input.buffer": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.buffer.repeat.input.buffer": "",
         "hex.builtin.nodes.buffer.repeat.input.count": "カウント",
         "hex.builtin.nodes.buffer.slice": "スライス",
         "hex.builtin.nodes.buffer.slice.header": "バッファをスライス",
-        "hex.builtin.nodes.buffer.slice.input.buffer": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.buffer.slice.input.buffer": "",
         "hex.builtin.nodes.buffer.slice.input.from": "From",
         "hex.builtin.nodes.buffer.slice.input.to": "To",
         "hex.builtin.nodes.casting": "データ変換",
-        "hex.builtin.nodes.casting.buffer_to_float": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.casting.buffer_to_float.header": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.casting.buffer_to_int": "バッファ→整数",
-        "hex.builtin.nodes.casting.buffer_to_int.header": "バッファ→整数",
-        "hex.builtin.nodes.casting.float_to_buffer": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.casting.float_to_buffer.header": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.casting.int_to_buffer": "整数→バッファ",
-        "hex.builtin.nodes.casting.int_to_buffer.header": "整数→バッファ",
-        "hex.builtin.nodes.common.height": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.casting.buffer_to_float": "バッファをfloatに",
+        "hex.builtin.nodes.casting.buffer_to_float.header": "バッファをfloatに",
+        "hex.builtin.nodes.casting.buffer_to_int": "バッファを整数に",
+        "hex.builtin.nodes.casting.buffer_to_int.header": "バッファを整数に",
+        "hex.builtin.nodes.casting.float_to_buffer": "floatをバッファに",
+        "hex.builtin.nodes.casting.float_to_buffer.header": "floatをバッファに",
+        "hex.builtin.nodes.casting.int_to_buffer": "整数をバッファに",
+        "hex.builtin.nodes.casting.int_to_buffer.header": "整数をバッファに",
+        "hex.builtin.nodes.common.height": "高さ",
         "hex.builtin.nodes.common.input": "入力",
         "hex.builtin.nodes.common.input.a": "入力 A",
         "hex.builtin.nodes.common.input.b": "入力 B",
         "hex.builtin.nodes.common.output": "出力",
-        "hex.builtin.nodes.common.width": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.common.width": "幅",
         "hex.builtin.nodes.constants": "定数",
         "hex.builtin.nodes.constants.buffer": "バッファ",
         "hex.builtin.nodes.constants.buffer.header": "バッファ",
@@ -220,8 +230,8 @@
         "hex.builtin.nodes.constants.float.header": "小数",
         "hex.builtin.nodes.constants.int": "整数",
         "hex.builtin.nodes.constants.int.header": "整数",
-        "hex.builtin.nodes.constants.nullptr": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.constants.nullptr.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.constants.nullptr": "ヌルポインタ",
+        "hex.builtin.nodes.constants.nullptr.header": "ヌルポインタ",
         "hex.builtin.nodes.constants.rgba8": "RGBA8",
         "hex.builtin.nodes.constants.rgba8.header": "RGBA8",
         "hex.builtin.nodes.constants.rgba8.output.a": "A",
@@ -279,17 +289,17 @@
         "hex.builtin.nodes.decoding.hex": "16進法",
         "hex.builtin.nodes.decoding.hex.header": "16進デコーダ",
         "hex.builtin.nodes.display": "表示",
-        "hex.builtin.nodes.display.buffer": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.display.buffer.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.display.buffer": "バッファ",
+        "hex.builtin.nodes.display.buffer.header": "バッファ表示",
         "hex.builtin.nodes.display.float": "小数",
         "hex.builtin.nodes.display.float.header": "小数表示",
         "hex.builtin.nodes.display.int": "整数",
         "hex.builtin.nodes.display.int.header": "整数表示",
-        "hex.builtin.nodes.display.string": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.display.string.header": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.pattern_language": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.pattern_language.out_var": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.pattern_language.out_var.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.display.string": "ASCII",
+        "hex.builtin.nodes.display.string.header": "ASCII表示",
+        "hex.builtin.nodes.pattern_language": "",
+        "hex.builtin.nodes.pattern_language.out_var": "",
+        "hex.builtin.nodes.pattern_language.out_var.header": "",
         "hex.builtin.nodes.visualizer": "ビジュアライザー",
         "hex.builtin.nodes.visualizer.byte_distribution": "バイト分布",
         "hex.builtin.nodes.visualizer.byte_distribution.header": "バイト分布",
@@ -297,52 +307,54 @@
         "hex.builtin.nodes.visualizer.digram.header": "図式",
         "hex.builtin.nodes.visualizer.image": "画像",
         "hex.builtin.nodes.visualizer.image.header": "画像ビジュアライザー",
-        "hex.builtin.nodes.visualizer.image_rgba": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.visualizer.image_rgba.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.visualizer.image_rgba": "",
+        "hex.builtin.nodes.visualizer.image_rgba.header": "",
         "hex.builtin.nodes.visualizer.layered_dist": "層状分布",
         "hex.builtin.nodes.visualizer.layered_dist.header": "層状分布",
         "hex.builtin.pattern_drawer.color": "色",
-        "hex.builtin.pattern_drawer.double_click": "***** MISSING TRANSLATION *****",
+        "hex.builtin.pattern_drawer.double_click": "",
         "hex.builtin.pattern_drawer.offset": "オフセット",
         "hex.builtin.pattern_drawer.size": "サイズ",
         "hex.builtin.pattern_drawer.type": "型",
         "hex.builtin.pattern_drawer.value": "値",
         "hex.builtin.pattern_drawer.var_name": "名前",
-        "hex.builtin.popup.close_provider.desc": "***** MISSING TRANSLATION *****",
-        "hex.builtin.popup.close_provider.title": "***** MISSING TRANSLATION *****",
+        "hex.builtin.pattern_drawer.visualizer.invalid_parameter_count": "",
+        "hex.builtin.pattern_drawer.visualizer.unknown": "",
+        "hex.builtin.popup.close_provider.desc": "変更がプロジェクトとして保存されていません。\nファイルを閉じてもよろしいですか？",
+        "hex.builtin.popup.close_provider.title": "タブを閉じますか？",
         "hex.builtin.popup.error.create": "新しいファイルを作成できませんでした。",
-        "hex.builtin.popup.error.file_dialog.common": "***** MISSING TRANSLATION *****",
-        "hex.builtin.popup.error.file_dialog.portal": "***** MISSING TRANSLATION *****",
+        "hex.builtin.popup.error.file_dialog.common": "",
+        "hex.builtin.popup.error.file_dialog.portal": "",
         "hex.builtin.popup.error.open": "ファイルを開けませんでした。",
-        "hex.builtin.popup.error.project.load": "***** MISSING TRANSLATION *****",
-        "hex.builtin.popup.error.project.save": "***** MISSING TRANSLATION *****",
+        "hex.builtin.popup.error.project.load": "",
+        "hex.builtin.popup.error.project.save": "",
         "hex.builtin.popup.error.read_only": "書き込み権限を取得できませんでした。ファイルが読み取り専用で開かれました。",
-        "hex.builtin.popup.error.task_exception": "***** MISSING TRANSLATION *****",
-        "hex.builtin.popup.exit_application.desc": "プロジェクトに保存されていない変更があります。\n終了してもよろしいですか？",
+        "hex.builtin.popup.error.task_exception": "",
+        "hex.builtin.popup.exit_application.desc": "変更がプロジェクトとして保存されていません。\n終了してもよろしいですか？",
         "hex.builtin.popup.exit_application.title": "アプリケーションを終了しますか？",
-        "hex.builtin.provider.disk": "Rawディスクプロバイダ",
+        "hex.builtin.provider.disk": "ディスクイメージ",
         "hex.builtin.provider.disk.disk_size": "ディスクサイズ",
         "hex.builtin.provider.disk.reload": "リロード",
         "hex.builtin.provider.disk.sector_size": "セクタサイズ",
         "hex.builtin.provider.disk.selected_disk": "ディスク",
-        "hex.builtin.provider.file": "ファイルプロバイダ",
+        "hex.builtin.provider.file": "ファイル",
         "hex.builtin.provider.file.access": "最終アクセス時刻",
         "hex.builtin.provider.file.creation": "作成時刻",
         "hex.builtin.provider.file.modification": "最終編集時刻",
         "hex.builtin.provider.file.path": "ファイルパス",
         "hex.builtin.provider.file.size": "サイズ",
-        "hex.builtin.provider.gdb": "GDBサーバープロバイダ",
+        "hex.builtin.provider.gdb": "GDBサーバー",
         "hex.builtin.provider.gdb.ip": "IPアドレス",
         "hex.builtin.provider.gdb.name": "GDBサーバー <{0}:{1}>",
         "hex.builtin.provider.gdb.port": "ポート",
         "hex.builtin.provider.gdb.server": "サーバー",
-        "hex.builtin.provider.intel_hex": "***** MISSING TRANSLATION *****",
-        "hex.builtin.provider.intel_hex.name": "***** MISSING TRANSLATION *****",
-        "hex.builtin.provider.mem_file": "***** MISSING TRANSLATION *****",
-        "hex.builtin.provider.mem_file.unsaved": "***** MISSING TRANSLATION *****",
-        "hex.builtin.provider.motorola_srec": "***** MISSING TRANSLATION *****",
-        "hex.builtin.provider.motorola_srec.name": "***** MISSING TRANSLATION *****",
-        "hex.builtin.provider.view": "***** MISSING TRANSLATION *****",
+        "hex.builtin.provider.intel_hex": "",
+        "hex.builtin.provider.intel_hex.name": "",
+        "hex.builtin.provider.mem_file": "",
+        "hex.builtin.provider.mem_file.unsaved": "",
+        "hex.builtin.provider.motorola_srec": "",
+        "hex.builtin.provider.motorola_srec.name": "",
+        "hex.builtin.provider.view": "",
         "hex.builtin.setting.folders": "フォルダ",
         "hex.builtin.setting.folders.add_folder": "フォルダを追加…",
         "hex.builtin.setting.folders.description": "パターン、スクリプト、ルールなどのための検索パスを指定して追加できます。",
@@ -352,19 +364,19 @@
         "hex.builtin.setting.font.font_size": "フォントサイズ",
         "hex.builtin.setting.general": "基本",
         "hex.builtin.setting.general.auto_load_patterns": "対応するパターンを自動で読み込む",
-        "hex.builtin.setting.general.check_for_updates": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.general.enable_unicode": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.general.check_for_updates": "",
+        "hex.builtin.setting.general.enable_unicode": "",
         "hex.builtin.setting.general.show_tips": "起動時に豆知識を表示",
-        "hex.builtin.setting.general.sync_pattern_source": "プロバイダ間のパターンソースコードを同期",
+        "hex.builtin.setting.general.sync_pattern_source": "ファイル間のパターンソースコードを同期",
         "hex.builtin.setting.hex_editor": "Hexエディタ",
         "hex.builtin.setting.hex_editor.advanced_decoding": "他のデコード列を表示",
         "hex.builtin.setting.hex_editor.ascii": "ASCIIを表示",
-        "hex.builtin.setting.hex_editor.byte_padding": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.hex_editor.byte_padding": "",
         "hex.builtin.setting.hex_editor.bytes_per_row": "１行のバイト数",
-        "hex.builtin.setting.hex_editor.char_padding": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.hex_editor.char_padding": "",
         "hex.builtin.setting.hex_editor.grey_zeros": "ゼロをグレーアウト",
         "hex.builtin.setting.hex_editor.highlight_color": "選択範囲の色",
-        "hex.builtin.setting.hex_editor.sync_scrolling": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.hex_editor.sync_scrolling": "",
         "hex.builtin.setting.hex_editor.uppercase_hex": "16進数を大文字表記",
         "hex.builtin.setting.hex_editor.visualizer": "データ表示方式",
         "hex.builtin.setting.imhex": "ImHex",
@@ -374,7 +386,11 @@
         "hex.builtin.setting.interface.fps": "FPS制限",
         "hex.builtin.setting.interface.fps.unlocked": "無制限",
         "hex.builtin.setting.interface.language": "言語",
-        "hex.builtin.setting.interface.multi_windows": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.interface.multi_windows": "",
+        "hex.builtin.setting.interface.pattern_tree_style": "",
+        "hex.builtin.setting.interface.pattern_tree_style.auto_expanded": "",
+        "hex.builtin.setting.interface.pattern_tree_style.flattened": "",
+        "hex.builtin.setting.interface.pattern_tree_style.tree": "",
         "hex.builtin.setting.interface.scaling": "スケーリング",
         "hex.builtin.setting.interface.scaling.native": "ネイティブ",
         "hex.builtin.setting.interface.scaling.x0_5": "x0.5",
@@ -383,12 +399,12 @@
         "hex.builtin.setting.interface.scaling.x2_0": "x2.0",
         "hex.builtin.setting.interface.scaling.x3_0": "x3.0",
         "hex.builtin.setting.interface.scaling.x4_0": "x4.0",
-        "hex.builtin.setting.interface.wiki_explain_language": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.interface.wiki_explain_language": "",
         "hex.builtin.setting.proxy": "プロキシ",
-        "hex.builtin.setting.proxy.description": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.proxy.description": "",
         "hex.builtin.setting.proxy.enable": "プロキシを有効化",
         "hex.builtin.setting.proxy.url": "プロキシURL",
-        "hex.builtin.setting.proxy.url.tooltip": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.proxy.url.tooltip": "",
         "hex.builtin.tools.ascii_table": "ASCIIテーブル",
         "hex.builtin.tools.ascii_table.octal": "8進数表示",
         "hex.builtin.tools.base_converter": "単位変換",
@@ -456,21 +472,25 @@
         "hex.builtin.tools.format.scientific": "科学",
         "hex.builtin.tools.format.standard": "基本",
         "hex.builtin.tools.history": "履歴",
-        "hex.builtin.tools.ieee756": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.double_precision": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.exponent": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.exponent_size": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.formula": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.half_precision": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.mantissa": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.mantissa_size": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.result.float": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.result.hex": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.result.title": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.sign": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.singe_precision": "***** MISSING TRANSLATION *****",
-        "hex.builtin.tools.ieee756.type": "***** MISSING TRANSLATION *****",
+        "hex.builtin.tools.ieee754": "",
+        "hex.builtin.tools.ieee754.description": "",
+        "hex.builtin.tools.ieee754.double_precision": "",
+        "hex.builtin.tools.ieee754.exponent": "",
+        "hex.builtin.tools.ieee754.exponent_size": "",
+        "hex.builtin.tools.ieee754.formula": "",
+        "hex.builtin.tools.ieee754.half_precision": "",
+        "hex.builtin.tools.ieee754.mantissa": "",
+        "hex.builtin.tools.ieee754.mantissa_size": "",
+        "hex.builtin.tools.ieee754.result.float": "",
+        "hex.builtin.tools.ieee754.result.hex": "",
+        "hex.builtin.tools.ieee754.result.title": "",
+        "hex.builtin.tools.ieee754.sign": "",
+        "hex.builtin.tools.ieee754.singe_precision": "",
+        "hex.builtin.tools.ieee754.type": "",
         "hex.builtin.tools.input": "入力",
+        "hex.builtin.tools.invariant_multiplication": "",
+        "hex.builtin.tools.invariant_multiplication.description": "",
+        "hex.builtin.tools.invariant_multiplication.num_bits": "",
         "hex.builtin.tools.name": "名前",
         "hex.builtin.tools.permissions": "UNIXパーミッション計算機",
         "hex.builtin.tools.permissions.absolute": "数値表記",
@@ -568,7 +588,7 @@
         "hex.builtin.view.disassembler.name": "逆アセンブラ",
         "hex.builtin.view.disassembler.position": "位置",
         "hex.builtin.view.disassembler.ppc.booke": "Book-E",
-        "hex.builtin.view.disassembler.ppc.qpx": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.disassembler.ppc.qpx": "",
         "hex.builtin.view.disassembler.ppc.spe": "信号処理エンジン",
         "hex.builtin.view.disassembler.region": "コード領域",
         "hex.builtin.view.disassembler.riscv.compressed": "圧縮済み",
@@ -577,41 +597,41 @@
         "hex.builtin.view.disassembler.sparc.v9": "Sparc V9",
         "hex.builtin.view.find.binary_pattern": "16進数",
         "hex.builtin.view.find.context.copy": "値をコピー",
-        "hex.builtin.view.find.context.copy_demangle": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.demangled": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.find.context.copy_demangle": "",
+        "hex.builtin.view.find.demangled": "",
         "hex.builtin.view.find.name": "検索",
         "hex.builtin.view.find.regex": "正規表現",
-        "hex.builtin.view.find.regex.full_match": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.regex.pattern": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.search": "検索を実行",
+        "hex.builtin.view.find.regex.full_match": "",
+        "hex.builtin.view.find.regex.pattern": "",
+        "hex.builtin.view.find.search": "検索開始",
         "hex.builtin.view.find.search.entries": "一致件数: {0}",
-        "hex.builtin.view.find.search.reset": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.find.search.reset": "",
         "hex.builtin.view.find.searching": "検索中…",
-        "hex.builtin.view.find.sequences": "通常検索",
-        "hex.builtin.view.find.strings": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.chars": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.find.sequences": "ASCII",
+        "hex.builtin.view.find.strings": "",
+        "hex.builtin.view.find.strings.chars": "検索対象",
         "hex.builtin.view.find.strings.line_feeds": "ラインフィード",
         "hex.builtin.view.find.strings.lower_case": "大文字",
         "hex.builtin.view.find.strings.match_settings": "条件設定",
-        "hex.builtin.view.find.strings.min_length": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.null_term": "ヌル終端を含む文字列のみ検索",
+        "hex.builtin.view.find.strings.min_length": "",
+        "hex.builtin.view.find.strings.null_term": "ヌル終端を持つ文字列のみ検索",
         "hex.builtin.view.find.strings.numbers": "数字",
         "hex.builtin.view.find.strings.spaces": "半角スペース",
         "hex.builtin.view.find.strings.symbols": "その他の記号",
         "hex.builtin.view.find.strings.underscores": "アンダースコア",
         "hex.builtin.view.find.strings.upper_case": "小文字",
-        "hex.builtin.view.find.value": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.value.max": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.value.min": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.find.value": "数値",
+        "hex.builtin.view.find.value.max": "最大値",
+        "hex.builtin.view.find.value.min": "最小値",
         "hex.builtin.view.hashes.function": "ハッシュ関数",
-        "hex.builtin.view.hashes.hash": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hashes.hover_info": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hashes.hash": "",
+        "hex.builtin.view.hashes.hover_info": "",
         "hex.builtin.view.hashes.name": "ハッシュ",
-        "hex.builtin.view.hashes.no_settings": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hashes.remove": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hashes.table.name": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hashes.no_settings": "",
+        "hex.builtin.view.hashes.remove": "",
+        "hex.builtin.view.hashes.table.name": "",
         "hex.builtin.view.hashes.table.result": "結果",
-        "hex.builtin.view.hashes.table.type": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hashes.table.type": "",
         "hex.builtin.view.help.about.contributor": "ご協力頂いた方々",
         "hex.builtin.view.help.about.donations": "寄付",
         "hex.builtin.view.help.about.libs": "使用しているライブラリ",
@@ -625,15 +645,13 @@
         "hex.builtin.view.help.documentation": "ImHexドキュメント",
         "hex.builtin.view.help.name": "ヘルプ",
         "hex.builtin.view.help.pattern_cheat_sheet": "パターン言語リファレンス",
-        "hex.builtin.view.hex_editor.copy.address": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.copy.ascii": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hex_editor.copy.address": "",
         "hex.builtin.view.hex_editor.copy.base64": "Base64",
         "hex.builtin.view.hex_editor.copy.c": "C 配列",
         "hex.builtin.view.hex_editor.copy.cpp": "C++ 配列",
         "hex.builtin.view.hex_editor.copy.crystal": "Crystal 配列",
         "hex.builtin.view.hex_editor.copy.csharp": "C# 配列",
         "hex.builtin.view.hex_editor.copy.go": "Go 配列",
-        "hex.builtin.view.hex_editor.copy.hex": "文字列",
         "hex.builtin.view.hex_editor.copy.html": "HTML",
         "hex.builtin.view.hex_editor.copy.java": "Java 配列",
         "hex.builtin.view.hex_editor.copy.js": "JavaScript 配列",
@@ -649,45 +667,50 @@
         "hex.builtin.view.hex_editor.menu.edit.copy": "コピー",
         "hex.builtin.view.hex_editor.menu.edit.copy_as": "〜としてコピー…",
         "hex.builtin.view.hex_editor.menu.edit.insert": "挿入…",
-        "hex.builtin.view.hex_editor.menu.edit.jump_to": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.menu.edit.open_in_new_provider": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hex_editor.menu.edit.jump_to": "",
+        "hex.builtin.view.hex_editor.menu.edit.open_in_new_provider": "",
         "hex.builtin.view.hex_editor.menu.edit.paste": "貼り付け",
-        "hex.builtin.view.hex_editor.menu.edit.paste_all": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.menu.edit.remove": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hex_editor.menu.edit.paste_all": "",
+        "hex.builtin.view.hex_editor.menu.edit.remove": "",
         "hex.builtin.view.hex_editor.menu.edit.resize": "リサイズ…",
         "hex.builtin.view.hex_editor.menu.edit.select_all": "すべて選択",
         "hex.builtin.view.hex_editor.menu.edit.set_base": "ベースアドレスをセット",
         "hex.builtin.view.hex_editor.menu.file.goto": "移動",
-        "hex.builtin.view.hex_editor.menu.file.load_encoding_file": "カスタムエンコードを読み込む…",
+        "hex.builtin.view.hex_editor.menu.file.load_encoding_file": "カスタムデコードを読み込む…",
         "hex.builtin.view.hex_editor.menu.file.save": "保存",
         "hex.builtin.view.hex_editor.menu.file.save_as": "名前をつけて保存…",
         "hex.builtin.view.hex_editor.menu.file.search": "検索",
-        "hex.builtin.view.hex_editor.menu.file.select": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hex_editor.menu.file.select": "選択",
         "hex.builtin.view.hex_editor.name": "Hexエディタ",
         "hex.builtin.view.hex_editor.search.find": "検索",
         "hex.builtin.view.hex_editor.search.hex": "16進数",
         "hex.builtin.view.hex_editor.search.string": "文字列",
-        "hex.builtin.view.hex_editor.select.offset.begin": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.select.offset.end": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.select.offset.region": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.select.offset.size": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.select.select": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hex_editor.select.offset.begin": "",
+        "hex.builtin.view.hex_editor.select.offset.end": "",
+        "hex.builtin.view.hex_editor.select.offset.region": "",
+        "hex.builtin.view.hex_editor.select.offset.size": "",
+        "hex.builtin.view.hex_editor.select.select": "",
         "hex.builtin.view.information.analyze": "表示中のページを解析する",
         "hex.builtin.view.information.analyzing": "解析中…",
         "hex.builtin.view.information.block_size": "ブロックサイズ",
         "hex.builtin.view.information.block_size.desc": "{0} ブロック/ {1} バイト",
+        "hex.builtin.view.information.byte_types": "",
         "hex.builtin.view.information.control": "コントロール",
         "hex.builtin.view.information.description": "詳細:",
+        "hex.builtin.view.information.digram": "",
         "hex.builtin.view.information.distribution": "バイト分布",
         "hex.builtin.view.information.encrypted": "暗号化や圧縮を経たデータと推測されます。",
         "hex.builtin.view.information.entropy": "エントロピー",
         "hex.builtin.view.information.file_entropy": "ファイルのエントロピー",
         "hex.builtin.view.information.highest_entropy": "最大エントロピーブロック",
         "hex.builtin.view.information.info_analysis": "情報の分析",
+        "hex.builtin.view.information.layered_distribution": "",
         "hex.builtin.view.information.magic": "Magic情報",
         "hex.builtin.view.information.magic_db_added": "Magicデータベースが追加されました。",
         "hex.builtin.view.information.mime": "MIMEタイプ:",
         "hex.builtin.view.information.name": "データ解析",
+        "hex.builtin.view.information.plain_text": "",
+        "hex.builtin.view.information.plain_text_percentage": "",
         "hex.builtin.view.information.region": "解析する領域",
         "hex.builtin.view.patches.name": "パッチ",
         "hex.builtin.view.patches.offset": "オフセット",
@@ -705,22 +728,22 @@
         "hex.builtin.view.pattern_editor.dangerous_function.name": "危険な関数の使用を許可しますか？",
         "hex.builtin.view.pattern_editor.env_vars": "環境変数",
         "hex.builtin.view.pattern_editor.evaluating": "実行中…",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin.array": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin.single": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.custom": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern": "",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin": "",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin.array": "",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin.single": "",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.custom": "",
         "hex.builtin.view.pattern_editor.menu.file.load_pattern": "パターンを読み込み…",
         "hex.builtin.view.pattern_editor.menu.file.save_pattern": "パターンを保存…",
         "hex.builtin.view.pattern_editor.name": "パターンエディタ",
         "hex.builtin.view.pattern_editor.no_in_out_vars": "グローバル変数に 'in' または 'out' を指定して、ここに表示されるように定義してください。",
         "hex.builtin.view.pattern_editor.open_pattern": "パターンを開く",
-        "hex.builtin.view.pattern_editor.section_popup": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.sections": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.pattern_editor.section_popup": "",
+        "hex.builtin.view.pattern_editor.sections": "",
         "hex.builtin.view.pattern_editor.settings": "設定",
-        "hex.builtin.view.provider_settings.load_error": "プロバイダを開く際にエラーが発生しました。",
-        "hex.builtin.view.provider_settings.load_popup": "プロバイダを開く",
-        "hex.builtin.view.provider_settings.name": "プロバイダ設定",
+        "hex.builtin.view.provider_settings.load_error": "ファイルを開く際にエラーが発生しました。",
+        "hex.builtin.view.provider_settings.load_popup": "ファイルを開く",
+        "hex.builtin.view.provider_settings.name": "ファイル設定",
         "hex.builtin.view.settings.name": "設定",
         "hex.builtin.view.settings.restart_question": "変更を反映させるには、ImHexの再起動が必要です。今すぐ再起動しますか？",
         "hex.builtin.view.store.desc": "ImHexのオンラインデータベースから新しいコンテンツをダウンロードする",
@@ -728,7 +751,7 @@
         "hex.builtin.view.store.download_error": "ファイルのダウンロードに失敗しました。ダウンロード先フォルダが存在しません。",
         "hex.builtin.view.store.loading": "ストアコンテンツを読み込み中…",
         "hex.builtin.view.store.name": "コンテンツストア",
-        "hex.builtin.view.store.netfailed": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.store.netfailed": "",
         "hex.builtin.view.store.reload": "再読み込み",
         "hex.builtin.view.store.remove": "削除",
         "hex.builtin.view.store.row.description": "詳細",
@@ -751,7 +774,7 @@
         "hex.builtin.view.yara.name": "Yaraルール",
         "hex.builtin.view.yara.no_rules": "YARAルールが見つかりませんでした。ImHexの'yara'フォルダ内に入れてください",
         "hex.builtin.view.yara.reload": "リロード",
-        "hex.builtin.view.yara.reset": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.yara.reset": "",
         "hex.builtin.view.yara.rule_added": "Yaraルールが追加されました。",
         "hex.builtin.view.yara.whole_data": "ファイル全体が一致します。",
         "hex.builtin.visualizer.decimal.signed.16bit": "符号付き整数型 (16 bits)",
@@ -769,9 +792,9 @@
         "hex.builtin.visualizer.hexadecimal.32bit": "16進数 (32 bits)",
         "hex.builtin.visualizer.hexadecimal.64bit": "16進数 (64 bits)",
         "hex.builtin.visualizer.hexadecimal.8bit": "16進数 ( 8 bits)",
-        "hex.builtin.visualizer.hexii": "***** MISSING TRANSLATION *****",
+        "hex.builtin.visualizer.hexii": "",
         "hex.builtin.visualizer.rgba8": "RGBA8",
-        "hex.builtin.welcome.check_for_updates_text": "***** MISSING TRANSLATION *****",
+        "hex.builtin.welcome.check_for_updates_text": "",
         "hex.builtin.welcome.customize.settings.desc": "ImHexの設定を変更します",
         "hex.builtin.welcome.customize.settings.title": "設定",
         "hex.builtin.welcome.header.customize": "カスタマイズ",
@@ -806,7 +829,7 @@
         "hex.builtin.welcome.safety_backup.title": "セッションの回復",
         "hex.builtin.welcome.start.create_file": "新規ファイルを作成",
         "hex.builtin.welcome.start.open_file": "ファイルを開く…",
-        "hex.builtin.welcome.start.open_other": "その他のプロバイダ",
+        "hex.builtin.welcome.start.open_other": "その他のファイル",
         "hex.builtin.welcome.start.open_project": "プロジェクトを開く…",
         "hex.builtin.welcome.start.recent": "最近使用したファイル",
         "hex.builtin.welcome.tip_of_the_day": "今日の豆知識",

plugins/builtin/romfs/lang/ko_KR.json

@@ -12,11 +12,12 @@
         "hex.builtin.common.big": "빅",
         "hex.builtin.common.big_endian": "빅 엔디안",
         "hex.builtin.common.browse": "찾아보기...",
+        "hex.builtin.common.bytes": "",
         "hex.builtin.common.cancel": "취소",
         "hex.builtin.common.choose_file": "파일 선택",
         "hex.builtin.common.close": "닫기",
         "hex.builtin.common.comment": "주석",
-        "hex.builtin.common.count": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.count": "",
         "hex.builtin.common.decimal": "10진수",
         "hex.builtin.common.dont_show_again": "다시 보이지 않기",
         "hex.builtin.common.encoding.ascii": "ASCII",
@@ -30,18 +31,20 @@
         "hex.builtin.common.filter": "필터",
         "hex.builtin.common.hexadecimal": "16진수",
         "hex.builtin.common.info": "정보",
+        "hex.builtin.common.instruction": "",
         "hex.builtin.common.link": "링크",
         "hex.builtin.common.little": "리틀",
         "hex.builtin.common.little_endian": "리틀 엔디안",
         "hex.builtin.common.load": "불러오기",
         "hex.builtin.common.match_selection": "선택 범위와 일치",
-        "hex.builtin.common.name": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.name": "",
         "hex.builtin.common.no": "아니오",
         "hex.builtin.common.number_format": "포맷",
         "hex.builtin.common.octal": "8진수",
         "hex.builtin.common.offset": "오프셋",
         "hex.builtin.common.okay": "네",
         "hex.builtin.common.open": "열기",
+        "hex.builtin.common.percentage": "",
         "hex.builtin.common.processing": "작업 중",
         "hex.builtin.common.question": "질문",
         "hex.builtin.common.range": "범위",
@@ -132,8 +135,15 @@
         "hex.builtin.menu.file.close": "닫기",
         "hex.builtin.menu.file.create_file": "새 파일...",
         "hex.builtin.menu.file.export": "내보내기...",
-        "hex.builtin.menu.file.export.base64.popup.export_error": "파일이 올바른 Base64 형식이 아닙니다!",
+        "hex.builtin.menu.file.export.base64": "",
+        "hex.builtin.menu.file.export.base64.popup.export_error": "",
         "hex.builtin.menu.file.export.ips": "IPS 패치",
+        "hex.builtin.menu.file.export.ips.popup.address_out_of_range_error": "",
+        "hex.builtin.menu.file.export.ips.popup.export_error": "",
+        "hex.builtin.menu.file.export.ips.popup.invalid_patch_format_error": "",
+        "hex.builtin.menu.file.export.ips.popup.invalid_patch_header_error": "",
+        "hex.builtin.menu.file.export.ips.popup.missing_eof_error": "",
+        "hex.builtin.menu.file.export.ips.popup.patch_too_large_error": "",
         "hex.builtin.menu.file.export.ips32": "IPS32 패치",
         "hex.builtin.menu.file.export.popup.create": "데이터를 내보낼 수 없습니다. 파일을 만드는 데 실패했습니다!",
         "hex.builtin.menu.file.export.title": "파일 내보내기",
@@ -148,23 +158,23 @@
         "hex.builtin.menu.file.open_project": "프로젝트 열기...",
         "hex.builtin.menu.file.open_recent": "최근 파일",
         "hex.builtin.menu.file.quit": "ImHex 종료하기",
-        "hex.builtin.menu.file.reload_file": "***** MISSING TRANSLATION *****",
+        "hex.builtin.menu.file.reload_file": "",
         "hex.builtin.menu.file.save_project": "프로젝트 저장",
-        "hex.builtin.menu.file.save_project_as": "***** MISSING TRANSLATION *****",
+        "hex.builtin.menu.file.save_project_as": "",
         "hex.builtin.menu.help": "도움말",
         "hex.builtin.menu.layout": "레이아웃",
         "hex.builtin.menu.view": "뷰",
         "hex.builtin.menu.view.demo": "ImGui Demo 표시하기",
-        "hex.builtin.menu.view.fps": "***** MISSING TRANSLATION *****",
+        "hex.builtin.menu.view.fps": "",
         "hex.builtin.nodes.arithmetic": "수학",
         "hex.builtin.nodes.arithmetic.add": "덧셈",
         "hex.builtin.nodes.arithmetic.add.header": "덧셈",
-        "hex.builtin.nodes.arithmetic.average": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.arithmetic.average.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.arithmetic.average": "",
+        "hex.builtin.nodes.arithmetic.average.header": "",
         "hex.builtin.nodes.arithmetic.div": "나눗셈",
         "hex.builtin.nodes.arithmetic.div.header": "나눗셈",
-        "hex.builtin.nodes.arithmetic.median": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.arithmetic.median.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.arithmetic.median": "",
+        "hex.builtin.nodes.arithmetic.median.header": "",
         "hex.builtin.nodes.arithmetic.mod": "나머지",
         "hex.builtin.nodes.arithmetic.mod.header": "나머지",
         "hex.builtin.nodes.arithmetic.mul": "곱셈",
@@ -183,12 +193,12 @@
         "hex.builtin.nodes.buffer": "버퍼",
         "hex.builtin.nodes.buffer.combine": "합치기",
         "hex.builtin.nodes.buffer.combine.header": "버퍼 합치기",
-        "hex.builtin.nodes.buffer.patch": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.buffer.patch.header": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.buffer.patch.input.patch": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.buffer.patch": "",
+        "hex.builtin.nodes.buffer.patch.header": "",
+        "hex.builtin.nodes.buffer.patch.input.patch": "",
         "hex.builtin.nodes.buffer.repeat": "출력",
         "hex.builtin.nodes.buffer.repeat.header": "버퍼 반복",
-        "hex.builtin.nodes.buffer.repeat.input.buffer": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.buffer.repeat.input.buffer": "",
         "hex.builtin.nodes.buffer.repeat.input.count": "개수",
         "hex.builtin.nodes.buffer.slice": "자르기",
         "hex.builtin.nodes.buffer.slice.header": "버퍼 자르기",
@@ -196,20 +206,20 @@
         "hex.builtin.nodes.buffer.slice.input.from": "시작",
         "hex.builtin.nodes.buffer.slice.input.to": "끝",
         "hex.builtin.nodes.casting": "데이터 변환",
-        "hex.builtin.nodes.casting.buffer_to_float": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.casting.buffer_to_float.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.casting.buffer_to_float": "",
+        "hex.builtin.nodes.casting.buffer_to_float.header": "",
         "hex.builtin.nodes.casting.buffer_to_int": "버퍼에서 정수로",
         "hex.builtin.nodes.casting.buffer_to_int.header": "버퍼에서 정수로",
-        "hex.builtin.nodes.casting.float_to_buffer": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.casting.float_to_buffer.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.casting.float_to_buffer": "",
+        "hex.builtin.nodes.casting.float_to_buffer.header": "",
         "hex.builtin.nodes.casting.int_to_buffer": "정수에서 버퍼로",
         "hex.builtin.nodes.casting.int_to_buffer.header": "정수에서 버퍼로",
-        "hex.builtin.nodes.common.height": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.common.height": "",
         "hex.builtin.nodes.common.input": "Input",
         "hex.builtin.nodes.common.input.a": "Input A",
         "hex.builtin.nodes.common.input.b": "Input B",
         "hex.builtin.nodes.common.output": "Output",
-        "hex.builtin.nodes.common.width": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.common.width": "",
         "hex.builtin.nodes.constants": "상수",
         "hex.builtin.nodes.constants.buffer": "버퍼",
         "hex.builtin.nodes.constants.buffer.header": "버퍼",
@@ -279,17 +289,17 @@
         "hex.builtin.nodes.decoding.hex": "16진수",
         "hex.builtin.nodes.decoding.hex.header": "16진수 decoder",
         "hex.builtin.nodes.display": "디스플레이",
-        "hex.builtin.nodes.display.buffer": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.display.buffer.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.display.buffer": "",
+        "hex.builtin.nodes.display.buffer.header": "",
         "hex.builtin.nodes.display.float": "실수",
         "hex.builtin.nodes.display.float.header": "실수 디스플레이",
         "hex.builtin.nodes.display.int": "정수",
         "hex.builtin.nodes.display.int.header": "정수 디스플레이",
-        "hex.builtin.nodes.display.string": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.display.string.header": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.pattern_language": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.pattern_language.out_var": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.pattern_language.out_var.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.display.string": "",
+        "hex.builtin.nodes.display.string.header": "",
+        "hex.builtin.nodes.pattern_language": "",
+        "hex.builtin.nodes.pattern_language.out_var": "",
+        "hex.builtin.nodes.pattern_language.out_var.header": "",
         "hex.builtin.nodes.visualizer": "시작화",
         "hex.builtin.nodes.visualizer.byte_distribution": "바이트 분포",
         "hex.builtin.nodes.visualizer.byte_distribution.header": "바이트 분포",
@@ -297,27 +307,29 @@
         "hex.builtin.nodes.visualizer.digram.header": "다이어그램",
         "hex.builtin.nodes.visualizer.image": "이미지",
         "hex.builtin.nodes.visualizer.image.header": "이미지 시각화",
-        "hex.builtin.nodes.visualizer.image_rgba": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.visualizer.image_rgba.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.visualizer.image_rgba": "",
+        "hex.builtin.nodes.visualizer.image_rgba.header": "",
         "hex.builtin.nodes.visualizer.layered_dist": "계층적 분포",
         "hex.builtin.nodes.visualizer.layered_dist.header": "계층적 분포",
         "hex.builtin.pattern_drawer.color": "색상",
-        "hex.builtin.pattern_drawer.double_click": "***** MISSING TRANSLATION *****",
+        "hex.builtin.pattern_drawer.double_click": "",
         "hex.builtin.pattern_drawer.offset": "오프셋",
         "hex.builtin.pattern_drawer.size": "크기",
         "hex.builtin.pattern_drawer.type": "타입",
         "hex.builtin.pattern_drawer.value": "값",
         "hex.builtin.pattern_drawer.var_name": "이름",
+        "hex.builtin.pattern_drawer.visualizer.invalid_parameter_count": "",
+        "hex.builtin.pattern_drawer.visualizer.unknown": "",
         "hex.builtin.popup.close_provider.desc": "공급자에 저장하지 않은 내용이 있습니다.\n정말로 종료하시겠습니까?",
         "hex.builtin.popup.close_provider.title": "공급자를 종료하시겠습니까?",
         "hex.builtin.popup.error.create": "새 파일을 만드는데 실패했습니다!",
-        "hex.builtin.popup.error.file_dialog.common": "***** MISSING TRANSLATION *****",
-        "hex.builtin.popup.error.file_dialog.portal": "***** MISSING TRANSLATION *****",
+        "hex.builtin.popup.error.file_dialog.common": "",
+        "hex.builtin.popup.error.file_dialog.portal": "",
         "hex.builtin.popup.error.open": "파일을 여는데 실패했습니다!",
-        "hex.builtin.popup.error.project.load": "***** MISSING TRANSLATION *****",
-        "hex.builtin.popup.error.project.save": "***** MISSING TRANSLATION *****",
+        "hex.builtin.popup.error.project.load": "",
+        "hex.builtin.popup.error.project.save": "",
         "hex.builtin.popup.error.read_only": "쓰기 권한을 가져올 수 없습니다. 파일이 읽기 전용 모드로 열렸습니다.",
-        "hex.builtin.popup.error.task_exception": "***** MISSING TRANSLATION *****",
+        "hex.builtin.popup.error.task_exception": "",
         "hex.builtin.popup.exit_application.desc": "프로젝트에 저장하지 않은 내용이 있습니다.\n정말로 종료하시겠습니까?",
         "hex.builtin.popup.exit_application.title": "프로그램을 종료하시겠습니까?",
         "hex.builtin.provider.disk": "Raw 디스크 공급자",
@@ -338,11 +350,11 @@
         "hex.builtin.provider.gdb.server": "서버",
         "hex.builtin.provider.intel_hex": "Intel Hex 공급자",
         "hex.builtin.provider.intel_hex.name": "Intel Hex {0}",
-        "hex.builtin.provider.mem_file": "***** MISSING TRANSLATION *****",
-        "hex.builtin.provider.mem_file.unsaved": "***** MISSING TRANSLATION *****",
+        "hex.builtin.provider.mem_file": "",
+        "hex.builtin.provider.mem_file.unsaved": "",
         "hex.builtin.provider.motorola_srec": "Motorola SREC 공급자",
         "hex.builtin.provider.motorola_srec.name": "Motorola SREC {0}",
-        "hex.builtin.provider.view": "***** MISSING TRANSLATION *****",
+        "hex.builtin.provider.view": "",
         "hex.builtin.setting.folders": "폴더",
         "hex.builtin.setting.folders.add_folder": "새 폴더 추가",
         "hex.builtin.setting.folders.description": "패턴, 스크립트, YARA 규칙 등을 찾아볼 추가적인 폴더 경로를 지정하세요",
@@ -352,19 +364,19 @@
         "hex.builtin.setting.font.font_size": "글꼴 크기",
         "hex.builtin.setting.general": "일반",
         "hex.builtin.setting.general.auto_load_patterns": "지원하는 패턴 자동으로 로드",
-        "hex.builtin.setting.general.check_for_updates": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.general.enable_unicode": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.general.check_for_updates": "",
+        "hex.builtin.setting.general.enable_unicode": "",
         "hex.builtin.setting.general.show_tips": "시작 시 팁 표시",
         "hex.builtin.setting.general.sync_pattern_source": "공급자 간 패턴 소스 코드 동기화",
         "hex.builtin.setting.hex_editor": "헥스 편집기",
         "hex.builtin.setting.hex_editor.advanced_decoding": "추가 디코딩 열 표시",
         "hex.builtin.setting.hex_editor.ascii": "ASCII 열 표시",
-        "hex.builtin.setting.hex_editor.byte_padding": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.hex_editor.byte_padding": "",
         "hex.builtin.setting.hex_editor.bytes_per_row": "한 줄당 바이트 수",
-        "hex.builtin.setting.hex_editor.char_padding": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.hex_editor.char_padding": "",
         "hex.builtin.setting.hex_editor.grey_zeros": "00을 회색으로 표시",
         "hex.builtin.setting.hex_editor.highlight_color": "선택 영역 색상 하이라이트",
-        "hex.builtin.setting.hex_editor.sync_scrolling": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.hex_editor.sync_scrolling": "",
         "hex.builtin.setting.hex_editor.uppercase_hex": "16진수 값을 대문자로 표시",
         "hex.builtin.setting.hex_editor.visualizer": "데이터 표시",
         "hex.builtin.setting.imhex": "ImHex",
@@ -374,7 +386,11 @@
         "hex.builtin.setting.interface.fps": "FPS 제한",
         "hex.builtin.setting.interface.fps.unlocked": "제한 없음",
         "hex.builtin.setting.interface.language": "언어",
-        "hex.builtin.setting.interface.multi_windows": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.interface.multi_windows": "",
+        "hex.builtin.setting.interface.pattern_tree_style": "",
+        "hex.builtin.setting.interface.pattern_tree_style.auto_expanded": "",
+        "hex.builtin.setting.interface.pattern_tree_style.flattened": "",
+        "hex.builtin.setting.interface.pattern_tree_style.tree": "",
         "hex.builtin.setting.interface.scaling": "크기",
         "hex.builtin.setting.interface.scaling.native": "기본",
         "hex.builtin.setting.interface.scaling.x0_5": "x0.5",
@@ -456,21 +472,25 @@
         "hex.builtin.tools.format.scientific": "공학용",
         "hex.builtin.tools.format.standard": "표준",
         "hex.builtin.tools.history": "이력",
-        "hex.builtin.tools.ieee756": "IEEE 756 부동 소수점 테스트",
-        "hex.builtin.tools.ieee756.double_precision": "Double Precision",
-        "hex.builtin.tools.ieee756.exponent": "지수부",
-        "hex.builtin.tools.ieee756.exponent_size": "지수부 크기",
-        "hex.builtin.tools.ieee756.formula": "공식",
-        "hex.builtin.tools.ieee756.half_precision": "Half Precision",
-        "hex.builtin.tools.ieee756.mantissa": "가수부",
-        "hex.builtin.tools.ieee756.mantissa_size": "가수부 크기",
-        "hex.builtin.tools.ieee756.result.float": "부동 소수점 결과",
-        "hex.builtin.tools.ieee756.result.hex": "16진수 결과",
-        "hex.builtin.tools.ieee756.result.title": "결과",
-        "hex.builtin.tools.ieee756.sign": "부포",
-        "hex.builtin.tools.ieee756.singe_precision": "Single Precision",
-        "hex.builtin.tools.ieee756.type": "종류",
+        "hex.builtin.tools.ieee754": "IEEE 754 부동 소수점 테스트",
+        "hex.builtin.tools.ieee754.description": "",
+        "hex.builtin.tools.ieee754.double_precision": "Double Precision",
+        "hex.builtin.tools.ieee754.exponent": "지수부",
+        "hex.builtin.tools.ieee754.exponent_size": "지수부 크기",
+        "hex.builtin.tools.ieee754.formula": "공식",
+        "hex.builtin.tools.ieee754.half_precision": "Half Precision",
+        "hex.builtin.tools.ieee754.mantissa": "가수부",
+        "hex.builtin.tools.ieee754.mantissa_size": "가수부 크기",
+        "hex.builtin.tools.ieee754.result.float": "부동 소수점 결과",
+        "hex.builtin.tools.ieee754.result.hex": "16진수 결과",
+        "hex.builtin.tools.ieee754.result.title": "결과",
+        "hex.builtin.tools.ieee754.sign": "부포",
+        "hex.builtin.tools.ieee754.singe_precision": "Single Precision",
+        "hex.builtin.tools.ieee754.type": "종류",
         "hex.builtin.tools.input": "입력",
+        "hex.builtin.tools.invariant_multiplication": "",
+        "hex.builtin.tools.invariant_multiplication.description": "",
+        "hex.builtin.tools.invariant_multiplication.num_bits": "",
         "hex.builtin.tools.name": "이름",
         "hex.builtin.tools.permissions": "UNIX 권한 계산기",
         "hex.builtin.tools.permissions.absolute": "절대값",
@@ -581,11 +601,11 @@
         "hex.builtin.view.find.demangled": "Demangled",
         "hex.builtin.view.find.name": "찾기",
         "hex.builtin.view.find.regex": "정규식",
-        "hex.builtin.view.find.regex.full_match": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.regex.pattern": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.find.regex.full_match": "",
+        "hex.builtin.view.find.regex.pattern": "",
         "hex.builtin.view.find.search": "검색",
         "hex.builtin.view.find.search.entries": "{} 개 검색됨",
-        "hex.builtin.view.find.search.reset": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.find.search.reset": "",
         "hex.builtin.view.find.searching": "검색 중...",
         "hex.builtin.view.find.sequences": "텍스트 시퀸스",
         "hex.builtin.view.find.strings": "문자열",
@@ -600,9 +620,9 @@
         "hex.builtin.view.find.strings.symbols": "특수 문자",
         "hex.builtin.view.find.strings.underscores": "언더스코어",
         "hex.builtin.view.find.strings.upper_case": "대문자",
-        "hex.builtin.view.find.value": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.value.max": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.value.min": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.find.value": "",
+        "hex.builtin.view.find.value.max": "",
+        "hex.builtin.view.find.value.min": "",
         "hex.builtin.view.hashes.function": "해시 함수",
         "hex.builtin.view.hashes.hash": "해시",
         "hex.builtin.view.hashes.hover_info": "헥스 편집기에서 영역을 선택 후 쉬프트를 누른 채로 마우스 커서를 올리면 해당 값들의 해시를 알 수 있습니다.",
@@ -625,15 +645,13 @@
         "hex.builtin.view.help.documentation": "ImHex 문서",
         "hex.builtin.view.help.name": "도움말",
         "hex.builtin.view.help.pattern_cheat_sheet": "패턴 언어 치트시트",
-        "hex.builtin.view.hex_editor.copy.address": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.copy.ascii": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hex_editor.copy.address": "",
         "hex.builtin.view.hex_editor.copy.base64": "Base64",
         "hex.builtin.view.hex_editor.copy.c": "C 배열",
         "hex.builtin.view.hex_editor.copy.cpp": "C++ 배열",
         "hex.builtin.view.hex_editor.copy.crystal": "Crystal 배열",
         "hex.builtin.view.hex_editor.copy.csharp": "C# 배열",
         "hex.builtin.view.hex_editor.copy.go": "Go 배열",
-        "hex.builtin.view.hex_editor.copy.hex": "문자열",
         "hex.builtin.view.hex_editor.copy.html": "HTML",
         "hex.builtin.view.hex_editor.copy.java": "Java 배열",
         "hex.builtin.view.hex_editor.copy.js": "JavaScript 배열",
@@ -649,10 +667,10 @@
         "hex.builtin.view.hex_editor.menu.edit.copy": "복사",
         "hex.builtin.view.hex_editor.menu.edit.copy_as": "다른 방법으로 복사...",
         "hex.builtin.view.hex_editor.menu.edit.insert": "삽입...",
-        "hex.builtin.view.hex_editor.menu.edit.jump_to": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.menu.edit.open_in_new_provider": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hex_editor.menu.edit.jump_to": "",
+        "hex.builtin.view.hex_editor.menu.edit.open_in_new_provider": "",
         "hex.builtin.view.hex_editor.menu.edit.paste": "붙여넣기",
-        "hex.builtin.view.hex_editor.menu.edit.paste_all": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hex_editor.menu.edit.paste_all": "",
         "hex.builtin.view.hex_editor.menu.edit.remove": "삭제...",
         "hex.builtin.view.hex_editor.menu.edit.resize": "크기 변경...",
         "hex.builtin.view.hex_editor.menu.edit.select_all": "모두 선택하기",
@@ -676,18 +694,23 @@
         "hex.builtin.view.information.analyzing": "분석 중...",
         "hex.builtin.view.information.block_size": "블록 크기",
         "hex.builtin.view.information.block_size.desc": "{1} 바이트 중 {0} 블록 ",
+        "hex.builtin.view.information.byte_types": "",
         "hex.builtin.view.information.control": "컨트롤",
         "hex.builtin.view.information.description": "설명:",
+        "hex.builtin.view.information.digram": "",
         "hex.builtin.view.information.distribution": "바이트 분포",
         "hex.builtin.view.information.encrypted": "이 데이터는 아마 암호화 혹은 압축되었을 가능성이 높습니다!",
         "hex.builtin.view.information.entropy": "엔트로피",
         "hex.builtin.view.information.file_entropy": "파일 엔트로피",
         "hex.builtin.view.information.highest_entropy": "최대 엔트로피 블록",
         "hex.builtin.view.information.info_analysis": "정보 분석",
+        "hex.builtin.view.information.layered_distribution": "",
         "hex.builtin.view.information.magic": "Magic 정보",
         "hex.builtin.view.information.magic_db_added": "Magic 데이터베이스 추가됨!",
         "hex.builtin.view.information.mime": "MIME 타입:",
         "hex.builtin.view.information.name": "데이터 정보",
+        "hex.builtin.view.information.plain_text": "",
+        "hex.builtin.view.information.plain_text_percentage": "",
         "hex.builtin.view.information.region": "분석한 영역",
         "hex.builtin.view.patches.name": "패치",
         "hex.builtin.view.patches.offset": "오프셋",
@@ -705,18 +728,18 @@
         "hex.builtin.view.pattern_editor.dangerous_function.name": "위험한 함수를 허용하시겠습니까?",
         "hex.builtin.view.pattern_editor.env_vars": "환경 변수",
         "hex.builtin.view.pattern_editor.evaluating": "평가 중...",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin.array": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin.single": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.custom": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern": "",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin": "",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin.array": "",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin.single": "",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.custom": "",
         "hex.builtin.view.pattern_editor.menu.file.load_pattern": "패턴 불러오기...",
         "hex.builtin.view.pattern_editor.menu.file.save_pattern": "패턴 저장하기...",
         "hex.builtin.view.pattern_editor.name": "패턴 편집기",
         "hex.builtin.view.pattern_editor.no_in_out_vars": "'in' 또는 'out' 지정자를 이용해 여기에 나타날 전역 변수를 선언합니다.",
         "hex.builtin.view.pattern_editor.open_pattern": "패턴 열기",
-        "hex.builtin.view.pattern_editor.section_popup": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.sections": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.pattern_editor.section_popup": "",
+        "hex.builtin.view.pattern_editor.sections": "",
         "hex.builtin.view.pattern_editor.settings": "설정",
         "hex.builtin.view.provider_settings.load_error": "이 공급자를 여는 도중 에러가 발생했습니다!",
         "hex.builtin.view.provider_settings.load_popup": "공급자 열기",
@@ -728,7 +751,7 @@
         "hex.builtin.view.store.download_error": "파일 다운로드에 실패했습니다! 저장 폴더가 존재하지 않습니다.",
         "hex.builtin.view.store.loading": "스토어 콘텐츠 불러오는 중...",
         "hex.builtin.view.store.name": "콘텐츠 스토어",
-        "hex.builtin.view.store.netfailed": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.store.netfailed": "",
         "hex.builtin.view.store.reload": "새로 고침",
         "hex.builtin.view.store.remove": "제거",
         "hex.builtin.view.store.row.description": "설명",
@@ -751,7 +774,7 @@
         "hex.builtin.view.yara.name": "Yara 규칙",
         "hex.builtin.view.yara.no_rules": "YARA 규칙이 없습니다. ImHex의 'yara' 폴더에 YARA 규칙을 넣으세요.",
         "hex.builtin.view.yara.reload": "재검사",
-        "hex.builtin.view.yara.reset": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.yara.reset": "",
         "hex.builtin.view.yara.rule_added": "Yara 규칙 추가됨!",
         "hex.builtin.view.yara.whole_data": "모든 파일을 검색했습니다!",
         "hex.builtin.visualizer.decimal.signed.16bit": "부호 있는 10진수 (16 비트)",
@@ -771,7 +794,7 @@
         "hex.builtin.visualizer.hexadecimal.8bit": "16진수 (8 비트)",
         "hex.builtin.visualizer.hexii": "HexII",
         "hex.builtin.visualizer.rgba8": "RGBA8 색상",
-        "hex.builtin.welcome.check_for_updates_text": "***** MISSING TRANSLATION *****",
+        "hex.builtin.welcome.check_for_updates_text": "",
         "hex.builtin.welcome.customize.settings.desc": "ImHex의 설정을 변경합니다",
         "hex.builtin.welcome.customize.settings.title": "설정",
         "hex.builtin.welcome.header.customize": "커스터마이즈",

plugins/builtin/romfs/lang/pt_BR.json

@@ -12,11 +12,12 @@
         "hex.builtin.common.big": "Big",
         "hex.builtin.common.big_endian": "Big Endian",
         "hex.builtin.common.browse": "Navegar...",
+        "hex.builtin.common.bytes": "",
         "hex.builtin.common.cancel": "Cancelar",
         "hex.builtin.common.choose_file": "Escolher arquivo",
         "hex.builtin.common.close": "Fechar",
-        "hex.builtin.common.comment": "***** MISSING TRANSLATION *****",
-        "hex.builtin.common.count": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.comment": "",
+        "hex.builtin.common.count": "",
         "hex.builtin.common.decimal": "Decimal",
         "hex.builtin.common.dont_show_again": "Não Mostrar Novamente",
         "hex.builtin.common.encoding.ascii": "ASCII",
@@ -27,30 +28,32 @@
         "hex.builtin.common.error": "Erro",
         "hex.builtin.common.fatal": "Erro Fatal",
         "hex.builtin.common.file": "Arquivo",
-        "hex.builtin.common.filter": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.filter": "",
         "hex.builtin.common.hexadecimal": "Hexadecimal",
         "hex.builtin.common.info": "Informação",
+        "hex.builtin.common.instruction": "",
         "hex.builtin.common.link": "Link",
         "hex.builtin.common.little": "Little",
         "hex.builtin.common.little_endian": "Little Endian",
         "hex.builtin.common.load": "Carregar",
         "hex.builtin.common.match_selection": "Seleção de correspondência",
-        "hex.builtin.common.name": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.name": "",
         "hex.builtin.common.no": "Não",
         "hex.builtin.common.number_format": "Format",
         "hex.builtin.common.octal": "Octal",
         "hex.builtin.common.offset": "Offset",
         "hex.builtin.common.okay": "OK",
         "hex.builtin.common.open": "Abrir",
+        "hex.builtin.common.percentage": "",
         "hex.builtin.common.processing": "Processando",
         "hex.builtin.common.question": "Question",
-        "hex.builtin.common.range": "***** MISSING TRANSLATION *****",
-        "hex.builtin.common.range.entire_data": "***** MISSING TRANSLATION *****",
-        "hex.builtin.common.range.selection": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.range": "",
+        "hex.builtin.common.range.entire_data": "",
+        "hex.builtin.common.range.selection": "",
         "hex.builtin.common.region": "Region",
         "hex.builtin.common.set": "Colocar",
         "hex.builtin.common.size": "Tamanho",
-        "hex.builtin.common.type": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.type": "",
         "hex.builtin.common.type.f32": "float",
         "hex.builtin.common.type.f64": "double",
         "hex.builtin.common.type.i16": "int16_t",
@@ -65,7 +68,7 @@
         "hex.builtin.common.type.u48": "uint48_t",
         "hex.builtin.common.type.u64": "uint64_t",
         "hex.builtin.common.type.u8": "uint8_t",
-        "hex.builtin.common.value": "***** MISSING TRANSLATION *****",
+        "hex.builtin.common.value": "",
         "hex.builtin.common.yes": "Sim",
         "hex.builtin.hash.crc.iv": "Initial Value",
         "hex.builtin.hash.crc.poly": "Polynomial",
@@ -105,7 +108,7 @@
         "hex.builtin.inspector.long_double": "long double (128 bit)",
         "hex.builtin.inspector.rgb565": "RGB565 Color",
         "hex.builtin.inspector.rgba8": "RGBA8 Color",
-        "hex.builtin.inspector.sleb128": "***** MISSING TRANSLATION *****",
+        "hex.builtin.inspector.sleb128": "",
         "hex.builtin.inspector.string": "String",
         "hex.builtin.inspector.string16": "Wide String",
         "hex.builtin.inspector.time": "time_t",
@@ -117,7 +120,7 @@
         "hex.builtin.inspector.u48": "uint48_t",
         "hex.builtin.inspector.u64": "uint64_t",
         "hex.builtin.inspector.u8": "uint8_t",
-        "hex.builtin.inspector.uleb128": "***** MISSING TRANSLATION *****",
+        "hex.builtin.inspector.uleb128": "",
         "hex.builtin.inspector.utf8": "UTF-8 code point",
         "hex.builtin.inspector.wide": "Wide Character",
         "hex.builtin.layouts.default": "Default",
@@ -126,14 +129,21 @@
         "hex.builtin.menu.edit.redo": "Refazer",
         "hex.builtin.menu.edit.undo": "Desfazer",
         "hex.builtin.menu.file": "File",
-        "hex.builtin.menu.file.bookmark.export": "***** MISSING TRANSLATION *****",
-        "hex.builtin.menu.file.bookmark.import": "***** MISSING TRANSLATION *****",
+        "hex.builtin.menu.file.bookmark.export": "",
+        "hex.builtin.menu.file.bookmark.import": "",
         "hex.builtin.menu.file.clear_recent": "Limpar",
         "hex.builtin.menu.file.close": "Fechar",
-        "hex.builtin.menu.file.create_file": "***** MISSING TRANSLATION *****",
+        "hex.builtin.menu.file.create_file": "",
         "hex.builtin.menu.file.export": "Exportar...",
-        "hex.builtin.menu.file.export.base64.popup.export_error": "Esse arquivo não é baseado em um formato Base64 valido!",
+        "hex.builtin.menu.file.export.base64": "",
+        "hex.builtin.menu.file.export.base64.popup.export_error": "",
         "hex.builtin.menu.file.export.ips": "IPS Patch",
+        "hex.builtin.menu.file.export.ips.popup.address_out_of_range_error": "",
+        "hex.builtin.menu.file.export.ips.popup.export_error": "",
+        "hex.builtin.menu.file.export.ips.popup.invalid_patch_format_error": "",
+        "hex.builtin.menu.file.export.ips.popup.invalid_patch_header_error": "",
+        "hex.builtin.menu.file.export.ips.popup.missing_eof_error": "",
+        "hex.builtin.menu.file.export.ips.popup.patch_too_large_error": "",
         "hex.builtin.menu.file.export.ips32": "IPS32 Patch",
         "hex.builtin.menu.file.export.popup.create": "Não é possível exportar os dados. Falha ao criar arquivo!",
         "hex.builtin.menu.file.export.title": "Exportar Arquivo",
@@ -148,9 +158,9 @@
         "hex.builtin.menu.file.open_project": "Abrir Projeto...",
         "hex.builtin.menu.file.open_recent": "Abrir Recentes",
         "hex.builtin.menu.file.quit": "Sair do ImHex",
-        "hex.builtin.menu.file.reload_file": "***** MISSING TRANSLATION *****",
+        "hex.builtin.menu.file.reload_file": "",
         "hex.builtin.menu.file.save_project": "Salvar Projeto",
-        "hex.builtin.menu.file.save_project_as": "***** MISSING TRANSLATION *****",
+        "hex.builtin.menu.file.save_project_as": "",
         "hex.builtin.menu.help": "Ajuda",
         "hex.builtin.menu.layout": "Layout",
         "hex.builtin.menu.view": "Exibir",
@@ -159,12 +169,12 @@
         "hex.builtin.nodes.arithmetic": "Aritmética",
         "hex.builtin.nodes.arithmetic.add": "Adição",
         "hex.builtin.nodes.arithmetic.add.header": "Adicionar",
-        "hex.builtin.nodes.arithmetic.average": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.arithmetic.average.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.arithmetic.average": "",
+        "hex.builtin.nodes.arithmetic.average.header": "",
         "hex.builtin.nodes.arithmetic.div": "Divisão",
         "hex.builtin.nodes.arithmetic.div.header": "Dividir",
-        "hex.builtin.nodes.arithmetic.median": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.arithmetic.median.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.arithmetic.median": "",
+        "hex.builtin.nodes.arithmetic.median.header": "",
         "hex.builtin.nodes.arithmetic.mod": "Módulos",
         "hex.builtin.nodes.arithmetic.mod.header": "Módulo",
         "hex.builtin.nodes.arithmetic.mul": "Multiplição",
@@ -183,12 +193,12 @@
         "hex.builtin.nodes.buffer": "Buffer",
         "hex.builtin.nodes.buffer.combine": "Combinar",
         "hex.builtin.nodes.buffer.combine.header": "Combinar buffers",
-        "hex.builtin.nodes.buffer.patch": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.buffer.patch.header": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.buffer.patch.input.patch": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.buffer.patch": "",
+        "hex.builtin.nodes.buffer.patch.header": "",
+        "hex.builtin.nodes.buffer.patch.input.patch": "",
         "hex.builtin.nodes.buffer.repeat": "Repetir",
         "hex.builtin.nodes.buffer.repeat.header": "Repetir buffer",
-        "hex.builtin.nodes.buffer.repeat.input.buffer": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.buffer.repeat.input.buffer": "",
         "hex.builtin.nodes.buffer.repeat.input.count": "Contar",
         "hex.builtin.nodes.buffer.slice": "Slice",
         "hex.builtin.nodes.buffer.slice.header": "Slice buffer",
@@ -196,20 +206,20 @@
         "hex.builtin.nodes.buffer.slice.input.from": "Do",
         "hex.builtin.nodes.buffer.slice.input.to": "Para",
         "hex.builtin.nodes.casting": "Conversão de Dados",
-        "hex.builtin.nodes.casting.buffer_to_float": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.casting.buffer_to_float.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.casting.buffer_to_float": "",
+        "hex.builtin.nodes.casting.buffer_to_float.header": "",
         "hex.builtin.nodes.casting.buffer_to_int": "Buffer to Integer",
         "hex.builtin.nodes.casting.buffer_to_int.header": "Buffer to Integer",
-        "hex.builtin.nodes.casting.float_to_buffer": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.casting.float_to_buffer.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.casting.float_to_buffer": "",
+        "hex.builtin.nodes.casting.float_to_buffer.header": "",
         "hex.builtin.nodes.casting.int_to_buffer": "Integer to Buffer",
         "hex.builtin.nodes.casting.int_to_buffer.header": "Integer to Buffer",
-        "hex.builtin.nodes.common.height": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.common.height": "",
         "hex.builtin.nodes.common.input": "Input",
         "hex.builtin.nodes.common.input.a": "Input A",
         "hex.builtin.nodes.common.input.b": "Input B",
         "hex.builtin.nodes.common.output": "Output",
-        "hex.builtin.nodes.common.width": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.common.width": "",
         "hex.builtin.nodes.constants": "Constants",
         "hex.builtin.nodes.constants.buffer": "Buffer",
         "hex.builtin.nodes.constants.buffer.header": "Buffer",
@@ -279,17 +289,17 @@
         "hex.builtin.nodes.decoding.hex": "Hexadecimal",
         "hex.builtin.nodes.decoding.hex.header": "Hexadecimal decoder",
         "hex.builtin.nodes.display": "Display",
-        "hex.builtin.nodes.display.buffer": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.display.buffer.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.display.buffer": "",
+        "hex.builtin.nodes.display.buffer.header": "",
         "hex.builtin.nodes.display.float": "Float",
         "hex.builtin.nodes.display.float.header": "Float display",
         "hex.builtin.nodes.display.int": "Integer",
         "hex.builtin.nodes.display.int.header": "Integer display",
-        "hex.builtin.nodes.display.string": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.display.string.header": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.pattern_language": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.pattern_language.out_var": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.pattern_language.out_var.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.display.string": "",
+        "hex.builtin.nodes.display.string.header": "",
+        "hex.builtin.nodes.pattern_language": "",
+        "hex.builtin.nodes.pattern_language.out_var": "",
+        "hex.builtin.nodes.pattern_language.out_var.header": "",
         "hex.builtin.nodes.visualizer": "Visualizers",
         "hex.builtin.nodes.visualizer.byte_distribution": "Byte Distribution",
         "hex.builtin.nodes.visualizer.byte_distribution.header": "Byte Distribution",
@@ -297,27 +307,29 @@
         "hex.builtin.nodes.visualizer.digram.header": "Digram",
         "hex.builtin.nodes.visualizer.image": "Image",
         "hex.builtin.nodes.visualizer.image.header": "Image Visualizer",
-        "hex.builtin.nodes.visualizer.image_rgba": "***** MISSING TRANSLATION *****",
-        "hex.builtin.nodes.visualizer.image_rgba.header": "***** MISSING TRANSLATION *****",
+        "hex.builtin.nodes.visualizer.image_rgba": "",
+        "hex.builtin.nodes.visualizer.image_rgba.header": "",
         "hex.builtin.nodes.visualizer.layered_dist": "Layered Distribution",
         "hex.builtin.nodes.visualizer.layered_dist.header": "Layered Distribution",
         "hex.builtin.pattern_drawer.color": "Cor",
-        "hex.builtin.pattern_drawer.double_click": "***** MISSING TRANSLATION *****",
+        "hex.builtin.pattern_drawer.double_click": "",
         "hex.builtin.pattern_drawer.offset": "Offset",
         "hex.builtin.pattern_drawer.size": "Tamanho",
         "hex.builtin.pattern_drawer.type": "Tipo",
         "hex.builtin.pattern_drawer.value": "Valor",
         "hex.builtin.pattern_drawer.var_name": "Nome",
-        "hex.builtin.popup.close_provider.desc": "***** MISSING TRANSLATION *****",
-        "hex.builtin.popup.close_provider.title": "***** MISSING TRANSLATION *****",
+        "hex.builtin.pattern_drawer.visualizer.invalid_parameter_count": "",
+        "hex.builtin.pattern_drawer.visualizer.unknown": "",
+        "hex.builtin.popup.close_provider.desc": "",
+        "hex.builtin.popup.close_provider.title": "",
         "hex.builtin.popup.error.create": "Falha ao criar um novo arquivo!",
-        "hex.builtin.popup.error.file_dialog.common": "***** MISSING TRANSLATION *****",
-        "hex.builtin.popup.error.file_dialog.portal": "***** MISSING TRANSLATION *****",
+        "hex.builtin.popup.error.file_dialog.common": "",
+        "hex.builtin.popup.error.file_dialog.portal": "",
         "hex.builtin.popup.error.open": "Falha ao abrir o arquivo!",
-        "hex.builtin.popup.error.project.load": "***** MISSING TRANSLATION *****",
-        "hex.builtin.popup.error.project.save": "***** MISSING TRANSLATION *****",
+        "hex.builtin.popup.error.project.load": "",
+        "hex.builtin.popup.error.project.save": "",
         "hex.builtin.popup.error.read_only": "Não foi possível obter acesso de gravação. Arquivo aberto no modo somente leitura.",
-        "hex.builtin.popup.error.task_exception": "***** MISSING TRANSLATION *****",
+        "hex.builtin.popup.error.task_exception": "",
         "hex.builtin.popup.exit_application.desc": "Você tem alterações não salvas feitas em seu projeto.\nVocê tem certeza que quer sair?",
         "hex.builtin.popup.exit_application.title": "Sair da aplicação?",
         "hex.builtin.provider.disk": "Provedor de disco bruto",
@@ -336,13 +348,13 @@
         "hex.builtin.provider.gdb.name": "GDB Server <{0}:{1}>",
         "hex.builtin.provider.gdb.port": "Porta",
         "hex.builtin.provider.gdb.server": "Servidor",
-        "hex.builtin.provider.intel_hex": "***** MISSING TRANSLATION *****",
-        "hex.builtin.provider.intel_hex.name": "***** MISSING TRANSLATION *****",
-        "hex.builtin.provider.mem_file": "***** MISSING TRANSLATION *****",
-        "hex.builtin.provider.mem_file.unsaved": "***** MISSING TRANSLATION *****",
-        "hex.builtin.provider.motorola_srec": "***** MISSING TRANSLATION *****",
-        "hex.builtin.provider.motorola_srec.name": "***** MISSING TRANSLATION *****",
-        "hex.builtin.provider.view": "***** MISSING TRANSLATION *****",
+        "hex.builtin.provider.intel_hex": "",
+        "hex.builtin.provider.intel_hex.name": "",
+        "hex.builtin.provider.mem_file": "",
+        "hex.builtin.provider.mem_file.unsaved": "",
+        "hex.builtin.provider.motorola_srec": "",
+        "hex.builtin.provider.motorola_srec.name": "",
+        "hex.builtin.provider.view": "",
         "hex.builtin.setting.folders": "Pastas",
         "hex.builtin.setting.folders.add_folder": "Adicionar nova pasta",
         "hex.builtin.setting.folders.description": "Especifique caminhos de pesquisa adicionais para padrões, scripts, regras Yara e muito mais",
@@ -352,20 +364,20 @@
         "hex.builtin.setting.font.font_size": "Tamanho da Fonte",
         "hex.builtin.setting.general": "General",
         "hex.builtin.setting.general.auto_load_patterns": "Padrão compatível com carregamento automático",
-        "hex.builtin.setting.general.check_for_updates": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.general.enable_unicode": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.general.check_for_updates": "",
+        "hex.builtin.setting.general.enable_unicode": "",
         "hex.builtin.setting.general.show_tips": "Mostrar dicas na inicialização",
-        "hex.builtin.setting.general.sync_pattern_source": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.general.sync_pattern_source": "",
         "hex.builtin.setting.hex_editor": "Hex Editor",
-        "hex.builtin.setting.hex_editor.advanced_decoding": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.hex_editor.advanced_decoding": "",
         "hex.builtin.setting.hex_editor.ascii": "Exibir coluna ASCII",
-        "hex.builtin.setting.hex_editor.byte_padding": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.hex_editor.byte_padding": "",
         "hex.builtin.setting.hex_editor.bytes_per_row": "Bytes por linha",
-        "hex.builtin.setting.hex_editor.char_padding": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.hex_editor.grey_zeros": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.hex_editor.highlight_color": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.hex_editor.sync_scrolling": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.hex_editor.uppercase_hex": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.hex_editor.char_padding": "",
+        "hex.builtin.setting.hex_editor.grey_zeros": "",
+        "hex.builtin.setting.hex_editor.highlight_color": "",
+        "hex.builtin.setting.hex_editor.sync_scrolling": "",
+        "hex.builtin.setting.hex_editor.uppercase_hex": "",
         "hex.builtin.setting.hex_editor.visualizer": "Visualizador de Dados",
         "hex.builtin.setting.imhex": "ImHex",
         "hex.builtin.setting.imhex.recent_files": "Arquivos Recentes",
@@ -374,7 +386,11 @@
         "hex.builtin.setting.interface.fps": "FPS Limit",
         "hex.builtin.setting.interface.fps.unlocked": "Destravado",
         "hex.builtin.setting.interface.language": "Idioma",
-        "hex.builtin.setting.interface.multi_windows": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.interface.multi_windows": "",
+        "hex.builtin.setting.interface.pattern_tree_style": "",
+        "hex.builtin.setting.interface.pattern_tree_style.auto_expanded": "",
+        "hex.builtin.setting.interface.pattern_tree_style.flattened": "",
+        "hex.builtin.setting.interface.pattern_tree_style.tree": "",
         "hex.builtin.setting.interface.scaling": "Scaling",
         "hex.builtin.setting.interface.scaling.native": "Nativo",
         "hex.builtin.setting.interface.scaling.x0_5": "x0.5",
@@ -384,11 +400,11 @@
         "hex.builtin.setting.interface.scaling.x3_0": "x3.0",
         "hex.builtin.setting.interface.scaling.x4_0": "x4.0",
         "hex.builtin.setting.interface.wiki_explain_language": "Idioma do Wikipedia",
-        "hex.builtin.setting.proxy": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.proxy.description": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.proxy.enable": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.proxy.url": "***** MISSING TRANSLATION *****",
-        "hex.builtin.setting.proxy.url.tooltip": "***** MISSING TRANSLATION *****",
+        "hex.builtin.setting.proxy": "",
+        "hex.builtin.setting.proxy.description": "",
+        "hex.builtin.setting.proxy.enable": "",
+        "hex.builtin.setting.proxy.url": "",
+        "hex.builtin.setting.proxy.url.tooltip": "",
         "hex.builtin.tools.ascii_table": "ASCII table",
         "hex.builtin.tools.ascii_table.octal": "Mostrar octal",
         "hex.builtin.tools.base_converter": "Base converter",
@@ -456,21 +472,25 @@
         "hex.builtin.tools.format.scientific": "Scientific",
         "hex.builtin.tools.format.standard": "Standard",
         "hex.builtin.tools.history": "History",
-        "hex.builtin.tools.ieee756": "IEEE 756 Floating Point Tester",
-        "hex.builtin.tools.ieee756.double_precision": "Double Precision",
-        "hex.builtin.tools.ieee756.exponent": "Exponent",
-        "hex.builtin.tools.ieee756.exponent_size": "Exponent Size",
-        "hex.builtin.tools.ieee756.formula": "Formula",
-        "hex.builtin.tools.ieee756.half_precision": "Half Precision",
-        "hex.builtin.tools.ieee756.mantissa": "Mantissa",
-        "hex.builtin.tools.ieee756.mantissa_size": "Mantissa Size",
-        "hex.builtin.tools.ieee756.result.float": "Resultado de ponto flutuante",
-        "hex.builtin.tools.ieee756.result.hex": "Resultado Hexadecimal",
-        "hex.builtin.tools.ieee756.result.title": "Resultado",
-        "hex.builtin.tools.ieee756.sign": "Sign",
-        "hex.builtin.tools.ieee756.singe_precision": "Single Precision",
-        "hex.builtin.tools.ieee756.type": "Tipo",
+        "hex.builtin.tools.ieee754": "IEEE 754 Floating Point Tester",
+        "hex.builtin.tools.ieee754.description": "",
+        "hex.builtin.tools.ieee754.double_precision": "Double Precision",
+        "hex.builtin.tools.ieee754.exponent": "Exponent",
+        "hex.builtin.tools.ieee754.exponent_size": "Exponent Size",
+        "hex.builtin.tools.ieee754.formula": "Formula",
+        "hex.builtin.tools.ieee754.half_precision": "Half Precision",
+        "hex.builtin.tools.ieee754.mantissa": "Mantissa",
+        "hex.builtin.tools.ieee754.mantissa_size": "Mantissa Size",
+        "hex.builtin.tools.ieee754.result.float": "Resultado de ponto flutuante",
+        "hex.builtin.tools.ieee754.result.hex": "Resultado Hexadecimal",
+        "hex.builtin.tools.ieee754.result.title": "Resultado",
+        "hex.builtin.tools.ieee754.sign": "Sign",
+        "hex.builtin.tools.ieee754.singe_precision": "Single Precision",
+        "hex.builtin.tools.ieee754.type": "Tipo",
         "hex.builtin.tools.input": "Input",
+        "hex.builtin.tools.invariant_multiplication": "",
+        "hex.builtin.tools.invariant_multiplication.description": "",
+        "hex.builtin.tools.invariant_multiplication.num_bits": "",
         "hex.builtin.tools.name": "Nome",
         "hex.builtin.tools.permissions": "Calculadora de Permissões UNIX",
         "hex.builtin.tools.permissions.absolute": "Absolute Notation",
@@ -575,34 +595,34 @@
         "hex.builtin.view.disassembler.settings.header": "Configurações",
         "hex.builtin.view.disassembler.settings.mode": "Modo",
         "hex.builtin.view.disassembler.sparc.v9": "Sparc V9",
-        "hex.builtin.view.find.binary_pattern": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.context.copy": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.context.copy_demangle": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.demangled": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.name": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.regex": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.regex.full_match": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.regex.pattern": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.search": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.search.entries": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.search.reset": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.searching": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.sequences": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.chars": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.line_feeds": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.lower_case": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.match_settings": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.min_length": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.null_term": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.numbers": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.spaces": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.symbols": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.underscores": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.strings.upper_case": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.value": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.value.max": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.find.value.min": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.find.binary_pattern": "",
+        "hex.builtin.view.find.context.copy": "",
+        "hex.builtin.view.find.context.copy_demangle": "",
+        "hex.builtin.view.find.demangled": "",
+        "hex.builtin.view.find.name": "",
+        "hex.builtin.view.find.regex": "",
+        "hex.builtin.view.find.regex.full_match": "",
+        "hex.builtin.view.find.regex.pattern": "",
+        "hex.builtin.view.find.search": "",
+        "hex.builtin.view.find.search.entries": "",
+        "hex.builtin.view.find.search.reset": "",
+        "hex.builtin.view.find.searching": "",
+        "hex.builtin.view.find.sequences": "",
+        "hex.builtin.view.find.strings": "",
+        "hex.builtin.view.find.strings.chars": "",
+        "hex.builtin.view.find.strings.line_feeds": "",
+        "hex.builtin.view.find.strings.lower_case": "",
+        "hex.builtin.view.find.strings.match_settings": "",
+        "hex.builtin.view.find.strings.min_length": "",
+        "hex.builtin.view.find.strings.null_term": "",
+        "hex.builtin.view.find.strings.numbers": "",
+        "hex.builtin.view.find.strings.spaces": "",
+        "hex.builtin.view.find.strings.symbols": "",
+        "hex.builtin.view.find.strings.underscores": "",
+        "hex.builtin.view.find.strings.upper_case": "",
+        "hex.builtin.view.find.value": "",
+        "hex.builtin.view.find.value.max": "",
+        "hex.builtin.view.find.value.min": "",
         "hex.builtin.view.hashes.function": "Função Hash",
         "hex.builtin.view.hashes.hash": "Hash",
         "hex.builtin.view.hashes.hover_info": "Passe o mouse sobre a seleção Hex Editor e mantenha pressionada a tecla SHIFT para visualizar os hashes dessa região.",
@@ -625,15 +645,13 @@
         "hex.builtin.view.help.documentation": "Documentação do ImHex",
         "hex.builtin.view.help.name": "Ajuda",
         "hex.builtin.view.help.pattern_cheat_sheet": "Pattern Language Cheat Sheet",
-        "hex.builtin.view.hex_editor.copy.address": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.copy.ascii": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hex_editor.copy.address": "",
         "hex.builtin.view.hex_editor.copy.base64": "Base64",
         "hex.builtin.view.hex_editor.copy.c": "C Array",
         "hex.builtin.view.hex_editor.copy.cpp": "C++ Array",
         "hex.builtin.view.hex_editor.copy.crystal": "Crystal Array",
         "hex.builtin.view.hex_editor.copy.csharp": "C# Array",
         "hex.builtin.view.hex_editor.copy.go": "Go Array",
-        "hex.builtin.view.hex_editor.copy.hex": "String",
         "hex.builtin.view.hex_editor.copy.html": "HTML",
         "hex.builtin.view.hex_editor.copy.java": "Java Array",
         "hex.builtin.view.hex_editor.copy.js": "JavaScript Array",
@@ -649,11 +667,11 @@
         "hex.builtin.view.hex_editor.menu.edit.copy": "Copiar",
         "hex.builtin.view.hex_editor.menu.edit.copy_as": "Copiar como...",
         "hex.builtin.view.hex_editor.menu.edit.insert": "Inserir...",
-        "hex.builtin.view.hex_editor.menu.edit.jump_to": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.menu.edit.open_in_new_provider": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hex_editor.menu.edit.jump_to": "",
+        "hex.builtin.view.hex_editor.menu.edit.open_in_new_provider": "",
         "hex.builtin.view.hex_editor.menu.edit.paste": "Colar",
-        "hex.builtin.view.hex_editor.menu.edit.paste_all": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.menu.edit.remove": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hex_editor.menu.edit.paste_all": "",
+        "hex.builtin.view.hex_editor.menu.edit.remove": "",
         "hex.builtin.view.hex_editor.menu.edit.resize": "Redimensionar...",
         "hex.builtin.view.hex_editor.menu.edit.select_all": "Selecionar tudo",
         "hex.builtin.view.hex_editor.menu.edit.set_base": "Definir endereço base",
@@ -662,32 +680,37 @@
         "hex.builtin.view.hex_editor.menu.file.save": "Salvar",
         "hex.builtin.view.hex_editor.menu.file.save_as": "Salvar como...",
         "hex.builtin.view.hex_editor.menu.file.search": "Procurar",
-        "hex.builtin.view.hex_editor.menu.file.select": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hex_editor.menu.file.select": "",
         "hex.builtin.view.hex_editor.name": "Editor Hex",
         "hex.builtin.view.hex_editor.search.find": "Buscar",
         "hex.builtin.view.hex_editor.search.hex": "Hex",
         "hex.builtin.view.hex_editor.search.string": "String",
-        "hex.builtin.view.hex_editor.select.offset.begin": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.select.offset.end": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.select.offset.region": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.select.offset.size": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.hex_editor.select.select": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.hex_editor.select.offset.begin": "",
+        "hex.builtin.view.hex_editor.select.offset.end": "",
+        "hex.builtin.view.hex_editor.select.offset.region": "",
+        "hex.builtin.view.hex_editor.select.offset.size": "",
+        "hex.builtin.view.hex_editor.select.select": "",
         "hex.builtin.view.information.analyze": "Analisar Pagina",
         "hex.builtin.view.information.analyzing": "Analizando...",
         "hex.builtin.view.information.block_size": "Block size",
         "hex.builtin.view.information.block_size.desc": "{0} blocks of {1} bytes",
+        "hex.builtin.view.information.byte_types": "",
         "hex.builtin.view.information.control": "Controle",
         "hex.builtin.view.information.description": "Descrição:",
+        "hex.builtin.view.information.digram": "",
         "hex.builtin.view.information.distribution": "Byte distribution",
         "hex.builtin.view.information.encrypted": "Esses dados provavelmente estão criptografados ou compactados!",
         "hex.builtin.view.information.entropy": "Entropy",
         "hex.builtin.view.information.file_entropy": "File entropy",
         "hex.builtin.view.information.highest_entropy": "Highest entropy block",
         "hex.builtin.view.information.info_analysis": "Análise de Informações",
+        "hex.builtin.view.information.layered_distribution": "",
         "hex.builtin.view.information.magic": "Informação Mágica",
         "hex.builtin.view.information.magic_db_added": "Magic database added!",
         "hex.builtin.view.information.mime": "MIME Type:",
         "hex.builtin.view.information.name": "Data Information",
+        "hex.builtin.view.information.plain_text": "",
+        "hex.builtin.view.information.plain_text_percentage": "",
         "hex.builtin.view.information.region": "Região analizada",
         "hex.builtin.view.patches.name": "Patches",
         "hex.builtin.view.patches.offset": "Desvio",
@@ -705,20 +728,20 @@
         "hex.builtin.view.pattern_editor.dangerous_function.name": "Permitir função perigosa?",
         "hex.builtin.view.pattern_editor.env_vars": "Variáveis de Ambiente",
         "hex.builtin.view.pattern_editor.evaluating": "Avaliando...",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin.array": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin.single": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.custom": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern": "",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin": "",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin.array": "",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.builtin.single": "",
+        "hex.builtin.view.pattern_editor.menu.edit.place_pattern.custom": "",
         "hex.builtin.view.pattern_editor.menu.file.load_pattern": "Carregando padrão...",
         "hex.builtin.view.pattern_editor.menu.file.save_pattern": "Salvando padrão...",
         "hex.builtin.view.pattern_editor.name": "Editor de padrões",
         "hex.builtin.view.pattern_editor.no_in_out_vars": "Defina algumas variáveis globais com o especificador 'in' ou 'out' para que elas apareçam aqui.",
         "hex.builtin.view.pattern_editor.open_pattern": "Abrir padrão",
-        "hex.builtin.view.pattern_editor.section_popup": "***** MISSING TRANSLATION *****",
-        "hex.builtin.view.pattern_editor.sections": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.pattern_editor.section_popup": "",
+        "hex.builtin.view.pattern_editor.sections": "",
         "hex.builtin.view.pattern_editor.settings": "Configurações",
-        "hex.builtin.view.provider_settings.load_error": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.provider_settings.load_error": "",
         "hex.builtin.view.provider_settings.load_popup": "Abrir Provedor",
         "hex.builtin.view.provider_settings.name": "Configurações do provedor",
         "hex.builtin.view.settings.name": "Configurações",
@@ -728,7 +751,7 @@
         "hex.builtin.view.store.download_error": "Falha ao baixar o arquivo! A pasta de destino não existe.",
         "hex.builtin.view.store.loading": "Carregando conteúdo da loja...",
         "hex.builtin.view.store.name": "Loja de Conteúdo",
-        "hex.builtin.view.store.netfailed": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.store.netfailed": "",
         "hex.builtin.view.store.reload": "Recarregar",
         "hex.builtin.view.store.remove": "Remover",
         "hex.builtin.view.store.row.description": "Descrição",
@@ -751,7 +774,7 @@
         "hex.builtin.view.yara.name": "Regras Yara",
         "hex.builtin.view.yara.no_rules": "Nenhuma regra YARA encontrada. Coloque-os na pasta 'yara' do ImHex",
         "hex.builtin.view.yara.reload": "Recarregar",
-        "hex.builtin.view.yara.reset": "***** MISSING TRANSLATION *****",
+        "hex.builtin.view.yara.reset": "",
         "hex.builtin.view.yara.rule_added": "Regra Yara Adicionada!",
         "hex.builtin.view.yara.whole_data": "O arquivo inteiro corresponde!",
         "hex.builtin.visualizer.decimal.signed.16bit": "Decimal Signed (16 bits)",
@@ -771,7 +794,7 @@
         "hex.builtin.visualizer.hexadecimal.8bit": "Hexadecimal (8 bits)",
         "hex.builtin.visualizer.hexii": "HexII",
         "hex.builtin.visualizer.rgba8": "RGBA8 Color",
-        "hex.builtin.welcome.check_for_updates_text": "***** MISSING TRANSLATION *****",
+        "hex.builtin.welcome.check_for_updates_text": "",
         "hex.builtin.welcome.customize.settings.desc": "Mudar preferencias do ImHex",
         "hex.builtin.welcome.customize.settings.title": "Configurações",
         "hex.builtin.welcome.header.customize": "Customizar",

plugins/builtin/romfs/lang/zh_CN.json

@@ -12,6 +12,7 @@
         "hex.builtin.common.big": "大",
         "hex.builtin.common.big_endian": "大端序",
         "hex.builtin.common.browse": "浏览...",
+        "hex.builtin.common.bytes": "",
         "hex.builtin.common.cancel": "取消",
         "hex.builtin.common.choose_file": "选择文件",
         "hex.builtin.common.close": "关闭",
@@ -30,6 +31,7 @@
         "hex.builtin.common.filter": "过滤器",
         "hex.builtin.common.hexadecimal": "十六进制",
         "hex.builtin.common.info": "信息",
+        "hex.builtin.common.instruction": "",
         "hex.builtin.common.link": "链接",
         "hex.builtin.common.little": "小",
         "hex.builtin.common.little_endian": "小端序",
@@ -42,6 +44,7 @@
         "hex.builtin.common.offset": "偏移",
         "hex.builtin.common.okay": "好的",
         "hex.builtin.common.open": "打开",
+        "hex.builtin.common.percentage": "",
         "hex.builtin.common.processing": "处理",
         "hex.builtin.common.question": "问题",
         "hex.builtin.common.range": "范围",
@@ -132,8 +135,15 @@
         "hex.builtin.menu.file.close": "关闭",
         "hex.builtin.menu.file.create_file": "新建文件...",
         "hex.builtin.menu.file.export": "导出...",
-        "hex.builtin.menu.file.export.base64.popup.export_error": "文件不是有效的 Base64 格式！",
+        "hex.builtin.menu.file.export.base64": "",
+        "hex.builtin.menu.file.export.base64.popup.export_error": "",
         "hex.builtin.menu.file.export.ips": "IPS 补丁",
+        "hex.builtin.menu.file.export.ips.popup.address_out_of_range_error": "",
+        "hex.builtin.menu.file.export.ips.popup.export_error": "",
+        "hex.builtin.menu.file.export.ips.popup.invalid_patch_format_error": "",
+        "hex.builtin.menu.file.export.ips.popup.invalid_patch_header_error": "",
+        "hex.builtin.menu.file.export.ips.popup.missing_eof_error": "",
+        "hex.builtin.menu.file.export.ips.popup.patch_too_large_error": "",
         "hex.builtin.menu.file.export.ips32": "IPS32 补丁",
         "hex.builtin.menu.file.export.popup.create": "无法导出文件。文件创建失败！",
         "hex.builtin.menu.file.export.title": "导出文件",
@@ -308,6 +318,8 @@
         "hex.builtin.pattern_drawer.type": "类型",
         "hex.builtin.pattern_drawer.value": "值",
         "hex.builtin.pattern_drawer.var_name": "名称",
+        "hex.builtin.pattern_drawer.visualizer.invalid_parameter_count": "",
+        "hex.builtin.pattern_drawer.visualizer.unknown": "",
         "hex.builtin.popup.close_provider.desc": "有对此提供器做出的未保存的更改。\n你确定要关闭吗？",
         "hex.builtin.popup.close_provider.title": "关闭提供器？",
         "hex.builtin.popup.error.create": "创建新文件失败！",
@@ -370,10 +382,15 @@
         "hex.builtin.setting.imhex": "ImHex",
         "hex.builtin.setting.imhex.recent_files": "最近文件",
         "hex.builtin.setting.interface": "界面",
+        "hex.builtin.setting.interface.color": "",
         "hex.builtin.setting.interface.fps": "FPS 限制",
         "hex.builtin.setting.interface.fps.unlocked": "无限制",
         "hex.builtin.setting.interface.language": "语言",
         "hex.builtin.setting.interface.multi_windows": "启用多窗口支持",
+        "hex.builtin.setting.interface.pattern_tree_style": "",
+        "hex.builtin.setting.interface.pattern_tree_style.auto_expanded": "",
+        "hex.builtin.setting.interface.pattern_tree_style.flattened": "",
+        "hex.builtin.setting.interface.pattern_tree_style.tree": "",
         "hex.builtin.setting.interface.scaling": "缩放",
         "hex.builtin.setting.interface.scaling.native": "本地默认",
         "hex.builtin.setting.interface.scaling.x0_5": "x0.5",
@@ -455,21 +472,25 @@
         "hex.builtin.tools.format.scientific": "科学",
         "hex.builtin.tools.format.standard": "标准",
         "hex.builtin.tools.history": "历史",
-        "hex.builtin.tools.ieee756": "IEEE 756 浮点数测试器",
-        "hex.builtin.tools.ieee756.double_precision": "双精度浮点数",
-        "hex.builtin.tools.ieee756.exponent": "指数",
-        "hex.builtin.tools.ieee756.exponent_size": "指数位数",
-        "hex.builtin.tools.ieee756.formula": "计算式",
-        "hex.builtin.tools.ieee756.half_precision": "半精度浮点数",
-        "hex.builtin.tools.ieee756.mantissa": "尾数",
-        "hex.builtin.tools.ieee756.mantissa_size": "尾数位数",
-        "hex.builtin.tools.ieee756.result.float": "十进制小数表示",
-        "hex.builtin.tools.ieee756.result.hex": "十六进制小数表示",
-        "hex.builtin.tools.ieee756.result.title": "结果",
-        "hex.builtin.tools.ieee756.sign": "符号",
-        "hex.builtin.tools.ieee756.singe_precision": "单精度浮点数",
-        "hex.builtin.tools.ieee756.type": "部分",
+        "hex.builtin.tools.ieee754": "IEEE 754 浮点数测试器",
+        "hex.builtin.tools.ieee754.description": "",
+        "hex.builtin.tools.ieee754.double_precision": "双精度浮点数",
+        "hex.builtin.tools.ieee754.exponent": "指数",
+        "hex.builtin.tools.ieee754.exponent_size": "指数位数",
+        "hex.builtin.tools.ieee754.formula": "计算式",
+        "hex.builtin.tools.ieee754.half_precision": "半精度浮点数",
+        "hex.builtin.tools.ieee754.mantissa": "尾数",
+        "hex.builtin.tools.ieee754.mantissa_size": "尾数位数",
+        "hex.builtin.tools.ieee754.result.float": "十进制小数表示",
+        "hex.builtin.tools.ieee754.result.hex": "十六进制小数表示",
+        "hex.builtin.tools.ieee754.result.title": "结果",
+        "hex.builtin.tools.ieee754.sign": "符号",
+        "hex.builtin.tools.ieee754.singe_precision": "单精度浮点数",
+        "hex.builtin.tools.ieee754.type": "部分",
         "hex.builtin.tools.input": "输入",
+        "hex.builtin.tools.invariant_multiplication": "",
+        "hex.builtin.tools.invariant_multiplication.description": "",
+        "hex.builtin.tools.invariant_multiplication.num_bits": "",
         "hex.builtin.tools.name": "名称",
         "hex.builtin.tools.permissions": "UNIX 权限计算器",
         "hex.builtin.tools.permissions.absolute": "绝对符号",
@@ -675,18 +696,23 @@
         "hex.builtin.view.information.analyzing": "分析中...",
         "hex.builtin.view.information.block_size": "块大小",
         "hex.builtin.view.information.block_size.desc": "{0} 块 × {1} 字节",
+        "hex.builtin.view.information.byte_types": "",
         "hex.builtin.view.information.control": "控制",
         "hex.builtin.view.information.description": "描述:",
+        "hex.builtin.view.information.digram": "",
         "hex.builtin.view.information.distribution": "字节分布",
         "hex.builtin.view.information.encrypted": "此数据似乎经过了加密或压缩！",
         "hex.builtin.view.information.entropy": "熵",
         "hex.builtin.view.information.file_entropy": "文件熵",
         "hex.builtin.view.information.highest_entropy": "最高熵",
         "hex.builtin.view.information.info_analysis": "信息分析",
+        "hex.builtin.view.information.layered_distribution": "",
         "hex.builtin.view.information.magic": "LibMagic 信息",
         "hex.builtin.view.information.magic_db_added": "LibMagic 数据库已添加！",
         "hex.builtin.view.information.mime": "MIME 类型:",
         "hex.builtin.view.information.name": "数据信息",
+        "hex.builtin.view.information.plain_text": "",
+        "hex.builtin.view.information.plain_text_percentage": "",
         "hex.builtin.view.information.region": "已分析区域",
         "hex.builtin.view.patches.name": "补丁",
         "hex.builtin.view.patches.offset": "偏移",

plugins/builtin/romfs/lang/zh_TW.json

@@ -12,6 +12,7 @@
         "hex.builtin.common.big": "大",
         "hex.builtin.common.big_endian": "大端序",
         "hex.builtin.common.browse": "瀏覽...",
+        "hex.builtin.common.bytes": "",
         "hex.builtin.common.cancel": "取消",
         "hex.builtin.common.choose_file": "選擇檔案",
         "hex.builtin.common.close": "關閉",
@@ -20,9 +21,9 @@
         "hex.builtin.common.decimal": "十進位",
         "hex.builtin.common.dont_show_again": "不再顯示",
         "hex.builtin.common.encoding.ascii": "ASCII",
-        "hex.builtin.common.encoding.utf8": "UTF-8",
         "hex.builtin.common.encoding.utf16be": "UTF-16BE",
         "hex.builtin.common.encoding.utf16le": "UTF-16LE",
+        "hex.builtin.common.encoding.utf8": "UTF-8",
         "hex.builtin.common.endian": "端序",
         "hex.builtin.common.error": "錯誤",
         "hex.builtin.common.fatal": "嚴重錯誤",
@@ -30,6 +31,7 @@
         "hex.builtin.common.filter": "篩選",
         "hex.builtin.common.hexadecimal": "十六進位",
         "hex.builtin.common.info": "資訊",
+        "hex.builtin.common.instruction": "",
         "hex.builtin.common.link": "連結",
         "hex.builtin.common.little": "小",
         "hex.builtin.common.little_endian": "小端序",
@@ -42,6 +44,7 @@
         "hex.builtin.common.offset": "位移",
         "hex.builtin.common.okay": "好",
         "hex.builtin.common.open": "開啟",
+        "hex.builtin.common.percentage": "",
         "hex.builtin.common.processing": "正在處理",
         "hex.builtin.common.question": "問題",
         "hex.builtin.common.range": "範圍",
@@ -53,18 +56,18 @@
         "hex.builtin.common.type": "類型",
         "hex.builtin.common.type.f32": "float",
         "hex.builtin.common.type.f64": "double",
-        "hex.builtin.common.type.i8": "int8_t",
         "hex.builtin.common.type.i16": "int16_t",
         "hex.builtin.common.type.i24": "int24_t",
         "hex.builtin.common.type.i32": "int32_t",
         "hex.builtin.common.type.i48": "int48_t",
         "hex.builtin.common.type.i64": "int64_t",
-        "hex.builtin.common.type.u8": "uint8_t",
+        "hex.builtin.common.type.i8": "int8_t",
         "hex.builtin.common.type.u16": "uint16_t",
         "hex.builtin.common.type.u24": "uint24_t",
         "hex.builtin.common.type.u32": "uint32_t",
         "hex.builtin.common.type.u48": "uint48_t",
         "hex.builtin.common.type.u64": "uint64_t",
+        "hex.builtin.common.type.u8": "uint8_t",
         "hex.builtin.common.value": "數值",
         "hex.builtin.common.yes": "是",
         "hex.builtin.hash.crc.iv": "初始數值",
@@ -72,9 +75,9 @@
         "hex.builtin.hash.crc.refl_in": "Reflect In",
         "hex.builtin.hash.crc.refl_out": "Reflect Out",
         "hex.builtin.hash.crc.xor_out": "XOR Out",
-        "hex.builtin.hash.crc8": "CRC8",
         "hex.builtin.hash.crc16": "CRC16",
         "hex.builtin.hash.crc32": "CRC32",
+        "hex.builtin.hash.crc8": "CRC8",
         "hex.builtin.hash.md5": "MD5",
         "hex.builtin.hash.sha1": "SHA1",
         "hex.builtin.hash.sha224": "SHA224",
@@ -96,12 +99,12 @@
         "hex.builtin.inspector.float": "float (32 位元)",
         "hex.builtin.inspector.float16": "half float (16 位元)",
         "hex.builtin.inspector.guid": "GUID",
-        "hex.builtin.inspector.i8": "int8_t",
         "hex.builtin.inspector.i16": "int16_t",
         "hex.builtin.inspector.i24": "int24_t",
         "hex.builtin.inspector.i32": "int32_t",
         "hex.builtin.inspector.i48": "int48_t",
         "hex.builtin.inspector.i64": "int64_t",
+        "hex.builtin.inspector.i8": "int8_t",
         "hex.builtin.inspector.long_double": "long double (128 位元)",
         "hex.builtin.inspector.rgb565": "RGB565 顏色",
         "hex.builtin.inspector.rgba8": "RGBA8 顏色",
@@ -111,12 +114,12 @@
         "hex.builtin.inspector.time": "time_t",
         "hex.builtin.inspector.time32": "time32_t",
         "hex.builtin.inspector.time64": "time64_t",
-        "hex.builtin.inspector.u8": "uint8_t",
         "hex.builtin.inspector.u16": "uint16_t",
         "hex.builtin.inspector.u24": "uint24_t",
         "hex.builtin.inspector.u32": "uint32_t",
         "hex.builtin.inspector.u48": "uint48_t",
         "hex.builtin.inspector.u64": "uint64_t",
+        "hex.builtin.inspector.u8": "uint8_t",
         "hex.builtin.inspector.uleb128": "無號數 LEB128",
         "hex.builtin.inspector.utf8": "UTF-8 code point",
         "hex.builtin.inspector.wide": "框字元",
@@ -132,8 +135,15 @@
         "hex.builtin.menu.file.close": "關閉",
         "hex.builtin.menu.file.create_file": "新檔案...",
         "hex.builtin.menu.file.export": "匯出...",
-        "hex.builtin.menu.file.export.base64.popup.export_error": "檔案並非有效的 Base64 格式！",
+        "hex.builtin.menu.file.export.base64": "",
+        "hex.builtin.menu.file.export.base64.popup.export_error": "",
         "hex.builtin.menu.file.export.ips": "IPS 修補檔案",
+        "hex.builtin.menu.file.export.ips.popup.address_out_of_range_error": "",
+        "hex.builtin.menu.file.export.ips.popup.export_error": "",
+        "hex.builtin.menu.file.export.ips.popup.invalid_patch_format_error": "",
+        "hex.builtin.menu.file.export.ips.popup.invalid_patch_header_error": "",
+        "hex.builtin.menu.file.export.ips.popup.missing_eof_error": "",
+        "hex.builtin.menu.file.export.ips.popup.patch_too_large_error": "",
         "hex.builtin.menu.file.export.ips32": "IPS32 修補檔案",
         "hex.builtin.menu.file.export.popup.create": "無法匯出資料。無法建立檔案！",
         "hex.builtin.menu.file.export.title": "匯出檔案",
@@ -296,9 +306,9 @@
         "hex.builtin.nodes.visualizer.digram": "流程圖",
         "hex.builtin.nodes.visualizer.digram.header": "流程圖",
         "hex.builtin.nodes.visualizer.image": "圖片",
+        "hex.builtin.nodes.visualizer.image.header": "圖片視覺化工具",
         "hex.builtin.nodes.visualizer.image_rgba": "RGBA8 圖片",
         "hex.builtin.nodes.visualizer.image_rgba.header": "RGBA8 圖片視覺化工具",
-        "hex.builtin.nodes.visualizer.image.header": "圖片視覺化工具",
         "hex.builtin.nodes.visualizer.layered_dist": "Layered Distribution",
         "hex.builtin.nodes.visualizer.layered_dist.header": "Layered Distribution",
         "hex.builtin.pattern_drawer.color": "顏色",
@@ -308,6 +318,8 @@
         "hex.builtin.pattern_drawer.type": "類型",
         "hex.builtin.pattern_drawer.value": "數值",
         "hex.builtin.pattern_drawer.var_name": "名稱",
+        "hex.builtin.pattern_drawer.visualizer.invalid_parameter_count": "",
+        "hex.builtin.pattern_drawer.visualizer.unknown": "",
         "hex.builtin.popup.close_provider.desc": "您對此提供者有未儲存的更動。\n您確定要關閉嗎？",
         "hex.builtin.popup.close_provider.title": "關閉提供者？",
         "hex.builtin.popup.error.create": "無法建立新檔案！",
@@ -375,6 +387,10 @@
         "hex.builtin.setting.interface.fps.unlocked": "解鎖",
         "hex.builtin.setting.interface.language": "語言",
         "hex.builtin.setting.interface.multi_windows": "啟用多視窗支援",
+        "hex.builtin.setting.interface.pattern_tree_style": "",
+        "hex.builtin.setting.interface.pattern_tree_style.auto_expanded": "",
+        "hex.builtin.setting.interface.pattern_tree_style.flattened": "",
+        "hex.builtin.setting.interface.pattern_tree_style.tree": "",
         "hex.builtin.setting.interface.scaling": "縮放",
         "hex.builtin.setting.interface.scaling.native": "原生",
         "hex.builtin.setting.interface.scaling.x0_5": "x0.5",
@@ -456,21 +472,25 @@
         "hex.builtin.tools.format.scientific": "科學",
         "hex.builtin.tools.format.standard": "標準",
         "hex.builtin.tools.history": "歷史",
-        "hex.builtin.tools.ieee756": "IEEE 756 浮點數測試工具",
-        "hex.builtin.tools.ieee756.double_precision": "雙精度",
-        "hex.builtin.tools.ieee756.exponent": "指數",
-        "hex.builtin.tools.ieee756.exponent_size": "指數大小",
-        "hex.builtin.tools.ieee756.formula": "Formula",
-        "hex.builtin.tools.ieee756.half_precision": "半精度",
-        "hex.builtin.tools.ieee756.mantissa": "尾數",
-        "hex.builtin.tools.ieee756.mantissa_size": "尾數大小",
-        "hex.builtin.tools.ieee756.result.float": "浮點數結果",
-        "hex.builtin.tools.ieee756.result.hex": "十六進位結果",
-        "hex.builtin.tools.ieee756.result.title": "結果",
-        "hex.builtin.tools.ieee756.sign": "符號",
-        "hex.builtin.tools.ieee756.singe_precision": "單精度",
-        "hex.builtin.tools.ieee756.type": "類型",
+        "hex.builtin.tools.ieee754": "IEEE 754 浮點數測試工具",
+        "hex.builtin.tools.ieee754.description": "",
+        "hex.builtin.tools.ieee754.double_precision": "雙精度",
+        "hex.builtin.tools.ieee754.exponent": "指數",
+        "hex.builtin.tools.ieee754.exponent_size": "指數大小",
+        "hex.builtin.tools.ieee754.formula": "Formula",
+        "hex.builtin.tools.ieee754.half_precision": "半精度",
+        "hex.builtin.tools.ieee754.mantissa": "尾數",
+        "hex.builtin.tools.ieee754.mantissa_size": "尾數大小",
+        "hex.builtin.tools.ieee754.result.float": "浮點數結果",
+        "hex.builtin.tools.ieee754.result.hex": "十六進位結果",
+        "hex.builtin.tools.ieee754.result.title": "結果",
+        "hex.builtin.tools.ieee754.sign": "符號",
+        "hex.builtin.tools.ieee754.singe_precision": "單精度",
+        "hex.builtin.tools.ieee754.type": "類型",
         "hex.builtin.tools.input": "輸入",
+        "hex.builtin.tools.invariant_multiplication": "",
+        "hex.builtin.tools.invariant_multiplication.description": "",
+        "hex.builtin.tools.invariant_multiplication.num_bits": "",
         "hex.builtin.tools.name": "名稱",
         "hex.builtin.tools.permissions": "UNIX 權限計算機",
         "hex.builtin.tools.permissions.absolute": "Absolute Notation",
@@ -536,12 +556,6 @@
         "hex.builtin.view.disassembler.disassembly.bytes": "位元",
         "hex.builtin.view.disassembler.disassembly.offset": "位移",
         "hex.builtin.view.disassembler.disassembly.title": "反組譯",
-        "hex.builtin.view.disassembler.m68k.000": "000",
-        "hex.builtin.view.disassembler.m68k.010": "010",
-        "hex.builtin.view.disassembler.m68k.020": "020",
-        "hex.builtin.view.disassembler.m68k.030": "030",
-        "hex.builtin.view.disassembler.m68k.040": "040",
-        "hex.builtin.view.disassembler.m68k.060": "060",
         "hex.builtin.view.disassembler.m680x.6301": "6301",
         "hex.builtin.view.disassembler.m680x.6309": "6309",
         "hex.builtin.view.disassembler.m680x.6800": "6800",
@@ -552,18 +566,24 @@
         "hex.builtin.view.disassembler.m680x.6811": "6811",
         "hex.builtin.view.disassembler.m680x.cpu12": "CPU12",
         "hex.builtin.view.disassembler.m680x.hcs08": "HCS08",
+        "hex.builtin.view.disassembler.m68k.000": "000",
+        "hex.builtin.view.disassembler.m68k.010": "010",
+        "hex.builtin.view.disassembler.m68k.020": "020",
+        "hex.builtin.view.disassembler.m68k.030": "030",
+        "hex.builtin.view.disassembler.m68k.040": "040",
+        "hex.builtin.view.disassembler.m68k.060": "060",
         "hex.builtin.view.disassembler.mips.micro": "Micro",
         "hex.builtin.view.disassembler.mips.mips2": "MIPS II",
         "hex.builtin.view.disassembler.mips.mips3": "MIPS III",
         "hex.builtin.view.disassembler.mips.mips32": "MIPS32",
         "hex.builtin.view.disassembler.mips.mips32R6": "MIPS32R6",
         "hex.builtin.view.disassembler.mips.mips64": "MIPS64",
-        "hex.builtin.view.disassembler.mos65xx.65c02": "65C02",
         "hex.builtin.view.disassembler.mos65xx.6502": "6502",
         "hex.builtin.view.disassembler.mos65xx.65816": "65816",
         "hex.builtin.view.disassembler.mos65xx.65816_long_m": "65816 Long M",
         "hex.builtin.view.disassembler.mos65xx.65816_long_mx": "65816 Long MX",
         "hex.builtin.view.disassembler.mos65xx.65816_long_x": "65816 Long X",
+        "hex.builtin.view.disassembler.mos65xx.65c02": "65C02",
         "hex.builtin.view.disassembler.mos65xx.w65c02": "W65C02",
         "hex.builtin.view.disassembler.name": "反組譯器",
         "hex.builtin.view.disassembler.position": "位置",
@@ -626,14 +646,12 @@
         "hex.builtin.view.help.name": "幫助",
         "hex.builtin.view.help.pattern_cheat_sheet": "模式語言小抄",
         "hex.builtin.view.hex_editor.copy.address": "地址",
-        "hex.builtin.view.hex_editor.copy.ascii": "文字區域",
         "hex.builtin.view.hex_editor.copy.base64": "Base64",
         "hex.builtin.view.hex_editor.copy.c": "C 陣列",
         "hex.builtin.view.hex_editor.copy.cpp": "C++ 陣列",
         "hex.builtin.view.hex_editor.copy.crystal": "Crystal 陣列",
         "hex.builtin.view.hex_editor.copy.csharp": "C# 陣列",
         "hex.builtin.view.hex_editor.copy.go": "Go 陣列",
-        "hex.builtin.view.hex_editor.copy.hex": "字串",
         "hex.builtin.view.hex_editor.copy.html": "HTML",
         "hex.builtin.view.hex_editor.copy.java": "Java 陣列",
         "hex.builtin.view.hex_editor.copy.js": "JavaScript 陣列",
@@ -676,18 +694,23 @@
         "hex.builtin.view.information.analyzing": "正在分析...",
         "hex.builtin.view.information.block_size": "區塊大小",
         "hex.builtin.view.information.block_size.desc": "{0} blocks of {1} bytes",
+        "hex.builtin.view.information.byte_types": "",
         "hex.builtin.view.information.control": "控制",
         "hex.builtin.view.information.description": "說明：",
+        "hex.builtin.view.information.digram": "",
         "hex.builtin.view.information.distribution": "位元組分佈",
         "hex.builtin.view.information.encrypted": "此資料很有可能經過加密或壓縮！",
         "hex.builtin.view.information.entropy": "熵",
         "hex.builtin.view.information.file_entropy": "檔案熵",
         "hex.builtin.view.information.highest_entropy": "Highest entropy block",
         "hex.builtin.view.information.info_analysis": "資訊分析",
+        "hex.builtin.view.information.layered_distribution": "",
         "hex.builtin.view.information.magic": "Magic information",
         "hex.builtin.view.information.magic_db_added": "Magic database added!",
         "hex.builtin.view.information.mime": "MIME 類型：",
         "hex.builtin.view.information.name": "資料資訊",
+        "hex.builtin.view.information.plain_text": "",
+        "hex.builtin.view.information.plain_text_percentage": "",
         "hex.builtin.view.information.region": "Analyzed region",
         "hex.builtin.view.patches.name": "Patches",
         "hex.builtin.view.patches.offset": "位移",
@@ -754,21 +777,21 @@
         "hex.builtin.view.yara.reset": "Reset",
         "hex.builtin.view.yara.rule_added": " Yara 規則已新增！",
         "hex.builtin.view.yara.whole_data": "Whole file matches!",
-        "hex.builtin.visualizer.decimal.signed.8bit": "十進位有號數 (8 位元)",
         "hex.builtin.visualizer.decimal.signed.16bit": "十進位有號數 (16 位元)",
         "hex.builtin.visualizer.decimal.signed.32bit": "十進位有號數 (32 位元)",
         "hex.builtin.visualizer.decimal.signed.64bit": "十進位有號數 (64 位元)",
-        "hex.builtin.visualizer.decimal.unsigned.8bit": "十進位無號數 (8 位元)",
+        "hex.builtin.visualizer.decimal.signed.8bit": "十進位有號數 (8 位元)",
         "hex.builtin.visualizer.decimal.unsigned.16bit": "十進位無號數 (16 位元)",
         "hex.builtin.visualizer.decimal.unsigned.32bit": "十進位無號數 (32 位元)",
         "hex.builtin.visualizer.decimal.unsigned.64bit": "十進位無號數 (64 位元)",
+        "hex.builtin.visualizer.decimal.unsigned.8bit": "十進位無號數 (8 位元)",
         "hex.builtin.visualizer.floating_point.16bit": "浮點數 (16 位元)",
         "hex.builtin.visualizer.floating_point.32bit": "浮點數 (32 位元)",
         "hex.builtin.visualizer.floating_point.64bit": "浮點數 (64 位元)",
-        "hex.builtin.visualizer.hexadecimal.8bit": "十六進位 (8 位元)",
         "hex.builtin.visualizer.hexadecimal.16bit": "十六進位 (16 位元)",
         "hex.builtin.visualizer.hexadecimal.32bit": "十六進位 (32 位元)",
         "hex.builtin.visualizer.hexadecimal.64bit": "十六進位 (64 位元)",
+        "hex.builtin.visualizer.hexadecimal.8bit": "十六進位 (8 位元)",
         "hex.builtin.visualizer.hexii": "HexII",
         "hex.builtin.visualizer.rgba8": "RGBA8 顏色",
         "hex.builtin.welcome.check_for_updates_text": "您要在啟動時自動檢查更新嗎？\n 可用更新將在歡迎畫面的｢更新｣分頁顯示。",
@@ -814,4 +837,4 @@
         "hex.builtin.welcome.update.link": "https://github.com/WerWolv/ImHex/releases/latest",
         "hex.builtin.welcome.update.title": "有可用更新！"
     }
-}
+}