Merge pull request #2277 from fastfetch-cli/dev

Release v2.62.0
Terminal (Windows): removes using of Win32 registry APIs
2026-09-12 18:32:10 +02:00 · 2026-04-22 09:35:08 +08:00 · 2026-04-21 23:41:34 +08:00 · 2026-04-21 19:43:11 +08:00 · 2026-04-21 17:15:23 +08:00 · 2026-04-21 14:41:27 +08:00
863 changed files with 48438 additions and 38541 deletions
@@ -0,0 +1,83 @@
+# find . -type f \( -name "*.c" -o -name "*.h" -o -name "*.cpp" -o -name "*.hpp" \) ! -path "src/3rdparty/*" -print0 | xargs -0 clang-format -i
+
+BasedOnStyle: LLVM
+Language: Cpp
+
+UseTab: Never
+IndentWidth: 4
+TabWidth: 4
+ContinuationIndentWidth: 4
+
+ColumnLimit: 0
+ReflowComments: true
+
+BreakBeforeBraces: Attach
+BreakBeforeCloseBracketBracedList: true
+BraceWrapping:
+  AfterControlStatement: false
+  AfterEnum: false
+  AfterFunction: false
+  AfterStruct: false
+  AfterUnion: false
+  AfterExternBlock: false
+  BeforeElse: false
+  BeforeCatch: false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+  SplitEmptyNamespace: false
+IndentExternBlock: NoIndent
+
+AllowShortIfStatementsOnASingleLine: AllIfsAndElse
+AllowShortLoopsOnASingleLine: true
+AllowShortBlocksOnASingleLine: true
+AllowShortFunctionsOnASingleLine: Empty
+InsertBraces: true
+
+PointerAlignment: Left
+DerivePointerAlignment: false
+SpaceBeforeParens: ControlStatements
+SpacesInParentheses: false
+SpaceAfterCStyleCast: true
+SpacesInLineCommentPrefix:
+  Minimum: 1
+  Maximum: 1
+SpacesInContainerLiterals: true
+
+SortIncludes: Never
+IndentPPDirectives: BeforeHash
+PPIndentWidth: 4
+
+IndentCaseLabels: true
+
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignOperands: DontAlign
+
+BinPackParameters: false
+BinPackArguments: false
+AlignAfterOpenBracket: DontAlign
+BracedInitializerIndentWidth: 4
+Cpp11BracedListStyle: Block
+
+ForEachMacros:
+  - FF_LIST_FOR_EACH
+  - yyjson_obj_foreach
+  - yyjson_arr_foreach
+  - yyjson_mut_obj_foreach
+  - yyjson_mut_arr_foreach
+
+AttributeMacros:
+  - FF_A_FALLTHROUGH
+  - FF_A_DEPRECATED
+  - FF_A_CLEANUP
+  - FF_A_NODISCARD
+  - FF_A_PRINTF
+  - FF_A_SCANF
+  - FF_A_NONNULL
+  - FF_A_RETURNS_NONNULL
+  - FF_A_UNUSED
+  - FF_A_PACKED
+  - FF_A_WEAK_IMPORT
+
+MaxEmptyLinesToKeep: 1
+KeepEmptyLinesAtTheStartOfBlocks: false
@@ -0,0 +1,2 @@
+src/3rdparty/**
+build/**
@@ -0,0 +1,3 @@
+github: LinusDierheimer
+ko_fi: carterli
+custom: https://paypal.me/zhangsongcui
@@ -16,6 +16,15 @@ body:
      options:
        - label: I have checked the FAQ but the issue is not covered
          required: true
+  - type: checkboxes
+    attributes:
+      label: Not a known issue
+      description: Please check if the issue is already known and being worked on.
+      options:
+        - label: I have checked the existing issues but the issue is not covered
+          required: true
+        - label: My issue is not about crashing on Fedora and KDE 6.6
+          required: true
  - type: markdown
    attributes:
      value: "### General description of the bug"
@@ -6,33 +6,42 @@ body:
  - type: markdown
    attributes:
      value: |
-        Tip: A logo can be displayed by fastfetch without getting into fastfetch's official repo.
-        For highly customized logo for personal use, it's recommended to keep it locally.
+        Tip: You can display a logo in fastfetch without adding it to fastfetch's official repo.
+        For highly customized, personal logos, we recommend keeping them locally.
        Please refer to https://github.com/fastfetch-cli/fastfetch/wiki/Migrate-Neofetch-Logo-To-Fastfetch
  - type: textarea
    attributes:
      label: OS
-      description: Paste content of `/etc/os-release` and `/etc/lsb-release` here. If none of these files exist, describe a way to identify the distro
+      description: Paste the contents of `/etc/os-release` and `/etc/lsb-release` here. If neither file exists, describe how to identify the distro.
      placeholder: cat /etc/os-release
    validations:
      required: true
+  - type: input
+    attributes:
+      label: Distro Website
+      description: To help prevent spam and verify the request, a distro website is required, and a downloadable ISO must be available on that site.
+      placeholder: https://example.com
+    validations:
+      required: true
  - type: textarea
    attributes:
      label: ASCII Art
-      description: An ASCII logo should not take up too much space (smaller than 50x20 characters). Please also include the color codes if not available in `os-release`
+      description: The ASCII logo should not take up too much space (smaller than 50x20 characters, W x H). Please also include the color codes if they are not available in `os-release`.
      placeholder: Paste ASCII art here
    validations:
      required: true
  - type: input
    attributes:
-      label: Original Image
-      description: If the ASCII art is based on an image, please provide a link to the original image
-      placeholder: Image URL or distro website URL
+      label: Original Image URL
+      description: If the ASCII art is based on an image, please provide a link to the original image file.
+      placeholder: Image URL from the distro website mentioned above
  - type: checkboxes
    attributes:
      label: Checklist
      options:
-        - label: The ASCII art is smaller than 50x20 characters (width x height)
+        - label: The ASCII art is smaller than 50x20 characters (W x H).
          required: true
-        - label: The ASCII art contains color codes, or the color codes are available in `os-release`
+        - label: The ASCII art includes color codes, or the color codes are available in `os-release`.
+          required: true
+        - label: The ASCII art has no internal padding (spaces at the start and/or end of lines).
          required: true
@@ -0,0 +1,26 @@
+## Summary
+
+<!-- Briefly describe what this PR does. -->
+
+## Related issue (required for new logos for new distros)
+
+<!--
+If this PR adds a new logo, it MUST be linked to an existing "Logo Request" issue and has the requests fulfilled.
+
+Use one of the following formats so GitHub links it properly:
+- Closes #1234
+- Fixes #1234
+- Resolves #1234
+
+PRs that add logos without an associated Logo Request issue will not be accepted.
+-->
+
+Closes #
+
+## Changes
+
+- 
+
+## Checklist
+
+- [ ] I have tested my changes locally.
@@ -0,0 +1,40 @@
+name: Reusable DragonFly amd64
+
+on:
+  workflow_call:
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v6
+
+      - name: run VM
+        uses: vmactions/dragonflybsd-vm@v1
+        with:
+          usesh: yes
+          envs: 'CMAKE_BUILD_TYPE'
+          prepare: |
+            uname -a
+            pkg update
+            pkg install -y llvm cmake git pkgconf binutils wayland vulkan-headers vulkan-loader libxcb libXrandr libX11 libdrm glib dconf dbus sqlite3-tcl egl opencl ocl-icd v4l_compat chafa libelf
+
+          run: |
+            env CC=clang cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On .
+            cmake --build . --target package --verbose -j4
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: fastfetch-dragonfly-amd64
+          path: ./fastfetch-*.*
@@ -0,0 +1,42 @@
+name: Reusable FreeBSD amd64
+
+on:
+  workflow_call:
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v6
+
+      - name: run VM
+        uses: cross-platform-actions/action@master
+        with:
+          operating_system: freebsd
+          architecture: x86-64
+          cpu_count: 4
+          shell: bash
+          version: '15.0'
+          environment_variables: 'CMAKE_BUILD_TYPE'
+          run: |
+            uname -a
+            sudo pkg update
+            sudo pkg install -y cmake git pkgconf binutils wayland vulkan-headers vulkan-loader libxcb libXrandr libX11 libdrm glib dconf dbus sqlite3-tcl egl opencl ocl-icd v4l_compat chafa
+            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On .
+            cmake --build . --target package --verbose -j4
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: fastfetch-freebsd-amd64
+          path: ./fastfetch-*.*
@@ -0,0 +1,40 @@
+name: Reusable Haiku amd64
+
+on:
+  workflow_call:
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v6
+
+      - name: run VM
+        uses: cross-platform-actions/action@master
+        with:
+          operating_system: haiku
+          version: 'r1beta5'
+          architecture: x86-64
+          cpu_count: 4
+          shell: bash
+          environment_variables: 'CMAKE_BUILD_TYPE'
+          run: |
+            uname -a
+            pkgman install -y git dbus_devel mesa_devel libelf_devel imagemagick_devel opencl_headers ocl_icd_devel vulkan_devel zlib_devel chafa_devel cmake gcc make pkgconfig python3.10 || pkgman install -y git dbus_devel mesa_devel libelf_devel imagemagick_devel opencl_headers ocl_icd_devel vulkan_devel zlib_devel chafa_devel cmake gcc make pkgconfig python3.10
+            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On .
+            cmake --build . --target package --verbose -j4
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: fastfetch-haiku-amd64
+          path: ./fastfetch-*.*
@@ -0,0 +1,40 @@
+name: Reusable Linux armv6l
+
+on:
+  workflow_call:
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v6
+
+      - name: run VM
+        uses: uraimo/run-on-arch-action@v3
+        id: runcmd
+        with:
+          arch: armv6
+          distro: bookworm
+          githubToken: ${{ github.token }}
+          run: |
+            uname -a
+            apt-get update && apt-get install -y wget
+            apt-get install -y cmake make gcc libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libsqlite3-dev librpm-dev libegl-dev libglx-dev ocl-icd-opencl-dev libpulse-dev libdrm-dev libelf-dev rpm
+            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr .
+            cmake --build . --target package --verbose -j4
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: fastfetch-linux-armv6l
+          path: ./fastfetch-*.*
@@ -0,0 +1,44 @@
+name: Reusable Linux armv7l
+
+on:
+  workflow_call:
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v6
+
+      - name: run VM
+        uses: uraimo/run-on-arch-action@v3
+        id: runcmd
+        with:
+          arch: armv7
+          distro: ubuntu22.04
+          githubToken: ${{ github.token }}
+          run: |
+            uname -a
+            apt-get update && apt-get install -y software-properties-common ca-certificates gpg curl
+            add-apt-repository -y ppa:ubuntu-toolchain-r/test
+            curl -L https://apt.kitware.com/keys/kitware-archive-latest.asc | gpg --dearmor - | tee /usr/share/keyrings/kitware-archive-keyring.gpg >/dev/null
+            echo 'deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ jammy main' | tee /etc/apt/sources.list.d/kitware.list >/dev/null
+            echo -e 'Acquire::https::Verify-Peer "false";\nAcquire::https::Verify-Host "false";' >> /etc/apt/apt.conf.d/99ignore-certificates
+            apt-get update && apt-get install -y cmake make gcc-13 libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libsqlite3-dev librpm-dev libegl-dev libglx-dev ocl-icd-opencl-dev libpulse-dev libdrm-dev libelf-dev rpm
+            CC=gcc-13 cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr .
+            cmake --build . --target package --verbose -j4
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: fastfetch-linux-armv7l
+          path: ./fastfetch-*.*
@@ -0,0 +1,103 @@
+name: Reusable Linux Hosts
+
+on:
+  workflow_call:
+    inputs:
+      arch:
+        required: true
+        type: string
+      runs-on:
+        required: true
+        type: string
+    outputs:
+      ffversion:
+        description: fastfetch version from linux host build
+        value: ${{ jobs.build.outputs.ffversion }}
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ${{ inputs.runs-on }}
+    outputs:
+      ffversion: ${{ steps.ffversion.outputs.ffversion }}
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v6
+
+      - name: uname -a
+        run: uname -a
+
+      - name: cat /etc/os-release
+        run: cat /etc/os-release
+
+      - name: cat /proc/cpuinfo
+        run: cat /proc/cpuinfo
+
+      - name: add gcc-13 repo
+        run: sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+
+      - name: install required packages
+        run: sudo apt-get update && sudo apt-get install -y gcc-13 libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libsqlite3-dev librpm-dev libegl-dev libglx-dev ocl-icd-opencl-dev libpulse-dev libdrm-dev libelf-dev libddcutil-dev rpm ninja-build
+
+      - name: install linuxbrew packages
+        run: |
+          /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+          /home/linuxbrew/.linuxbrew/bin/brew install imagemagick chafa --ignore-dependencies
+
+      - name: Initialize CodeQL
+        if: inputs.arch == 'amd64'
+        uses: github/codeql-action/init@v4
+        with:
+          languages: c
+
+      - name: configure project
+        run: CC=gcc-13 PKG_CONFIG_PATH=/home/linuxbrew/.linuxbrew/lib/pkgconfig:$PKG_CONFIG_PATH cmake -GNinja -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On -DCMAKE_INSTALL_PREFIX=/usr .
+
+      - name: build project
+        run: cmake --build . --target package --verbose -j4
+
+      - name: perform CodeQL analysis
+        if: inputs.arch == 'amd64'
+        uses: github/codeql-action/analyze@v4
+
+      - name: list features
+        run: ./fastfetch --list-features
+
+      - name: run fastfetch
+        run: time ./fastfetch -c presets/ci.jsonc --stat false
+
+      - name: run fastfetch --format json
+        run: time ./fastfetch -c presets/ci.jsonc --format json
+
+      - name: run flashfetch
+        run: time ./flashfetch
+
+      - name: print dependencies
+        run: ldd fastfetch
+
+      - name: run tests
+        run: ctest --output-on-failure
+
+      - name: get fastfetch version
+        id: ffversion
+        run: echo "ffversion=$(./fastfetch --version-raw)" >> $GITHUB_OUTPUT
+
+      - name: polyfill glibc
+        run: |
+          wget https://github.com/CarterLi/polyfill-glibc/releases/download/v0.0.1/polyfill-glibc-${{ inputs.arch }} -O polyfill-glibc
+          chmod +x polyfill-glibc
+          strip fastfetch && ./polyfill-glibc fastfetch --target-glibc=2.17
+          strip flashfetch && ./polyfill-glibc flashfetch --target-glibc=2.17
+          echo 'set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_FILE_NAME}-polyfilled")' >> CPackConfig.cmake
+          echo 'set(CPACK_PACKAGE_RELOCATABLE OFF)' >> CPackConfig.cmake
+          echo 'set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6 (>= 2.17)")' >> CPackConfig.cmake
+          echo 'set(CPACK_RPM_SPEC_MORE_DEFINE "%global __os_install_post %{nil}")' >> CPackConfig.cmake
+          cpack -V
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: fastfetch-linux-${{ inputs.arch }}
+          path: ./fastfetch-*.*
@@ -0,0 +1,70 @@
+name: Reusable Linux i686
+
+on:
+  workflow_call:
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-22.04
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v6
+
+      - name: uname -a
+        run: uname -a
+
+      - name: cat /etc/os-release
+        run: cat /etc/os-release
+
+      - name: cat /proc/cpuinfo
+        run: cat /proc/cpuinfo
+
+      - name: add gcc-13 repo
+        run: sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+
+      - name: install required packages
+        run: sudo apt-get update && sudo apt-get install -y gcc-13 gcc-13-multilib libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libsqlite3-dev librpm-dev libegl-dev libglx-dev ocl-icd-opencl-dev libpulse-dev libdrm-dev libelf-dev libddcutil-dev rpm ninja-build
+
+      - name: install linuxbrew packages
+        run: |
+          /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+          /home/linuxbrew/.linuxbrew/bin/brew install imagemagick chafa --ignore-dependencies
+
+      - name: cmake version
+        run: cmake --version
+
+      - name: configure project
+        run: CC=gcc-13 PKG_CONFIG_PATH=/home/linuxbrew/.linuxbrew/lib/pkgconfig:$PKG_CONFIG_PATH cmake -DCMAKE_C_FLAGS="-m32 -march=i686 -mtune=i686" -DCMAKE_SYSTEM_PROCESSOR_OVERRIDE=i686 -DCPACK_DEBIAN_PACKAGE_ARCHITECTURE=i386 -GNinja -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On -DCMAKE_INSTALL_PREFIX=/usr .
+
+      - name: build project
+        run: cmake --build . --target package --verbose -j4
+
+      - name: check deb package
+        run: dpkg -I fastfetch-*.deb
+
+      - name: list features
+        run: ./fastfetch --list-features
+
+      - name: run fastfetch
+        run: time ./fastfetch -c presets/ci.jsonc --stat false
+
+      - name: run fastfetch --format json
+        run: time ./fastfetch -c presets/ci.jsonc --format json
+
+      - name: run flashfetch
+        run: time ./flashfetch
+
+      - name: print dependencies
+        run: ldd fastfetch
+
+      - name: run tests
+        run: ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: fastfetch-linux-i686
+          path: ./fastfetch-*.*
@@ -0,0 +1,45 @@
+name: Reusable Linux VMs
+
+on:
+  workflow_call:
+    inputs:
+      arch:
+        required: true
+        type: string
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v6
+
+      - name: run VM
+        uses: uraimo/run-on-arch-action@v3
+        id: runcmd
+        with:
+          arch: ${{ inputs.arch }}
+          distro: ubuntu22.04
+          githubToken: ${{ github.token }}
+          run: |
+            uname -a
+            apt-get update && apt-get install -y software-properties-common
+            add-apt-repository -y ppa:ubuntu-toolchain-r/test
+            apt-get update && apt-get install -y cmake make gcc-13 libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libsqlite3-dev librpm-dev libegl-dev libglx-dev ocl-icd-opencl-dev libpulse-dev libdrm-dev libchafa-dev libelf-dev rpm
+            CC=gcc-13 cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr .
+            cmake --build . --target package --verbose -j4
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: fastfetch-linux-${{ inputs.arch }}
+          path: ./fastfetch-*.*
@@ -0,0 +1,58 @@
+name: Reusable macOS Hosts
+
+on:
+  workflow_call:
+    inputs:
+      arch:
+        required: true
+        type: string
+      runs-on:
+        required: true
+        type: string
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ${{ inputs.runs-on }}
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v6
+
+      - name: uname -a
+        run: uname -a
+
+      - name: install required packages
+        run: |
+          HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1 brew install --overwrite vulkan-loader vulkan-headers molten-vk imagemagick chafa
+
+      - name: configure project
+        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .
+
+      - name: build project
+        run: cmake --build . --target package --verbose -j4
+
+      - name: list features
+        run: ./fastfetch --list-features
+
+      - name: run fastfetch
+        run: time ./fastfetch -c presets/ci.jsonc --structure-disabled vulkan --stat false
+
+      - name: run fastfetch --format json
+        run: time ./fastfetch -c presets/ci.jsonc --structure-disabled vulkan --format json
+
+      - name: run flashfetch
+        run: time ./flashfetch
+
+      - name: print dependencies
+        run: otool -L fastfetch
+
+      - name: run tests
+        run: ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: fastfetch-macos-${{ inputs.arch }}
+          path: ./fastfetch-*.*
@@ -0,0 +1,45 @@
+name: Reusable Musl amd64
+
+on:
+  workflow_call:
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: setup alpine linux
+        uses: jirutka/setup-alpine@master
+
+      - name: install dependencies
+        run: |
+          cat /etc/alpine-release
+          uname -a
+          apk add cmake samurai vulkan-loader-dev libxcb-dev libxrandr-dev rpm-dev wayland-dev libdrm-dev dconf-dev imagemagick-dev chafa-dev zlib-dev dbus-dev mesa-dev opencl-dev sqlite-dev networkmanager-dev pulseaudio-dev ddcutil-dev elfutils-dev gcc g++
+        shell: alpine.sh --root {0}
+
+      - name: build
+        run: |
+            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr -DIS_MUSL=ON -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On -GNinja .
+            cmake --build . --target package --verbose -j4
+        shell: alpine.sh {0}
+
+      - name: run
+        run: |
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest --output-on-failure
+        shell: alpine.sh {0}
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: fastfetch-musl-amd64
+          path: ./fastfetch-*.*
@@ -0,0 +1,41 @@
+name: Reusable NetBSD amd64
+
+on:
+  workflow_call:
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v6
+
+      - name: run VM
+        uses: cross-platform-actions/action@master
+        with:
+          operating_system: netbsd
+          architecture: x86-64
+          cpu_count: 4
+          shell: bash
+          version: '10.1'
+          environment_variables: 'CMAKE_BUILD_TYPE'
+          run: |
+            uname -a
+            sudo pkgin -y install clang cmake git pkgconf wayland vulkan-headers dconf dbus sqlite3 ImageMagick
+            CC=clang cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On .
+            cmake --build . --target package --verbose -j4
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: fastfetch-netbsd-amd64
+          path: ./fastfetch-*.*
@@ -0,0 +1,42 @@
+name: Reusable No Features Test
+
+on:
+  workflow_call:
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v6
+
+      - name: uname -a
+        run: uname -a
+
+      - name: configure project
+        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr . -DENABLE_VULKAN=OFF -DENABLE_WAYLAND=OFF -DENABLE_XCB_RANDR=OFF -DENABLE_XCB=OFF -DENABLE_XRANDR=OFF -DENABLE_X11=OFF -DENABLE_DRM=OFF -DENABLE_DRM_AMDGPU=OFF -DENABLE_GIO=OFF -DENABLE_DCONF=OFF -DENABLE_DBUS=OFF -DENABLE_SQLITE3=OFF -DENABLE_RPM=OFF -DENABLE_IMAGEMAGICK7=OFF -DENABLE_IMAGEMAGICK6=OFF -DENABLE_CHAFA=OFF -DENABLE_ZLIB=OFF -DENABLE_EGL=OFF -DENABLE_GLX=OFF -DENABLE_OPENCL=OFF -DENABLE_FREETYPE=OFF -DENABLE_PULSE=OFF -DENABLE_DDCUTIL=OFF -DENABLE_ELF=OFF -DENABLE_THREADS=OFF
+
+      - name: build project
+        run: cmake --build . --target package --verbose -j4
+
+      - name: list features
+        run: ./fastfetch --list-features
+
+      - name: run fastfetch
+        run: time ./fastfetch -c presets/ci.jsonc --stat false
+
+      - name: run fastfetch --format json
+        run: time ./fastfetch -c presets/ci.jsonc --format json
+
+      - name: run flashfetch
+        run: time ./flashfetch
+
+      - name: print dependencies
+        run: ldd fastfetch
+
+      - name: run tests
+        run: ctest --output-on-failure
@@ -0,0 +1,42 @@
+name: Reusable OmniOS amd64
+
+on:
+  workflow_call:
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v6
+
+      - name: run VM
+        uses: vmactions/omnios-vm@v1
+        with:
+          usesh: true
+          envs: 'CMAKE_BUILD_TYPE'
+          prepare: |
+            uname -a
+            pkg update --accept
+            pkg install gcc14 cmake git pkg-config glib2 dbus sqlite-3 imagemagick ninja
+
+          run: |
+            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -GNinja .
+            cmake --build . --verbose -j4
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest --output-on-failure
+            echo 'set(CPACK_PACKAGE_FILE_NAME "fastfetch-omnios-amd64")' >> CPackConfig.cmake
+            cpack -V
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: fastfetch-omnios-amd64
+          path: ./fastfetch-*.*
@@ -0,0 +1,42 @@
+name: Reusable OpenBSD amd64
+
+on:
+  workflow_call:
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v6
+
+      - name: run VM
+        uses: cross-platform-actions/action@master
+        with:
+          operating_system: openbsd
+          architecture: x86-64
+          cpu_count: 4
+          shell: bash
+          version: '7.8'
+          environment_variables: 'CMAKE_BUILD_TYPE'
+          run: |
+            uname -a
+            sudo pkg_add -u
+            sudo pkg_add -r llvm-21.1.2p0 cmake git pkgconf wayland vulkan-headers vulkan-loader glib2 dconf dbus sqlite3 imagemagick chafa
+            CC=clang-21 cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On .
+            cmake --build . --target package --verbose -j4
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: fastfetch-openbsd-amd64
+          path: ./fastfetch-*.*
@@ -0,0 +1,58 @@
+name: Reusable Release
+
+on:
+  workflow_call:
+    inputs:
+      ffversion:
+        required: true
+        type: string
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: get latest release version
+        id: get_version_release
+        uses: pozetroninc/github-action-get-latest-release@master
+        with:
+          repository: ${{ github.repository }}
+
+      - name: download artifacts
+        if: inputs.ffversion != steps.get_version_release.outputs.release
+        uses: actions/download-artifact@v8
+
+      - name: create release
+        if: inputs.ffversion != steps.get_version_release.outputs.release
+        uses: ncipollo/release-action@v1
+        with:
+          tag: ${{ inputs.ffversion }}
+          commit: ${{ github.sha }}
+          artifactErrorsFailBuild: true
+          artifacts: fastfetch-*/fastfetch-*
+          body: "Please refer to [CHANGELOG.md](https://github.com/${{ github.repository }}/blob/${{ inputs.ffversion }}/CHANGELOG.md) for details."
+
+      - name: download source tarballs
+        if: inputs.ffversion != steps.get_version_release.outputs.release
+        run: |
+          for i in 1 2 3 4 5; do curl -L --remote-name-all --output-dir fastfetch-source --create-dirs https://github.com/${{ github.repository }}/archive/refs/tags/${{ inputs.ffversion }}.{tar.gz,zip} && break || sleep 5; done
+          ls fastfetch-*/*
+
+      - name: generate release notes
+        if: inputs.ffversion != steps.get_version_release.outputs.release
+        run: |
+          echo "Please refer to [CHANGELOG.md](https://github.com/${{ github.repository }}/blob/${{ inputs.ffversion }}/CHANGELOG.md) for details." > fastfetch-release-notes.md
+          echo -e "\n---\n\n<details><summary>SHA256SUMs</summary><br>\n\n\`\`\`" >> fastfetch-release-notes.md
+          sha256sum fastfetch-*/* >> fastfetch-release-notes.md
+          echo -e "\`\`\`\n</details>" >> fastfetch-release-notes.md
+          echo -e "\n<details><summary>SHA512SUMs</summary><br>\n\n\`\`\`" >> fastfetch-release-notes.md
+          sha512sum fastfetch-*/* >> fastfetch-release-notes.md
+          echo -e "\`\`\`\n</details>" >> fastfetch-release-notes.md
+
+      - name: update release body
+        if: inputs.ffversion != steps.get_version_release.outputs.release
+        uses: ncipollo/release-action@v1
+        with:
+          tag: ${{ inputs.ffversion }}
+          commit: ${{ github.sha }}
+          bodyFile: fastfetch-release-notes.md
+          allowUpdates: true
@@ -0,0 +1,43 @@
+name: Reusable Solaris amd64
+
+on:
+  workflow_call:
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v6
+
+      - name: run VM
+        uses: vmactions/solaris-vm@v1
+        with:
+          usesh: true
+          envs: 'CMAKE_BUILD_TYPE'
+          release: "11.4-gcc-14"
+          prepare: |
+            uname -a
+            pkg install cmake git pkg-config glib2 dbus sqlite-3 imagemagick ninja dconf mesa
+
+          run: |
+            export PKG_CONFIG_PATH=/usr/lib/64/pkgconfig
+            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -GNinja .
+            cmake --build . --verbose -j4
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest --output-on-failure
+            echo 'set(CPACK_PACKAGE_FILE_NAME "fastfetch-solaris-amd64")' >> CPackConfig.cmake
+            cpack -V
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: fastfetch-solaris-amd64
+          path: ./fastfetch-*.*
@@ -0,0 +1,24 @@
+name: Reusable Spellcheck
+
+on:
+  workflow_call:
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  spellcheck:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v6
+
+      - name: Install codespell
+        shell: bash
+        run: |
+          sudo apt-get update || true
+          sudo apt-get install -y codespell
+
+      - name: Run Spellchecker
+        run: codespell
@@ -0,0 +1,106 @@
+name: Reusable Windows Hosts
+
+on:
+  workflow_call:
+    inputs:
+      arch:
+        required: true
+        type: string
+      runs-on:
+        required: true
+        type: string
+      msystem:
+        required: true
+        type: string
+      msystem-lower:
+        required: true
+        type: string
+      msys-arch:
+        required: true
+        type: string
+
+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
+jobs:
+  build:
+    runs-on: ${{ inputs.runs-on }}
+    defaults:
+      run:
+        shell: msys2 {0}
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v6
+
+      - name: setup-msys2
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: ${{ inputs.msystem }}
+          update: true
+          install: git mingw-w64-clang-${{ inputs.msys-arch }}-7zip mingw-w64-clang-${{ inputs.msys-arch }}-cmake mingw-w64-clang-${{ inputs.msys-arch }}-clang mingw-w64-clang-${{ inputs.msys-arch }}-vulkan-loader mingw-w64-clang-${{ inputs.msys-arch }}-vulkan-headers mingw-w64-clang-${{ inputs.msys-arch }}-opencl-icd mingw-w64-clang-${{ inputs.msys-arch }}-opencl-headers mingw-w64-clang-${{ inputs.msys-arch }}-cppwinrt mingw-w64-clang-${{ inputs.msys-arch }}-imagemagick mingw-w64-clang-${{ inputs.msys-arch }}-chafa mingw-w64-clang-${{ inputs.msys-arch }}-directx-headers
+
+      - name: print msys version
+        run: uname -a
+
+      - name: configure project
+        run: env PKG_CONFIG_PATH=/${{ inputs.msystem-lower }}/lib/pkgconfig/:$PKG_CONFIG_PATH cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .
+
+      - name: build project
+        run: cmake --build . --verbose -j4
+
+      - name: copy necessary dlls
+        run: cp /${{ inputs.msystem-lower }}/bin/{OpenCL,vulkan-1}.dll .
+
+      - name: list features
+        run: ./fastfetch --list-features
+
+      - name: run fastfetch
+        run: time ./fastfetch -c presets/ci.jsonc --stat false
+
+      - name: run fastfetch --format json
+        run: time ./fastfetch -c presets/ci.jsonc --format json
+
+      - name: run flashfetch
+        run: time ./flashfetch
+
+      - name: print dependencies
+        run: ldd fastfetch
+
+      - name: run tests
+        run: ctest --output-on-failure
+
+      - if: github.event_name == 'push' && github.repository == 'fastfetch-cli/fastfetch'
+        id: upload-unsigned-artifact
+        name: upload artifacts for signing
+        uses: actions/upload-artifact@v7
+        with:
+          name: fastfetch-windows-${{ inputs.arch }}
+          path: |
+            *.dll
+            fastfetch.exe
+            flashfetch.exe
+
+      - if: github.event_name == 'push' && github.repository == 'fastfetch-cli/fastfetch'
+        name: submit signing request
+        uses: signpath/github-action-submit-signing-request@v1
+        with:
+          api-token: '${{ secrets.SIGNPATH_API_TOKEN }}'
+          organization-id: '${{ vars.SIGNPATH_ORG_ID }}'
+          project-slug: 'fastfetch'
+          signing-policy-slug: ${{ github.ref == 'refs/heads/master' && 'release-signing' || 'test-signing' }}
+          github-artifact-id: '${{ steps.upload-unsigned-artifact.outputs.artifact-id }}'
+          wait-for-completion: true
+          output-artifact-directory: '.'
+
+      - name: create zip archive
+        run: 7z a -tzip -mx9 -bd -y fastfetch-windows-${{ inputs.arch }}.zip LICENSE *.dll fastfetch.exe flashfetch.exe presets
+
+      - name: create 7z archive
+        run: 7z a -t7z -mx9 -bd -y fastfetch-windows-${{ inputs.arch }}.7z LICENSE *.dll fastfetch.exe flashfetch.exe presets
+
+      - name: upload true artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: fastfetch-windows-${{ inputs.arch }}
+          path: ./fastfetch-windows-${{ inputs.arch }}.*
+          overwrite: true
@@ -1,3 +1,384 @@
+# 2.62.0
+
+Changes:
+* Sort package managers alphabetically in output and format arguments (Packages)
+    * The positional order of format arguments has changed — this is a breaking change for users relying on numeric placeholders. Named arguments are always preferred; e.g., use `{pacman}` (refer to `fastfetch -h packages-format`) instead of `{1}` to keep your config future-proof.
+
+Features:
+* Reports `Unused` instead of `Disabled` for zero-size swap on macOS (#2248, Swap, macOS)
+* Improves the robustness of default route detection on Linux (#2252, LocalIP, Linux)
+* PhysicalDisk module improvements
+    * Detects virtual disks and adds support for hiding them via `hideVirtual` option (defaults to `false`)
+    * Detects unused/disconnected disks and adds support for hiding them via `hideUnused` option (defaults to `true`)
+    * Adds support for OpenBSD and NetBSD (root privileges are required to access disk information)
+    * Improves interconnect type detection on SunOS
+    * Adds floppy drive support on Windows
+* Rewrites Windows GPU detection with D3DKMT APIs, unifying it with WSL GPU detection (GPU, Windows)
+* Verifies that the battery and power adapter are present before detection (Battery / PowerAdapter, Linux)
+* Improves PhysicalMemory reliability on OpenBSD and FreeBSD, including support for x86 UEFI systems on OpenBSD and non-UEFI systems on FreeBSD (PhysicalMemory, OpenBSD / FreeBSD)
+* Adds `display.common.(ndigits|spaceBeforeUnit)` options to configure common formatting for duration, percent, size, frequency and temperature values (#2234)
+* Slightly improves performance by skipping probes for ignored device types (Sound)
+* Adds support for AppImage package detection (#2179, Packages, Linux)
+
+Bugfixes:
+* Fixes a potential crash on certain Intel GPU models when using `--gpu-driver-specific` (#2259, GPU, Linux)
+* Doesn't report partitions as physical disks (DiskIO, NetBSD)
+* Fixes a typo (#2260, Wifi, macOS)
+* Corrects documentation for zpool format placeholders (#2261, Zpool)
+* Restores Windows 8.1 support (Cursor, Windows)
+* Fixes an out-of-bounds memory access when swaps are disabled (Swap, Windows)
+* Fixes battery status being incorrectly reported as `Charging` on systems with multiple batteries (#2263, Battery, Linux)
+* Fixes ash shell version detection (#2271, Shell, Linux)
+* Uses the `iterm` image protocol automatically on iTerm terminals for auto logo type (Logo)
+* Adds missing options when generating full config file
+
+Logos:
+* Updates AerynOS (#2272)
+
+# 2.61.0
+
+Changes:
+* Support for Windows 7 and 8 has been removed.
+    * Windows 8.1 is now the oldest version supported by fastfetch.
+* The GPU module on WSL no longer relies on `DXCore`.
+    * The `directx-headers` dependency is no longer required.
+    * Fastfetch on Linux is now pure C; a C++ compiler is no longer required.
+    * GPU type detection is now slightly less accurate, but detection speed should be slightly faster.
+* The GPU module on Windows now uses `DXCore` for more accurate GPU type detection (requires Windows 10 or later).
+    * This feature is built only when `DXCore` headers are available, which requires installing `mingw-w64-<msystem>-x86_64-directx-headers` on MSYS2.
+
+Features:
+* Adds a `brightness` option for color display configuration (#2238, Colors)
+* Adds support for detecting Bluetooth keyboards on Linux (#2220, Keyboard)
+* Adds support for detecting GlazeWM (WM, macOS)
+* Adds a `showEmptySlots` option to display empty memory slots on Linux (#2222, PhysicalMemory)
+* Adds marketing product name detection on Asahi Linux (Host, Linux)
+* Adds support for new M5 Mac models (Host, macOS)
+* Improves SMBIOS robustness by validating malformed data and improving error handling
+* Improves reliability when terminating child processes (Processing, Windows)
+* Improves Intel Mac support by querying SMBIOS data directly (Global, macOS)
+* Includes numerous internal cleanups and optimizations
+
+Bugfixes:
+* Fixes missing memory devices on some machines (PhysicalMemory)
+* Fixes CPUCache deduplication for shared caches (#2228, CPUCache, Linux)
+* Fixes WM version reporting for niri (#2218, WM, Linux)
+* Fixes SSID decoding issues from `iw` output (Wifi, Linux)
+* Fixes the CMD code page being changed after running fastfetch on Windows (#2245, Windows)
+
+# 2.60.0
+
+Changes:
+* The CMake option `ENABLE_WIN7_COMPAT:BOOLEAN` now defaults to `OFF` and will be removed in v2.61.0, effectively dropping support for Windows 7 in the next release.
+    * This follows the Windows 7 deprecation notice introduced in v2.57.0.
+* `wm.detectPlugin` now defaults to `true` (WM)
+
+Features:
+* Adds `{cwd}` for custom title formatting, which displays the current working directory (Title)
+* Adds support for detecting the Zed version (#2200, Editor)
+* Adds support for detecting `moss` packages (Packages, Linux)
+* Adds support for detecting komorebi, FancyWM, and GlazeWM (WM, Windows)
+* Adds support for WM plugin version detection on macOS (WM, macOS)
+* Adds support for retrieving the executable path on OpenBSD (#2195, OpenBSD)
+
+Bugfixes:
+* Fixes a potential segmentation fault caused by dereferencing a negative index (#2198)
+* Fixes `tempSensor` parsing so that it accepts only string values (#2202, CPU)
+* Fixes an issue that unexpectedly caused fewer devices to be reported (Keyboard, Linux)
+* Improves WM detection on LXQt by querying WM settings only when no WM has already been detected (#2199, WM, Linux)
+* Fixes memory leaks in DBus connection handling and in the OpenGL EGL context lifecycle
+* Fixes niri version detection on Fedora (WM, Linux)
+* Includes various internal cleanups and optimizations
+
+Logos:
+* Adds `RengeOS` (#2170)
+* Adds `Emmabuntüs` (#2207)
+* Updates Artix Linux (#2157)
+* Updates Linux Mint (#2186)
+* Renames `Refracted Devuan` to `Refracta`
+* Renames `ExodiaPredator` to `ExodiaOS`
+
+# 2.59.0
+
+Changes:
+* Fastfetch no longer relies on the unreliable environment variables `$USER` or `%USERPROFILE%` to determine the current username (Title)
+    * People who set `$USER` to customize the Fastfetch title should use `{ "type": "title", "format": "your-custom-user-name" }` to achieve the same result.
+* Fastfetch no longer tries to probe inaccessible remote disk drives on Windows (Disk, Windows)
+    * People who have remote drives may use `{ "type": "disk", "hideFolders": "X:\\" }` to ignore problematic ones.
+    * This change removes some ugly hacks from the codebase and matches the behavior on `*nix`.
+
+Features:
+* Adds Oracle Solaris support (#2176, SunOS)
+* Adds UID / SID detection (Title)
+    * In custom format: `{user-id}`
+* Switches to native GPU detection on GNU/Hurd and removes the `libpciaccess` dependency (GPU, Hurd)
+* Improves memory size detection on macOS (Memory, macOS)
+    * Avoids relying on `hw.memsize_usable` by default, which may not be available on older macOS versions
+* Improves Windows disk detection accuracy and performance (Disk, Windows)
+* Adds more ARM CPU parts and removes duplicated cases (CPU, ARM)
+
+Logos:
+* Adds 6-color support to the NixOS logo (including the small variant) (#2180)
+
+# 2.58.0
+
+An early release to fix compatibility issues with KDE Plasma 6.6.
+
+Breaking changes:
+* The `de.slowVersionDetection` option has been removed. Slow version detection is now always enabled, as required on non-FHS-compliant distros (e.g., NixOS). (#2149, DE, Linux)
+
+Features:
+* Adds the `--structure-disabled <modules...>` command-line flag to temporarily disable module structure printing.
+    * For example: `fastfetch --structure-disabled colors` removes the color blocks from the default output.
+* Supports chassis type detection on Linux ARM devices when reported via the device tree (Chassis, Linux)
+* Supports Bedrock Linux version detection (#2155, OS, Linux)
+* Honors the `DBPath` and `RootDir` settings in `pacman.conf` when detecting Pacman packages (#2154, Packages, Linux)
+
+Bugfixes:
+* Fixes a crash issue on KDE Plasma 6.6 (Display, Linux)
+* Fixes the Command module not working with `--dynamic-interval` (#2152, Command)
+* Fixes Quartz Compositor version detection. It now correctly reports the version of `WindowServer` (`SkyLight`) instead of `WindowManager`. (WM, macOS)
+
+Logos:
+* Adds Kiss2
+
+# 2.57.1
+
+Features:
+* Tiny performance improvements (Windows)
+* Improves the reliability of hostname retrieval (Title, Windows)
+
+Bugfixes:
+* Fixes potential compilation issues on Linux (#2142, Linux)
+* Fixes compilation errors on macOS when building with older SDKs (#2140, macOS)
+* Fixes compilation issues when building with `-DENABLE_SYSTEM_YYJSON=ON` (#2143)
+
+Logos:
+* Updates PrismLinux and adds a small variant
+
+# 2.57.0
+
+Deprecation notice:
+* Support for Windows 7 (and 8.x) is deprecated and will be removed in a future release. Extended support for Windows 7 (and 8.1) ended on January 10, 2023. These versions do not officially support ANSI escape codes (running fastfetch on them requires a third-party terminal such as ConEmu). In addition, Windows 7 lacks some APIs used by fastfetch. Fastfetch currently loads these APIs dynamically at runtime to maintain compatibility, but this adds complexity to the codebase and increases the maintenance burden.
+    * A CMake flag `ENABLE_WIN7_COMPAT:BOOLEAN` has been introduced (defaults to `ON` for now). If set to `OFF`, Windows 7 compatibility code is excluded, and the resulting binaries will support only Windows 10 (version 1607 and later) and Windows 11.
+    * The main prebuilt Windows binaries on the Release page (`fastfetch-windows-amd64.*`) are built with `ENABLE_WIN7_COMPAT=OFF`. These are the binaries used by `scoop` and `winget`. Users who need Windows 7 (or 8.x) support can download the `-win7` variant instead.
+    * ~~The `ENABLE_WIN7_COMPAT` CMake option and the `-win7` variant binaries are planned to be removed in 2.60.0~~.
+
+Features:
+* Supports COSMIC DE version detection (DE, Linux)
+* Supports niri version detection (#2121, WM, Linux)
+* Supports cosmic-term version and terminal font detection (Terminal / TerminalFont, Linux)
+* Supports urxvt font detection (TerminalFont, Linux) (#2105)
+* Improves xterm font detection by checking `xterm.vt100.faceName` (TerminalFont, Linux)
+* Supports Secure Boot detection (Bootmgr, macOS)
+* Supports DPI scale factor detection on Windows 7 (Display, Windows)
+* Supports xterm 256-color codes in color configuration
+    * In `display.color`: "`@<color-index>`" (e.g., "`@34`" for color index `34`)
+    * In `*.format` strings: "`#@<color-index>`" (e.g., "`#@34`" for color index `34`)
+* Improves uptime accuracy on Windows 10+ (Uptime, Windows)
+* Adds a new module `Logo` to query built-in logo raw data in JSON output (Logo)
+    * Usage: `fastfetch -s logo -l <logo-name> -j # Supported in JSON format only`
+* Supports shell version detection even if the binary has been deleted (#2136, Shell, Linux)
+* Overall code refinements and optimizations
+
+Bugfixes:
+* Skips local / loopback routes when detecting network interfaces (LocalIP, Linux) (#2127)
+* Fixes CPU speed detection on s390x (CPU, Linux) (#2129)
+* Fixes GPU detection error handling and supports case-insensitive PCI ID parsing (GPU, Windows)
+* Fixes some networking issues and memory leaks (Networking)
+* Fixes `exePath` reporting relative paths on macOS (Shell, macOS)
+
+Logos:
+* Adds openSUSE Tumbleweed braille logo
+* Adds Xinux
+* Renames HydraPWK to NetHydra
+* Fixes colors of deepin and UOS
+* Fixes colors of macOS and variants
+
+# 2.56.1
+
+Features:
+* Improves compatibility with KDE Plasma 6.5 (#2093, Display)
+* Adds a `tempSensor` option to specify the sensor name used for CPU temperature detection (CPU)
+    * Example: `{ "type": "cpu", "tempSensor": "hwmon0" /* Use /sys/class/hwmon/hwmon0 for temperature detection */ }`
+* Refines Memory usage detection on macOS to match Activity Monitor more closely (Memory, macOS)
+* Minor optimizations
+
+Bugfixes:
+* Fixes cache line size detection (CPU, macOS)
+
+Logos:
+* Removes Opak
+* Updates GXDE
+
+# 2.56.0
+
+Features:
+* Enhances config file loading. `--config` and `-c` with relative path now also searches paths defined in `fastfetch --list-config-paths` (typically `~/.config/fastfetch/`)
+    * This allows users to use `fastfetch -c my-config` without needing to specify the full path.
+* Adds NUMA node count detection (CPU)
+    * Exposed via `{numa-nodes}` in custom format
+    * Supported on Linux, FreeBSD and Windows
+* Supports the newest Alacritty config format (#2070, TerminalFont)
+* Detects driver specific info for Zhaoxin GPUs (GPU, Linux)
+* Detects Android OEM UI for certain OSes (DE, Android)
+* Improves users detection on Linux (#2064, Users, Linux)
+    * Adds systemd fallback when utmp is unavailable
+    * Fixes resource leaks
+    * Always reports the newest session info
+* Adds kiss package manager support (#2072, Packages, Linux)
+* Reports `sshd` if `$SSH_TTY` is not available (Terminal)
+* Zpool module rewrite (#2051, Zpool)
+    * Adds new Zpool properties: allocated, guid, readOnly
+    * Zpool module now uses runtime lookup for properties to ensure portability
+    * Adds NetBSD (requires `sudo`) and macOS support
+* Adds `splitLines` option for Command module, which splits the output into sub modules, each containing one line of the output (Command)
+```
+* Command output:
+Line 1
+Line 2
+Line 3
+
+* Old behavior:
+Command: Line 1
+Line 2
+Line 3
+
+* With `"splitLines": true`:
+Command 1: Line 1
+Command 2: Line 2
+Command 3: Line 3
+```
+
+Bugfixes:
+* Fixes {m,o}ksh version detection on Linux (Shell)
+* Fixes Alacritty config parsing for TOML format (#2070, TerminalFont)
+* Improves builtin logo printing for piping and buffering (#2065, Logo)
+* Uses absolute path when detecting shell and terminal version if available (#2067, TerminalShell)
+
+Logos:
+* Updates Codex Linux logo (#2071)
+* Adds OS/2 Warp logo (#2062)
+* Adds Amiga logo (#2061)
+
+# 2.55.1
+
+Bugfixes:
+* Fix parallel command execution breaks randomly (#2056 / #2058, Command)
+    * Regression from v2.55.0
+* Fix `dylib` searching path on macOS (macOS)
+    * Regression from v2.55.0
+* Fix an uninitialized field (#2057, Display)
+
+# 2.55.0
+
+Changes:
+* Commands are now executed in parallel by default to improve performance (#2045, Command)
+    * This behavior can be disabled in the config file with `"parallel": false` if it causes problems with certain scripts
+* Folder/filesystem hiding is moved to the detection stage; hidden entries are no longer probed, improving performance (#2043, Disk)
+
+Features:
+* Adds `command.parallel` and `command.useStdErr` config options (Command)
+    * `parallel`: set to `false` to disable parallel execution (see Changes above)
+    * `useStdErr`: set to `true` to use stderr output instead of stdout
+* Adds the command-line flag `--dynamic-interval <interval-in-ms>` to enable dynamic output auto-refresh (#2041)
+    * Due to internal limitations, some modules do not support dynamic updates (notably Display and Media)
+* Adds support for using the current playing media's cover art as a logo source (Media / Logo)
+    * Usage: `"logo": { "type": "<image-protocol>", "source": "media-cover" }` in JSON config; or `--<image-protocol> media-cover` in command line
+    * Supports local sources only
+* Adds native GPU detection support on OpenBSD and NetBSD (instead of depending on `libpciaccess`) (GPU)
+    * No functional changes
+    * Root privileges are required to access PCI config space on OpenBSD (as always)
+* Adds GPU detection support on GNU/Hurd (GPU)
+    * Requires building with `libpciaccess`
+* Shows Debian point release on Raspberry Pi OS (#2032, OS, Linux)
+* Adds `Brush` shell version detection (Shell)
+* Improves Mac family detection via prefix matching (Host)
+
+Bugfixes:
+* Ignores `run-parts` during terminal/shell detection (#2048, Terminal / Shell, Linux)
+* Fixes fish version detection when `LC_ALL` is set (#2014, Shell, Linux)
+* Hides the module when no desktop icons are found (#2023, Icons, Windows)
+* Skips auxiliary display controllers to prevent the module from reporting duplicate entries (#2034, GPU, Linux)
+* Refines Apple rpath handling; fixes building for the Homebrew version on macOS (#1998, CMake)
+
+Logos:
+* Adds Vincent OS and MacaroniOS
+
+# 2.54.0
+
+Windows binaries in Release page are now signed by SignPath.
+
+Changes:
+* Moves macOS and Windows design language detection from the DE module to the Theme module
+
+Features:
+* Adds `--json` and `-j` command line flags as a shortcut for `--format json`
+* Various improvements to the OS module (OS)
+    * Displays point releases for Debian
+    * Displays code names for Ubuntu
+    * Displays build ID for macOS
+    * Displays code names for Windows (previously shown in the Kernel module)
+* Adds basic support for Wine (Windows)
+* Adds basic support for hppa and sh architectures (CPU, Linux)
+* Improves T-Head SoC name detection from the device tree (#1997, CPU, Linux)
+* Supports glob patterns in `Disk.hideFolders` (Disk)
+    * For example, `/boot/*` will match both `/boot/efi` and `/boot/firmware`
+* Adds brightness-level detection for external monitor support on Intel macOS (Brightness, macOS)
+* Adds configurable spacing between icon and text in keys
+    * `display.key.type: "both-N"` where N is `0-4`
+    * Useful for non-monospaced Nerd Fonts
+* Adds detection support for modern Samsung Exynos SoCs (CPU, Android)
+* Adds a new CMake option `-DENABLE_WORDEXP=<ON|OFF>` to enable or disable using `wordexp(3)` for acquiring logo file paths (`logo.source`)
+    * Enabled by default for compatibility
+    * Disabling this option reverts to using `glob(3)`, which is less functional but more secure
+
+Bugfixes:
+* Avoids integer overflow when calculating swap size (#1988, Swap, Windows)
+* Trims whitespace from full user name (Title, macOS)
+* Fixes default font size for Ghostty (#1986, TerminalFont, Linux)
+* Works around an issue that could report impossibly high memory usage in rare cases (#1988, Memory, Linux)
+* Fixes incorrect glibc dependency in polyfilled DEB packages (#1983, Linux)
+* Fixes corrupted binaries in polyfilled RPM packages (#1990, Linux)
+* Fixes crashes on ancient Android kernels (#1993, Disk, Android)
+* Fixes incorrect usage of `glob(3)` (OpenBSD)
+* Prefers resolutions reported by RandR mode info, fixing incorrect resolutions on XFCE when DPI scaling is enabled (Display, Linux)
+* Various code cleanups and minor fixes
+
+Logos:
+* Adds secureblue, PrismLinux, EmperorOS and Zraxyl
+* Updates T2
+
+# 2.53.0
+
+Changes:
+* JSON property `length` in `Separator` module has been renamed to `times` for clarity (Separator)
+
+Features:
+* Adds IPv6 type selection (#1459, LocalIP)
+    * For example: `{ "type": "localip", "showIpv6": "ula" /* Show ULA only */ }`
+* Adds more ARM CPU part IDs (CPU, Linux)
+* Improves Ghostty font config parsing with fallback font detection (#1967, TerminalFont)
+* Replaces statx(2) call with syscall(2) for better compatibility (Disk, Linux)
+* Allows array input for disk folder and filesystem options (Disk)
+    * For example: `{ "type": "disk", "folders": ["/", "/home"] }`
+* Adds support for ignoring input devices by name prefix (#1950, Keyboard / Mouse / Gamepad)
+    * For example: `{ "type": "keyboard", "ignores": ["Apple ", "Corsair "] }`
+* Adds support for (B)SSID detection on macOS Tahoe (Wifi, macOS)
+    * Please don't expect it to work on later macOS versions
+* Improves Ubuntu flavor detection (#1975, OS, Linux)
+* Refines ARMv8.4-A detection to require LSE2 (CPU, Windows)
+* Detects the latest Dimensity & Snapdragon SoC names (CPU, Android)
+
+Bugfixes:
+* Handles zero temperature data (#1960, CPU, Windows)
+* Fixes `dlopen libzfs.so failed` error on Proxmox 9 (#1973, Zpool, Linux)
+
+Logos:
+* Removes Starry Linux
+* Adds TempleOS
+* Updates ObsidianOS
+
 # 2.52.0

 Changes:
@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.12.0) # target_link_libraries with OBJECT libs & project homepage url

 project(fastfetch
-    VERSION 2.52.0
+    VERSION 2.62.0
    LANGUAGES C
    DESCRIPTION "Fast neofetch-like system information tool"
    HOMEPAGE_URL "https://github.com/fastfetch-cli/fastfetch"
@@ -9,6 +9,17 @@ project(fastfetch

 set(PROJECT_LICENSE "MIT license")

+if(DEFINED CMAKE_SYSTEM_PROCESSOR_OVERRIDE) # Used by github actions for i686 build
+    set(CMAKE_SYSTEM_PROCESSOR ${CMAKE_SYSTEM_PROCESSOR_OVERRIDE} CACHE INTERNAL "")
+endif()
+string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" CMAKE_SYSTEM_PROCESSOR)
+if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
+    set(CMAKE_SYSTEM_PROCESSOR "amd64")
+elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64")
+    set(CMAKE_SYSTEM_PROCESSOR "aarch64")
+endif()
+message(STATUS "Build for system processor: ${CMAKE_SYSTEM_PROCESSOR}")
+
 ###################
 # Target Platform #
 ###################
@@ -78,11 +89,8 @@ cmake_dependent_option(ENABLE_OPENCL "Enable opencl" ON "LINUX OR FreeBSD OR Ope
 cmake_dependent_option(ENABLE_FREETYPE "Enable freetype" ON "ANDROID" OFF)
 cmake_dependent_option(ENABLE_PULSE "Enable pulse" ON "LINUX OR ANDROID OR GNU" OFF)
 cmake_dependent_option(ENABLE_DDCUTIL "Enable ddcutil" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_DIRECTX_HEADERS "Enable DirectX headers for WSL" ON "LINUX" OFF)
 cmake_dependent_option(ENABLE_ELF "Enable libelf" ON "LINUX OR ANDROID OR DragonFly OR Haiku OR GNU" OFF)
 cmake_dependent_option(ENABLE_THREADS "Enable multithreading" ON "Threads_FOUND" OFF)
-cmake_dependent_option(ENABLE_LIBZFS "Enable libzfs" ON "LINUX OR FreeBSD OR SunOS" OFF)
-cmake_dependent_option(ENABLE_PCIACCESS "Enable libpciaccess" ON "NetBSD OR OpenBSD" OFF)

 option(ENABLE_ZLIB "Enable zlib" ON)
 option(ENABLE_SYSTEM_YYJSON "Use system provided (instead of fastfetch embedded) yyjson library" OFF)
@@ -95,6 +103,14 @@ option(IS_MUSL "Build with musl libc" OFF) # Used by Github Actions
 option(INSTALL_LICENSE "Install license into /usr/share/licenses" ON)
 option(ENABLE_EMBEDDED_PCIIDS "Embed pci.ids into fastfetch, requires `python`" OFF)
 option(ENABLE_EMBEDDED_AMDGPUIDS "Embed amdgpu.ids into fastfetch, requires `python`" OFF)
+option(ENABLE_WORDEXP "Enable using of wordexp(3) if available, instead of glob(3)" ON)
+option(ENABLE_LIBZFS "Enable libzfs" ON)
+if(WIN32 AND NOT CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64")
+    option(ENABLE_WIN81_COMPAT "Enable legacy Windows compatibility (Windows 8.1 and later; Windows 7 unsupported)" ON)
+endif()
+if(APPLE)
+    option(ENABLE_APPLE_MEMSIZE_USABLE "Use usable memory size as total memory size in Memory module, to match other systems" OFF)
+endif()

 set(BINARY_LINK_TYPE_OPTIONS dlopen dynamic static)
 set(BINARY_LINK_TYPE dlopen CACHE STRING "How to link fastfetch")
@@ -103,7 +119,7 @@ if(NOT BINARY_LINK_TYPE IN_LIST BINARY_LINK_TYPE_OPTIONS)
    message(FATAL_ERROR "BINARY_LINK_TYPE must be one of ${BINARY_LINK_TYPE_OPTIONS}")
 endif()

-set(PACKAGE_MANAGERS AM APK BREW CHOCO DPKG EMERGE EOPKG FLATPAK GUIX LINGLONG LPKG LPKGBUILD MACPORTS NIX OPKG PACMAN PACSTALL PALUDIS PISI PKG PKGTOOL RPM SCOOP SNAP SOAR SORCERY WINGET XBPS)
+set(PACKAGE_MANAGERS AM APPIMAGE APK BREW CHOCO DPKG EMERGE EOPKG FLATPAK GUIX LINGLONG LPKG LPKGBUILD MACPORTS NIX OPKG PACMAN PACSTALL PALUDIS PISI PKG PKGTOOL RPM SCOOP SNAP SOAR SORCERY WINGET XBPS)
 foreach(package_manager ${PACKAGE_MANAGERS})
    if(package_manager STREQUAL "WINGET")
        option(PACKAGES_DISABLE_${package_manager} "Disable ${package_manager} package manager detection by default" ON)
@@ -142,14 +158,20 @@ set(WARNING_FLAGS "-Wall -Wextra -Wconversion -Werror=uninitialized -Werror=retu
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS} -Werror=incompatible-pointer-types -Werror=implicit-function-declaration -Werror=int-conversion")

-if(WIN32 OR Haiku OR ENABLE_DIRECTX_HEADERS)
+if(WIN32 OR Haiku)
    enable_language(CXX)
    set(CMAKE_CXX_STANDARD 17)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS}")
 endif()

 if(WIN32)
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--tsaware -Wl,--build-id -Wl,--subsystem,console:6.1,--major-os-version,6,--minor-os-version,1")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--tsaware -Wl,--build-id")
+
+    if(ENABLE_WIN81_COMPAT)
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--subsystem,console,--major-os-version,6,--minor-os-version,3")
+    else()
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--subsystem,console,--major-os-version,10,--minor-os-version,0")
+    endif()
 elseif(APPLE AND CMAKE_C_COMPILER_ID MATCHES "Clang")
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fobjc-arc")
 endif()
@@ -282,7 +304,8 @@ if(ENABLE_EMBEDDED_PCIIDS AND NOT EXISTS "${PROJECT_BINARY_DIR}/fastfetch_pciids
                        RESULT_VARIABLE PYTHON_PCIIDS_RETCODE)
        if(NOT PYTHON_PCIIDS_RETCODE EQUAL 0)
            file(REMOVE "${PROJECT_BINARY_DIR}/fastfetch_pciids.c.inc")
-            message(FATAL_ERROR "Failed to generate 'fastfetch_pciids.c.inc'")
+            message(WARNING "Failed to generate 'fastfetch_pciids.c.inc'")
+            set(ENABLE_EMBEDDED_PCIIDS OFF)
        endif()
    else()
        message(WARNING "Python3 is not found, 'fastfetch_pciids.c.inc' will not be generated")
@@ -302,7 +325,8 @@ if(ENABLE_EMBEDDED_AMDGPUIDS AND NOT EXISTS "${PROJECT_BINARY_DIR}/fastfetch_amd
                        RESULT_VARIABLE PYTHON_AMDGPUIDS_RETCODE)
        if(NOT PYTHON_AMDGPUIDS_RETCODE EQUAL 0)
            file(REMOVE "${PROJECT_BINARY_DIR}/fastfetch_amdgpuids.c.inc")
-            message(FATAL_ERROR "Failed to generate 'fastfetch_amdgpuids.c.inc'")
+            message(WARNING "Failed to generate 'fastfetch_amdgpuids.c.inc'")
+            set(ENABLE_EMBEDDED_AMDGPUIDS OFF)
        endif()
    else()
        message(WARNING "Python3 is not found, 'fastfetch_amdgpuids.c.inc' will not be generated")
@@ -330,7 +354,7 @@ fastfetch_load_text(src/data/structure.txt DATATEXT_STRUCTURE)
 configure_file(src/fastfetch_config.h.in fastfetch_config.h @ONLY)
 configure_file(src/fastfetch_datatext.h.in fastfetch_datatext.h @ONLY)
 if(APPLE)
-    configure_file(src/util/apple/Info.plist.in Info.plist @ONLY)
+    configure_file(src/common/apple/Info.plist.in Info.plist @ONLY)
 endif()

 ####################
@@ -352,37 +376,45 @@ file(GENERATE OUTPUT logo_builtin.h CONTENT "${LOGO_BUILTIN_H}")
 #######################

 set(LIBFASTFETCH_SRC
-    src/common/commandoption.c
-    src/common/duration.c
-    src/common/font.c
-    src/common/format.c
-    src/common/frequency.c
-    src/common/init.c
-    src/common/jsonconfig.c
-    src/common/library.c
-    src/common/modules.c
-    src/common/netif/netif.c
-    src/common/networking/networking_common.c
-    src/common/option.c
-    src/common/parsing.c
-    src/common/percent.c
-    src/common/printing.c
-    src/common/properties.c
-    src/common/settings.c
-    src/common/size.c
-    src/common/temps.c
-    src/common/time.c
+    src/common/impl/commandoption.c
+    src/common/impl/duration.c
+    src/common/impl/font.c
+    src/common/impl/format.c
+    src/common/impl/frequency.c
+    src/common/impl/init.c
+    src/common/impl/jsonconfig.c
+    src/common/impl/library.c
+    src/common/impl/netif.c
+    src/common/impl/networking_common.c
+    src/common/impl/option.c
+    src/common/impl/parsing.c
+    src/common/impl/percent.c
+    src/common/impl/printing.c
+    src/common/impl/properties.c
+    src/common/impl/settings.c
+    src/common/impl/size.c
+    src/common/impl/temps.c
+    src/common/impl/time.c
+    src/common/impl/edidHelper.c
+    src/common/impl/base64.c
+    src/common/impl/FFlist.c
+    src/common/impl/FFstrbuf.c
+    src/common/impl/path.c
+    src/common/impl/FFPlatform.c
+    src/common/impl/smbios.c
    src/detection/bluetoothradio/bluetoothradio.c
    src/detection/bootmgr/bootmgr.c
    src/detection/chassis/chassis.c
    src/detection/cpu/cpu.c
    src/detection/cpuusage/cpuusage.c
+    src/detection/command/command.c
    src/detection/disk/disk.c
    src/detection/diskio/diskio.c
    src/detection/displayserver/displayserver.c
    src/detection/editor/editor.c
    src/detection/font/font.c
    src/detection/gpu/gpu.c
+    src/detection/host/host_mac.c
    src/detection/media/media.c
    src/detection/netio/netio.c
    src/detection/opencl/opencl.c
@@ -397,6 +429,7 @@ set(LIBFASTFETCH_SRC
    src/detection/version/version.c
    src/detection/vulkan/vulkan.c
    src/detection/weather/weather.c
+    src/detection/zpool/zpool.c
    src/logo/builtin.c
    src/logo/image/im6.c
    src/logo/image/im7.c
@@ -438,6 +471,7 @@ set(LIBFASTFETCH_SRC
    src/modules/loadavg/loadavg.c
    src/modules/locale/locale.c
    src/modules/localip/localip.c
+    src/modules/logo/logo.c
    src/modules/memory/memory.c
    src/modules/monitor/monitor.c
    src/modules/netio/netio.c
@@ -475,26 +509,22 @@ set(LIBFASTFETCH_SRC
    src/modules/wm/wm.c
    src/modules/wmtheme/wmtheme.c
    src/modules/zpool/zpool.c
+    src/modules/modules.c
    src/options/display.c
    src/options/logo.c
    src/options/general.c
-    src/util/edidHelper.c
-    src/util/base64.c
-    src/util/FFlist.c
-    src/util/FFstrbuf.c
-    src/util/kmod.c
-    src/util/path.c
-    src/util/platform/FFPlatform.c
-    src/util/smbiosHelper.c
 )

 if(LINUX)
    list(APPEND LIBFASTFETCH_SRC
-        src/common/dbus.c
-        src/common/io/io_unix.c
-        src/common/netif/netif_linux.c
-        src/common/networking/networking_linux.c
-        src/common/processing_linux.c
+        src/common/impl/dbus.c
+        src/common/impl/io_unix.c
+        src/common/impl/netif_linux.c
+        src/common/impl/networking_linux.c
+        src/common/impl/processing_linux.c
+        src/common/impl/FFPlatform_unix.c
+        src/common/impl/binary_linux.c
+        src/common/impl/kmod_linux.c
        src/detection/battery/battery_linux.c
        src/detection/bios/bios_linux.c
        src/detection/board/board_linux.c
@@ -531,9 +561,9 @@ if(LINUX)
        src/detection/gpu/gpu_linux.c
        src/detection/gpu/gpu_drm.c
        src/detection/gpu/gpu_pci.c
+        src/detection/gpu/gpu_windows.c
        src/detection/gtk_qt/gtk.c
        src/detection/host/host_linux.c
-        src/detection/host/host_mac.c
        src/detection/icons/icons_linux.c
        src/detection/initsystem/initsystem_linux.c
        src/detection/keyboard/keyboard_linux.c
@@ -569,17 +599,17 @@ if(LINUX)
        src/detection/de/de_linux.c
        src/detection/wmtheme/wmtheme_linux.c
        src/detection/camera/camera_linux.c
-        src/detection/zpool/zpool_linux.c
-        src/util/platform/FFPlatform_unix.c
-        src/util/binary_linux.c
    )
 elseif(ANDROID)
    list(APPEND LIBFASTFETCH_SRC
-        src/common/dbus.c
-        src/common/io/io_unix.c
-        src/common/netif/netif_linux.c
-        src/common/networking/networking_linux.c
-        src/common/processing_linux.c
+        src/common/impl/dbus.c
+        src/common/impl/io_unix.c
+        src/common/impl/netif_linux.c
+        src/common/impl/networking_linux.c
+        src/common/impl/processing_linux.c
+        src/common/impl/FFPlatform_unix.c
+        src/common/impl/binary_linux.c
+        src/common/impl/kmod_linux.c
        src/detection/battery/battery_android.c
        src/detection/bios/bios_android.c
        src/detection/bluetooth/bluetooth_nosupport.c
@@ -643,18 +673,18 @@ elseif(ANDROID)
        src/detection/de/de_linux.c
        src/detection/wmtheme/wmtheme_linux.c
        src/detection/camera/camera_android.c
-        src/detection/zpool/zpool_nosupport.c
-        src/util/platform/FFPlatform_unix.c
-        src/util/binary_linux.c
    )
 elseif(FreeBSD)
    list(APPEND LIBFASTFETCH_SRC
-        src/common/dbus.c
-        src/common/io/io_unix.c
-        src/common/netif/netif_bsd.c
-        src/common/networking/networking_linux.c
-        src/common/processing_linux.c
-        src/common/sysctl.c
+        src/common/impl/dbus.c
+        src/common/impl/io_unix.c
+        src/common/impl/netif_bsd.c
+        src/common/impl/networking_linux.c
+        src/common/impl/processing_linux.c
+        src/common/impl/sysctl.c
+        src/common/impl/FFPlatform_unix.c
+        src/common/impl/binary_linux.c
+        src/common/impl/kmod_bsd.c
        src/detection/battery/battery_bsd.c
        src/detection/bios/bios_bsd.c
        src/detection/bluetoothradio/bluetoothradio_nosupport.c
@@ -692,7 +722,6 @@ elseif(FreeBSD)
        src/detection/gpu/gpu_pci.c
        src/detection/gtk_qt/gtk.c
        src/detection/host/host_bsd.c
-        src/detection/host/host_mac.c
        src/detection/lm/lm_linux.c
        src/detection/icons/icons_linux.c
        src/detection/initsystem/initsystem_linux.c
@@ -726,9 +755,6 @@ elseif(FreeBSD)
        src/detection/de/de_linux.c
        src/detection/wmtheme/wmtheme_linux.c
        src/detection/camera/camera_linux.c
-        src/detection/zpool/zpool_linux.c
-        src/util/platform/FFPlatform_unix.c
-        src/util/binary_linux.c
    )
    if(DragonFly)
        list(APPEND LIBFASTFETCH_SRC
@@ -743,12 +769,15 @@ elseif(FreeBSD)
    endif()
 elseif(NetBSD)
    list(APPEND LIBFASTFETCH_SRC
-        src/common/dbus.c
-        src/common/io/io_unix.c
-        src/common/netif/netif_bsd.c
-        src/common/networking/networking_linux.c
-        src/common/processing_linux.c
-        src/common/sysctl.c
+        src/common/impl/dbus.c
+        src/common/impl/io_unix.c
+        src/common/impl/netif_bsd.c
+        src/common/impl/networking_linux.c
+        src/common/impl/processing_linux.c
+        src/common/impl/sysctl.c
+        src/common/impl/FFPlatform_unix.c
+        src/common/impl/binary_linux.c
+        src/common/impl/kmod_nbsd.c
        src/detection/battery/battery_nbsd.c
        src/detection/bios/bios_nbsd.c
        src/detection/bluetooth/bluetooth_bsd.c
@@ -764,7 +793,7 @@ elseif(NetBSD)
        src/detection/cursor/cursor_linux.c
        src/detection/disk/disk_bsd.c
        src/detection/dns/dns_linux.c
-        src/detection/physicaldisk/physicaldisk_nosupport.c
+        src/detection/physicaldisk/physicaldisk_nbsd.c
        src/detection/physicalmemory/physicalmemory_linux.c
        src/detection/diskio/diskio_nbsd.c
        src/detection/displayserver/linux/displayserver_linux.c
@@ -782,7 +811,7 @@ elseif(NetBSD)
        src/detection/displayserver/linux/xcb.c
        src/detection/displayserver/linux/xlib.c
        src/detection/font/font_linux.c
-        src/detection/gpu/gpu_general.c
+        src/detection/gpu/gpu_nbsd.c
        src/detection/gpu/gpu_pci.c
        src/detection/gtk_qt/gtk.c
        src/detection/host/host_nbsd.c
@@ -820,18 +849,19 @@ elseif(NetBSD)
        src/detection/de/de_linux.c
        src/detection/wmtheme/wmtheme_linux.c
        src/detection/camera/camera_linux.c
-        src/detection/zpool/zpool_linux.c
-        src/util/platform/FFPlatform_unix.c
-        src/util/binary_linux.c
    )
 elseif(OpenBSD)
    list(APPEND LIBFASTFETCH_SRC
-        src/common/dbus.c
-        src/common/io/io_unix.c
-        src/common/netif/netif_bsd.c
-        src/common/networking/networking_linux.c
-        src/common/processing_linux.c
-        src/common/sysctl.c
+        src/common/impl/dbus.c
+        src/common/impl/io_unix.c
+        src/common/impl/netif_bsd.c
+        src/common/impl/networking_linux.c
+        src/common/impl/processing_linux.c
+        src/common/impl/sysctl.c
+        src/common/impl/FFPlatform_unix.c
+        src/common/impl/binary_linux.c
+        src/common/impl/smbios.c
+        src/common/impl/kmod_nosupport.c
        src/detection/battery/battery_obsd.c
        src/detection/bios/bios_windows.c
        src/detection/bluetooth/bluetooth_nosupport.c
@@ -847,7 +877,7 @@ elseif(OpenBSD)
        src/detection/cursor/cursor_linux.c
        src/detection/disk/disk_bsd.c
        src/detection/dns/dns_linux.c
-        src/detection/physicaldisk/physicaldisk_nosupport.c
+        src/detection/physicaldisk/physicaldisk_obsd.c
        src/detection/physicalmemory/physicalmemory_linux.c
        src/detection/diskio/diskio_obsd.c
        src/detection/displayserver/linux/displayserver_linux.c
@@ -866,7 +896,7 @@ elseif(OpenBSD)
        src/detection/displayserver/linux/xlib.c
        src/detection/font/font_linux.c
        src/detection/gpu/gpu_pci.c
-        src/detection/gpu/gpu_general.c
+        src/detection/gpu/gpu_obsd.c
        src/detection/gtk_qt/gtk.c
        src/detection/host/host_obsd.c
        src/detection/lm/lm_nosupport.c
@@ -903,27 +933,26 @@ elseif(OpenBSD)
        src/detection/de/de_linux.c
        src/detection/wmtheme/wmtheme_linux.c
        src/detection/camera/camera_linux.c
-        src/detection/zpool/zpool_nosupport.c
-        src/util/platform/FFPlatform_unix.c
-        src/util/binary_linux.c
-        src/util/smbiosHelper.c
    )
 elseif(APPLE)
    list(APPEND LIBFASTFETCH_SRC
-        src/common/io/io_unix.c
-        src/common/netif/netif_apple.c
-        src/common/networking/networking_linux.c
-        src/common/processing_linux.c
-        src/common/sysctl.c
+        src/common/impl/io_unix.c
+        src/common/impl/netif_apple.c
+        src/common/impl/networking_linux.c
+        src/common/impl/processing_linux.c
+        src/common/impl/sysctl.c
+        src/common/impl/FFPlatform_unix.c
+        src/common/impl/binary_apple.c
+        src/common/impl/kmod_apple.c
+        src/common/apple/cf_helpers.c
+        src/common/apple/osascript.m
+        src/common/apple/smc_temps.c
        src/detection/battery/battery_apple.c
-        src/detection/bios/bios_apple.c
        src/detection/bluetooth/bluetooth_apple.m
        src/detection/bluetoothradio/bluetoothradio_apple.m
-        src/detection/board/board_apple.c
        src/detection/bootmgr/bootmgr_apple.c
        src/detection/brightness/brightness_apple.c
        src/detection/btrfs/btrfs_nosupport.c
-        src/detection/chassis/chassis_apple.c
        src/detection/cpu/cpu_apple.c
        src/detection/cpucache/cpucache_apple.c
        src/detection/cpuusage/cpuusage_apple.c
@@ -931,14 +960,11 @@ elseif(APPLE)
        src/detection/disk/disk_bsd.c
        src/detection/dns/dns_apple.c
        src/detection/physicaldisk/physicaldisk_apple.c
-        src/detection/physicalmemory/physicalmemory_apple.m
        src/detection/diskio/diskio_apple.c
        src/detection/displayserver/displayserver_apple.c
        src/detection/font/font_apple.m
        src/detection/gpu/gpu_apple.c
        src/detection/gpu/gpu_apple.m
-        src/detection/host/host_apple.c
-        src/detection/host/host_mac.c
        src/detection/icons/icons_nosupport.c
        src/detection/initsystem/initsystem_linux.c
        src/detection/keyboard/keyboard_apple.c
@@ -963,7 +989,7 @@ elseif(APPLE)
        src/detection/terminalfont/terminalfont_apple.m
        src/detection/terminalshell/terminalshell_linux.c
        src/detection/terminalsize/terminalsize_linux.c
-        src/detection/theme/theme_nosupport.c
+        src/detection/theme/theme_apple.c
        src/detection/tpm/tpm_apple.c
        src/detection/uptime/uptime_bsd.c
        src/detection/users/users_linux.c
@@ -973,19 +999,42 @@ elseif(APPLE)
        src/detection/de/de_nosupport.c
        src/detection/wmtheme/wmtheme_apple.m
        src/detection/camera/camera_apple.m
-        src/detection/zpool/zpool_nosupport.c
-        src/util/apple/cf_helpers.c
-        src/util/apple/osascript.m
-        src/util/apple/smc_temps.c
-        src/util/platform/FFPlatform_unix.c
-        src/util/binary_apple.c
    )
+    # CMAKE_SYSTEM_PROCESSOR has been normalized before
+    if(CMAKE_SYSTEM_PROCESSOR STREQUAL "amd64")
+        list(APPEND LIBFASTFETCH_SRC
+            src/detection/bios/bios_windows.c
+            src/detection/board/board_windows.c
+            src/detection/chassis/chassis_windows.c
+            src/detection/host/host_windows.c
+            src/detection/physicalmemory/physicalmemory_linux.c
+        )
+    else()
+        list(APPEND LIBFASTFETCH_SRC
+            src/detection/bios/bios_apple.c
+            src/detection/board/board_apple.c
+            src/detection/chassis/chassis_apple.c
+            src/detection/host/host_apple.c
+            src/detection/physicalmemory/physicalmemory_apple.m
+        )
+    endif()
 elseif(WIN32)
    list(APPEND LIBFASTFETCH_SRC
-        src/common/io/io_windows.c
-        src/common/netif/netif_windows.c
-        src/common/networking/networking_windows.c
-        src/common/processing_windows.c
+        src/common/impl/io_windows.c
+        src/common/impl/netif_windows.c
+        src/common/impl/networking_windows.c
+        src/common/impl/processing_windows.c
+        src/common/impl/FFPlatform_windows.c
+        src/common/impl/binary_windows.c
+        src/common/impl/debug_windows.c
+        src/common/impl/kmod_windows.c
+        src/common/windows/getline.c
+        src/common/windows/com.cpp
+        src/common/windows/registry.c
+        src/common/windows/unicode.c
+        src/common/windows/wmi.cpp
+        src/common/windows/variant.cpp
+        src/common/windows/version.c
        src/detection/battery/battery_windows.c
        src/detection/bios/bios_windows.c
        src/detection/bluetooth/bluetooth_windows.c
@@ -1007,7 +1056,7 @@ elseif(WIN32)
        src/detection/dns/dns_windows.c
        src/detection/font/font_windows.c
        src/detection/gpu/gpu_windows.c
-        src/detection/host/host_mac.c
+        src/detection/gpu/gpu_windows.cpp
        src/detection/host/host_windows.c
        src/detection/icons/icons_windows.c
        src/detection/initsystem/initsystem_nosupport.c
@@ -1033,34 +1082,27 @@ elseif(WIN32)
        src/detection/terminalfont/terminalfont_windows.c
        src/detection/terminalshell/terminalshell_windows.c
        src/detection/terminalsize/terminalsize_windows.c
-        src/detection/theme/theme_nosupport.c
+        src/detection/theme/theme_windows.c
        src/detection/tpm/tpm_windows.c
        src/detection/uptime/uptime_windows.c
        src/detection/users/users_windows.c
        src/detection/wallpaper/wallpaper_windows.c
        src/detection/wifi/wifi_windows.c
-        src/detection/wm/wm_windows.cpp
+        src/detection/wm/wm_windows.c
        src/detection/de/de_nosupport.c
        src/detection/wmtheme/wmtheme_windows.c
        src/detection/camera/camera_windows.cpp
-        src/detection/zpool/zpool_nosupport.c
-        src/util/windows/getline.c
-        src/util/windows/com.cpp
-        src/util/windows/registry.c
-        src/util/windows/unicode.c
-        src/util/windows/wmi.cpp
-        src/util/windows/version.c
-        src/util/platform/FFPlatform_windows.c
-        src/util/binary_windows.c
-        src/util/debug_windows.c
    )
 elseif(SunOS)
    list(APPEND LIBFASTFETCH_SRC
-        src/common/dbus.c
-        src/common/io/io_unix.c
-        src/common/netif/netif_apple.c
-        src/common/networking/networking_linux.c
-        src/common/processing_linux.c
+        src/common/impl/dbus.c
+        src/common/impl/io_unix.c
+        src/common/impl/netif_apple.c
+        src/common/impl/networking_linux.c
+        src/common/impl/processing_linux.c
+        src/common/impl/FFPlatform_unix.c
+        src/common/impl/binary_linux.c
+        src/common/impl/kmod_sunos.c
        src/detection/battery/battery_nosupport.c
        src/detection/bios/bios_windows.c
        src/detection/board/board_windows.c
@@ -1132,17 +1174,18 @@ elseif(SunOS)
        src/detection/de/de_linux.c
        src/detection/wmtheme/wmtheme_linux.c
        src/detection/camera/camera_nosupport.c
-        src/detection/zpool/zpool_linux.c
-        src/util/platform/FFPlatform_unix.c
-        src/util/binary_linux.c
    )
 elseif(Haiku)
    list(APPEND LIBFASTFETCH_SRC
-        src/common/dbus.c
-        src/common/io/io_unix.c
-        src/common/netif/netif_haiku.c
-        src/common/networking/networking_linux.c
-        src/common/processing_linux.c
+        src/common/impl/dbus.c
+        src/common/impl/io_unix.c
+        src/common/impl/netif_haiku.c
+        src/common/impl/networking_linux.c
+        src/common/impl/processing_linux.c
+        src/common/impl/FFPlatform_unix.c
+        src/common/impl/binary_linux.c
+        src/common/impl/kmod_nosupport.c
+        src/common/haiku/version.cpp
        src/detection/battery/battery_haiku.c
        src/detection/bios/bios_windows.c
        src/detection/board/board_windows.c
@@ -1201,18 +1244,17 @@ elseif(Haiku)
        src/detection/de/de_nosupport.c
        src/detection/wmtheme/wmtheme_nosupport.c
        src/detection/camera/camera_nosupport.c
-        src/detection/zpool/zpool_nosupport.c
-        src/util/platform/FFPlatform_unix.c
-        src/util/binary_linux.c
-        src/util/haiku/version.cpp
    )
 elseif(GNU)
    list(APPEND LIBFASTFETCH_SRC
-        src/common/dbus.c
-        src/common/io/io_unix.c
-        src/common/netif/netif_gnu.c
-        src/common/networking/networking_linux.c
-        src/common/processing_linux.c
+        src/common/impl/dbus.c
+        src/common/impl/io_unix.c
+        src/common/impl/netif_gnu.c
+        src/common/impl/networking_linux.c
+        src/common/impl/processing_linux.c
+        src/common/impl/FFPlatform_unix.c
+        src/common/impl/binary_linux.c
+        src/common/impl/kmod_nosupport.c
        src/detection/battery/battery_nosupport.c
        src/detection/bios/bios_nosupport.c
        src/detection/board/board_nosupport.c
@@ -1242,7 +1284,7 @@ elseif(GNU)
        src/detection/displayserver/linux/xcb.c
        src/detection/displayserver/linux/xlib.c
        src/detection/font/font_linux.c
-        src/detection/gpu/gpu_nosupport.c
+        src/detection/gpu/gpu_gnu.c
        src/detection/gpu/gpu_pci.c
        src/detection/gtk_qt/gtk.c
        src/detection/host/host_nosupport.c
@@ -1281,17 +1323,9 @@ elseif(GNU)
        src/detection/de/de_linux.c
        src/detection/wmtheme/wmtheme_linux.c
        src/detection/camera/camera_nosupport.c
-        src/detection/zpool/zpool_nosupport.c
-        src/util/platform/FFPlatform_unix.c
-        src/util/binary_linux.c
   )
 endif()

-if(ENABLE_DIRECTX_HEADERS)
-    message(STATUS "Enabling DirectX headers for WSL")
-    list(APPEND LIBFASTFETCH_SRC src/detection/gpu/gpu_wsl.cpp)
-endif()
-
 # Proprietary GPU driver APIs
 if(LINUX OR FreeBSD OR WIN32)
    list(APPEND LIBFASTFETCH_SRC src/detection/gpu/gpu_nvidia.c)
@@ -1304,14 +1338,15 @@ endif()
 include(CheckFunctionExists)
 check_function_exists(wcwidth HAVE_WCWIDTH)
 if(NOT HAVE_WCWIDTH)
-    list(APPEND LIBFASTFETCH_SRC src/3rdparty/mk_wcwidch/wcwidth.c)
-endif()
-if(LINUX)
-    check_function_exists(statx HAVE_STATX)
+    list(APPEND LIBFASTFETCH_SRC src/common/impl/wcwidth.c)
 endif()
 if(NOT WIN32)
    check_function_exists(pipe2 HAVE_PIPE2)
 endif()
+check_function_exists(memrchr HAVE_MEMRCHR)
+if(NOT HAVE_MEMRCHR)
+    list(APPEND LIBFASTFETCH_SRC src/common/impl/memrchr.c)
+endif()

 if(ENABLE_SYSTEM_YYJSON)
    find_package(yyjson)
@@ -1330,16 +1365,25 @@ add_library(libfastfetch OBJECT
    ${LIBFASTFETCH_SRC}
 )

+include(CheckCSourceCompiles)
+check_c_source_compiles("int main(void){int arr[1];return _Countof(arr);}" COMPILER_SUPPORTS_COUNT_OF)
+if(COMPILER_SUPPORTS_COUNT_OF)
+    message(STATUS "_Countof is supported by the compiler")
+    target_compile_definitions(libfastfetch PUBLIC FF_SUPPORTS_COUNT_OF=1)
+else()
+    message(STATUS "_Countof is NOT supported by the compiler")
+endif()
+
 if(yyjson_FOUND)
-    target_compile_definitions(libfastfetch PUBLIC FF_USE_SYSTEM_YYJSON)
+    target_compile_definitions(libfastfetch PUBLIC FF_USE_SYSTEM_YYJSON=1)
    target_link_libraries(libfastfetch PUBLIC yyjson::yyjson)
    # `target_link_libraries(yyjson::yyjson)` sets rpath implicitly
-else()
-    # Used for dlopen finding dylibs installed by homebrew
-    # `/opt/homebrew/lib` is not on in dlopen search path by default
-    if(APPLE)
-        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-rpath,/opt/homebrew/lib -Wl,-rpath,/usr/local/lib")
-    endif()
+endif()
+
+# Used for dlopen finding dylibs installed by homebrew
+# `/opt/homebrew/lib` is not on in dlopen search path by default
+if(APPLE AND BINARY_LINK_TYPE STREQUAL "dlopen")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-rpath,/opt/homebrew/lib -Wl,-rpath,/usr/local/lib")
 endif()

 if(ANDROID)
@@ -1401,7 +1445,7 @@ elseif(OpenBSD)
 elseif(DragonFly)
    target_compile_definitions(libfastfetch PUBLIC __FreeBSD__)
 elseif(SunOS)
-    target_compile_definitions(libfastfetch PUBLIC _GNU_SOURCE _XOPEN_SOURCE __STDC_WANT_LIB_EXT1__ _FILE_OFFSET_BITS=64 __EXTENSIONS__ _POSIX_C_SOURCE)
+    target_compile_definitions(libfastfetch PUBLIC _GNU_SOURCE __STDC_WANT_LIB_EXT1__ _FILE_OFFSET_BITS=64 __EXTENSIONS__ _POSIX_C_SOURCE)
 elseif(NetBSD)
    target_compile_definitions(libfastfetch PUBLIC _GNU_SOURCE)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-char-subscripts")
@@ -1409,9 +1453,39 @@ elseif(NetBSD)
 elseif(Haiku)
    target_compile_definitions(libfastfetch PUBLIC _GNU_SOURCE)
 elseif(GNU)
-    target_compile_definitions(libfastfetch PUBLIC _GNU_SOURCE)
    # On Hurd PATH_MAX is not defined. Set an arbitrary limit as workaround.
-    target_compile_definitions(libfastfetch PUBLIC PATH_MAX=4096)
+    target_compile_definitions(libfastfetch PUBLIC _GNU_SOURCE PATH_MAX=4096 O_PATH=0)
+endif()
+
+if(APPLE)
+    if(ENABLE_APPLE_MEMSIZE_USABLE)
+        target_compile_definitions(libfastfetch PUBLIC FF_APPLE_MEMSIZE_USABLE=1)
+    else()
+        target_compile_definitions(libfastfetch PUBLIC FF_APPLE_MEMSIZE_USABLE=0)
+    endif()
+endif()
+
+if(WIN32)
+    check_function_exists(_msize HAVE_MSVC_MSIZE)
+    if(HAVE_MSVC_MSIZE)
+        target_compile_definitions(libfastfetch PUBLIC FF_HAVE_MSVC_MSIZE=1)
+    endif()
+
+    if(ENABLE_WIN81_COMPAT)
+        target_compile_definitions(libfastfetch PUBLIC FF_WIN81_COMPAT=1)
+    else()
+        target_compile_definitions(libfastfetch PUBLIC FF_WIN81_COMPAT=0)
+    endif()
+else()
+    check_function_exists(malloc_usable_size HAVE_MALLOC_USABLE_SIZE)
+    if(HAVE_MALLOC_USABLE_SIZE)
+        target_compile_definitions(libfastfetch PUBLIC FF_HAVE_MALLOC_USABLE_SIZE=1)
+    else()
+        check_function_exists(malloc_size HAVE_MALLOC_SIZE)
+        if(HAVE_MALLOC_SIZE)
+            target_compile_definitions(libfastfetch PUBLIC FF_HAVE_MALLOC_SIZE=1)
+        endif()
+    endif()
 endif()

 if(FreeBSD OR OpenBSD OR NetBSD)
@@ -1424,10 +1498,6 @@ if(FreeBSD OR OpenBSD OR NetBSD)
    unset(CMAKE_REQUIRED_DEFINITIONS)
 endif()

-if(HAVE_STATX)
-    target_compile_definitions(libfastfetch PUBLIC FF_HAVE_STATX)
-endif()
-
 if(HAVE_WCWIDTH)
    target_compile_definitions(libfastfetch PUBLIC FF_HAVE_WCWIDTH)
 endif()
@@ -1597,32 +1667,6 @@ ff_lib_enable(ELF
    "libelf"
    "libelf"
 )
-ff_lib_enable(DIRECTX_HEADERS
-    "DirectX-Headers"
-    "DirectX-Headers"
-)
-ff_lib_enable(PCIACCESS
-    "pciaccess"
-    "pciaccess"
-)
-# The system <libzfs.h> is only usable on SunOS. We provide our local copy of it so it's always available.
-if(ENABLE_LIBZFS)
-    if(BINARY_LINK_TYPE STREQUAL "dlopen")
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_LIBZFS=1)
-    else()
-        set(CMAKE_REQUIRED_LIBRARIES_BACKUP ${CMAKE_REQUIRED_LIBRARIES})
-        set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} zfs)
-        check_function_exists("libzfs_init" LIBZFS_FOUND)
-        set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES_BACKUP})
-        if(NOT LIBZFS_FOUND)
-            message(STATUS "Library: missing: LIBZFS")
-        else()
-            message(STATUS "Library: found LIBZFS")
-            target_compile_definitions(libfastfetch PRIVATE FF_HAVE_LIBZFS=1)
-            target_link_libraries(libfastfetch PRIVATE zfs)
-        endif()
-    endif()
-endif()

 if(ENABLE_THREADS)
    target_compile_definitions(libfastfetch PRIVATE FF_HAVE_THREADS=1)
@@ -1637,6 +1681,18 @@ endif()
 if(ENABLE_EMBEDDED_AMDGPUIDS)
    target_compile_definitions(libfastfetch PRIVATE FF_HAVE_EMBEDDED_AMDGPUIDS=1)
 endif()
+if(ENABLE_LIBZFS)
+    target_compile_definitions(libfastfetch PRIVATE FF_HAVE_LIBZFS=1)
+
+    if(NOT BINARY_LINK_TYPE STREQUAL "dlopen")
+        target_link_libraries(libfastfetch
+            PRIVATE "zfs"
+        )
+    endif()
+endif()
+if(NOT HAVE_MEMRCHR)
+    target_compile_definitions(libfastfetch PRIVATE FF_HAVE_CUSTOM_MEMRCHR=1)
+endif()

 if(LINUX)
    target_link_libraries(libfastfetch
@@ -1673,7 +1729,6 @@ elseif(APPLE)
    )
 elseif(WIN32)
    target_link_libraries(libfastfetch
-        PRIVATE "dwmapi"
        PRIVATE "gdi32"
        PRIVATE "iphlpapi"
        PRIVATE "ole32"
@@ -1683,14 +1738,11 @@ elseif(WIN32)
        PRIVATE "version"
        PRIVATE "hid"
        PRIVATE "wtsapi32"
-        PRIVATE "imagehlp"
        PRIVATE "cfgmgr32"
        PRIVATE "winbrand"
-        PRIVATE "propsys"
        PRIVATE "secur32"
    )
-    if(CMAKE_SYSTEM_PROCESSOR STREQUAL "ARM64")
-        # WoA only works on Windows 10 or higher
+    if(NOT ENABLE_WIN81_COMPAT)
        target_link_libraries(libfastfetch
            PRIVATE "mincore"
        )
@@ -1715,12 +1767,14 @@ elseif(OpenBSD)
        PRIVATE "m"
        PRIVATE "kvm"
        PRIVATE "sndio"
+        PRIVATE "util"
    )
 elseif(NetBSD)
    target_link_libraries(libfastfetch
        PRIVATE "bluetooth"
        PRIVATE "m"
        PRIVATE "prop"
+        PRIVATE "util"
    )
 elseif(SunOS)
    target_link_libraries(libfastfetch
@@ -1728,8 +1782,6 @@ elseif(SunOS)
        PRIVATE "socket"
        PRIVATE "kstat"
        PRIVATE "proc"
-        PRIVATE "zfs"
-        PRIVATE "nvpair"
        PRIVATE "devinfo"
    )
 elseif(GNU)
@@ -1740,17 +1792,20 @@ elseif(ANDROID)
    target_link_libraries(libfastfetch
        PRIVATE "m"
    )
-    CHECK_LIBRARY_EXISTS(-l:libandroid-wordexp.a wordexp "" HAVE_LIBANDROID_WORDEXP_STATIC)
-    if(HAVE_LIBANDROID_WORDEXP_STATIC)
-        target_link_libraries(libfastfetch
-            PRIVATE -l:libandroid-wordexp.a
-        )
-    else()
-        CHECK_LIBRARY_EXISTS(android-wordexp wordexp "" HAVE_LIBANDROID_WORDEXP)
-        if(HAVE_LIBANDROID_WORDEXP)
+    if(ENABLE_WORDEXP)
+        # https://github.com/termux/termux-packages/pull/7056
+        CHECK_LIBRARY_EXISTS(-l:libandroid-wordexp.a wordexp "" HAVE_LIBANDROID_WORDEXP_STATIC)
+        if(HAVE_LIBANDROID_WORDEXP_STATIC)
            target_link_libraries(libfastfetch
-                PRIVATE android-wordexp
+                PRIVATE -l:libandroid-wordexp.a
            )
+        else()
+            CHECK_LIBRARY_EXISTS(android-wordexp wordexp "" HAVE_LIBANDROID_WORDEXP)
+            if(HAVE_LIBANDROID_WORDEXP)
+                target_link_libraries(libfastfetch
+                    PRIVATE android-wordexp
+                )
+            endif()
        endif()
    endif()
 elseif(Haiku)
@@ -1812,13 +1867,17 @@ if(NOT WIN32)
    if(HAVE_UTMPX)
        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_UTMPX=1)
    endif()
-    CHECK_INCLUDE_FILE("wordexp.h" HAVE_WORDEXP)
-    if(HAVE_WORDEXP)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_WORDEXP=1)
+    if(ENABLE_WORDEXP)
+        CHECK_INCLUDE_FILE("wordexp.h" HAVE_WORDEXP)
+        if(HAVE_WORDEXP)
+            target_compile_definitions(libfastfetch PRIVATE FF_HAVE_WORDEXP=1)
+            message(STATUS "wordexp.h found, wordexp support enabled")
+        else()
+            set(ENABLE_WORDEXP OFF)
+        endif()
    endif()
-    CHECK_INCLUDE_FILE("glob.h" HAVE_GLOB)
-    if(HAVE_GLOB)
-        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_GLOB=1)
+    if(NOT ENABLE_WORDEXP)
+        message(STATUS "wordexp.h not found or disabled, glob used instead")
    endif()
    if(ENABLE_THREADS AND CMAKE_USE_PTHREADS_INIT)
        CHECK_INCLUDE_FILE("pthread_np.h" HAVE_PTHREAD_NP)
@@ -1873,7 +1932,7 @@ set_target_properties(fastfetch PROPERTIES LINKER_LANGUAGE C)

 if(WIN32)
    target_sources(fastfetch
-        PRIVATE src/util/windows/version.rc
+        PRIVATE src/common/windows/version.rc
    )
 elseif(APPLE)
    target_link_options(fastfetch
@@ -1901,7 +1960,7 @@ if (BUILD_FLASHFETCH)

    if(WIN32)
        target_sources(flashfetch
-            PRIVATE src/util/windows/version.rc
+            PRIVATE src/common/windows/version.rc
        )
    elseif(APPLE)
        target_link_options(flashfetch
@@ -2027,11 +2086,6 @@ install(
 ##################

 set(CPACK_GENERATOR "TGZ;ZIP")
-if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
-    set(CMAKE_SYSTEM_PROCESSOR "amd64")
-elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64")
-    set(CMAKE_SYSTEM_PROCESSOR "aarch64")
-endif()
 if(APPLE)
    string(TOLOWER "${CMAKE_PROJECT_NAME}-macos-${CMAKE_SYSTEM_PROCESSOR}" CPACK_PACKAGE_FILE_NAME) # use macos instead of darwin
 elseif(IS_MUSL)
@@ -2071,14 +2125,14 @@ if(LINUX)
            set(CPACK_RPM_PACKAGE_LICENSE "MIT")
        endif()
    endif()
-elseif(FreeBSD)
+elseif(FreeBSD AND NOT DragonFly)
    set(CPACK_FREEBSD_PACKAGE_LICENSE "MIT")
    set(CPACK_GENERATOR "${CPACK_GENERATOR};FREEBSD")
 endif()

 set(CPACK_SET_DESTDIR ON)

-set(CPACK_PACKAGE_CONTACT "Linus Dierheimer <Linus@Dierheimer.de>")
+set(CPACK_PACKAGE_CONTACT "Carter Li <zhangsongcui@live.cn>")
 set(CPACK_PACKAGE_DESCRIPTION "\
 fastfetch is a neofetch-like tool for fetching system information and displaying them in a pretty way. \
 It is written mostly in C to achieve much better performance.\
@@ -1,7 +1,7 @@
 MIT License

 Copyright (c) 2021-2023 Linus Dierheimer
-Copyright (c) 2022-2025 Carter Li
+Copyright (c) 2022-2026 Carter Li

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -0,0 +1,75 @@
+# Fastfetch
+
+Fastfetch 是一款类似 neofetch 的系统信息展示工具，主要用 C 编写，强调性能和可定制性。支持 Linux、macOS、Windows 7+、Android、FreeBSD、OpenBSD、NetBSD、DragonFly、Haiku、SunOS。
+
+示例配置见 presets/examples，更多截图与平台说明见 Wiki。
+
+## 安装
+
+Linux（部分）：
+- Debian 13+ / Ubuntu: apt install fastfetch
+- Arch: pacman -S fastfetch
+- Fedora: dnf install fastfetch
+- openSUSE: zypper install fastfetch
+- Linuxbrew：brew install fastfetch
+- 各发行版打包状态：https://repology.org/project/fastfetch/versions
+
+macOS：
+- Homebrew：brew install fastfetch
+- MacPorts：sudo port install fastfetch
+
+Windows：
+- scoop install fastfetch
+- choco install fastfetch
+- winget install fastfetch
+- MSYS2：pacman -S mingw-w64-<subsystem>-<arch>-fastfetch
+
+BSD：
+- FreeBSD：pkg install fastfetch
+- NetBSD：pkgin in fastfetch
+- OpenBSD：pkg_add fastfetch
+
+Android（Termux）：
+- pkg install fastfetch
+
+Nightly 构建：
+- https://nightly.link/fastfetch-cli/fastfetch/workflows/ci/dev?preview
+
+## 源码构建
+
+基本上是 `cmake . && make`。详见 Wiki：https://github.com/fastfetch-cli/fastfetch/wiki/Building
+
+## 使用
+
+- 默认运行：`fastfetch`
+- 查看所有可用模块示例：`fastfetch -c all.jsonc`
+- 以 JSON 输出指定模块：`fastfetch -s <module1>[:<module2>] --format json`
+- 完整命令行帮助：`fastfetch --help`
+- 生成最小配置：`fastfetch --gen-config [</path/to/config.jsonc>]`
+  - 生成完整配置：`fastfetch --gen-config-full`
+  - 请使用支持 JSON schema 的编辑器（如 VSCode）编辑配置文件！
+  - 如果你连接 Github 有网络困难（智能提示不生效），可将配置文件中的 `$schema` 的值替换为 `https://gitee.com/carterl/fastfetch/raw/dev/doc/json_schema.json`
+
+## 定制
+
+- 配置使用 JSONC，语法与选项见 Wiki：https://github.com/fastfetch-cli/fastfetch/wiki/Configuration
+- 预设示例位于 presets，可用 `-c <filename>` 加载
+- Logo 选项与图像显示见文档：https://github.com/fastfetch-cli/fastfetch/wiki/Logo-options
+- 模块格式化（示例，仅显示 GPU 名称）：
+```jsonc
+{
+  "modules": [
+    { "type": "gpu", "format": "{name}" }
+  ]
+}
+```
+详见：https://github.com/fastfetch-cli/fastfetch/wiki/Format-String-Guide
+
+## 反馈与支持
+
+- 使用问题：Discussions https://github.com/fastfetch-cli/fastfetch/discussions
+- 疑似缺陷：Issues https://github.com/fastfetch-cli/fastfetch/issues（请填写模版）
+
+## 赞助
+
+<img src="https://github.com/user-attachments/assets/a36a6501-e8b0-4a10-9061-b9206d12ffba" width="220">
@@ -11,8 +11,11 @@
 [![latest packaged version(s)](https://repology.org/badge/latest-versions/fastfetch.svg)](https://repology.org/project/fastfetch/versions)
 [![Packaging status](https://repology.org/badge/tiny-repos/fastfetch.svg)](https://repology.org/project/fastfetch/versions)
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/fastfetch-cli/fastfetch)
+[![中文README](https://img.shields.io/badge/%E4%B8%AD%E6%96%87-README-red)](README-cn.md)

-Fastfetch is a [neofetch](https://github.com/dylanaraps/neofetch)-like tool for fetching system information and displaying it in a visually appealing way. It is written mainly in C, with a focus on performance and customizability. Currently, it supports Linux, macOS, Windows 7+, Android, FreeBSD, OpenBSD, NetBSD, DragonFly, Haiku, and SunOS.
+Fastfetch is a [neofetch](https://github.com/dylanaraps/neofetch)-like tool for fetching system information and displaying it in a visually appealing way. It is written mainly in C, with a focus on performance and customizability. Currently, it supports Linux, macOS, Windows 8.1+, Android, FreeBSD, OpenBSD, NetBSD, DragonFly, Haiku and SunOS (illumos, Solaris).
+
+> Note: Fastfetch is only actively tested on x86-64 and aarch64 platforms. It may work on other platforms but is not guaranteed to do so.

 <img src="screenshots/example1.png" width="49%" align="left" />
 <img src="https://upload.wikimedia.org/wikipedia/commons/2/24/Transparent_Square_Tiles_Texture.png" width="49%" height="16px" align="left" />
@@ -36,7 +39,8 @@ Some distributions package outdated versions of fastfetch. Older versions receiv
    <img src="https://repology.org/badge/vertical-allrepos/fastfetch.svg?columns=2" alt="Packaging status" align="right">
 </a>

-* Debian: `apt install fastfetch` (for Debian 13 or newer)
+* Ubuntu: [`ppa:zhangsongcui3371/fastfetch`](https://launchpad.net/~zhangsongcui3371/+archive/ubuntu/fastfetch) (Ubuntu 22.04 or newer; latest version)
+* Debian / Ubuntu: `apt install fastfetch` (Debian 13 or newer; Ubuntu 25.04 or newer)
 * Debian / Ubuntu: Download `fastfetch-linux-<proper architecture>.deb` from [Github release page](https://github.com/fastfetch-cli/fastfetch/releases/latest) and double-click it (for Ubuntu 20.04 or newer and Debian 11 or newer).
 * Arch Linux: `pacman -S fastfetch`
 * Fedora: `dnf install fastfetch`
@@ -103,6 +107,10 @@ Fastfetch uses JSONC (JSON with comments) for configuration. [See the Wiki for d

 Logos can also be heavily customized; see the [logo documentation](https://github.com/fastfetch-cli/fastfetch/wiki/Logo-options) for more information.

+### WARNING
+
+Fastfetch supports a `Command` module that can run arbitrary shell commands. If you copy-paste a config file from an untrusted source, it may contain malicious commands that can harm your system or compromise your privacy. Please always review the config file before using it.
+
 ## FAQ

 ### Q: Neofetch is good enough. Why do I need fastfetch?
@@ -317,6 +325,11 @@ If you find Fastfetch useful, please consider donating.
 * Current maintainer: [@CarterLi](https://paypal.me/zhangsongcui)
 * Original author: [@LinusDierheimer](https://github.com/sponsors/LinusDierheimer)

+## Code signing
+
+* Free code signing provided by [SignPath.io](https://about.signpath.io/), certificate by [SignPath Foundation](https://signpath.org/)
+* This program will not transfer any information to other networked systems unless specifically requested by the user or the person installing or operating it
+
 ## Star History

 Give us a star to show your support!
@@ -1,3 +1,76 @@
+fastfetch (2.61.0~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Update to 2.61.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Mon, 30 Mar 2026 09:51:18 +0800
+
+fastfetch (2.58.0~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Update to 2.58.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Thu, 22 Jan 2026 15:30:58 +0800
+
+fastfetch (2.57.1~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Update to 2.57.1
+
+ -- Carter Li <zhangsongcui@live.cn>  Wed, 14 Jan 2026 14:00:17 +0800
+
+fastfetch (2.57.0~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Update to 2.57.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Mon, 12 Jan 2026 10:11:21 +0800
+
+fastfetch (2.56.1~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Update to 2.56.1
+
+ -- Carter Li <zhangsongcui@live.cn>  Thu, 18 Dec 2025 14:57:36 +0800
+
+fastfetch (2.56.0~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Update to 2.56.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Mon, 08 Dec 2025 09:21:58 +0800
+
+fastfetch (2.55.1~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Update to 2.55.1
+
+ -- Carter Li <zhangsongcui@live.cn>  Mon, 17 Nov 2025 10:15:44 +0800
+
+fastfetch (2.55.0~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Update to 2.55.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Wed, 12 Nov 2025 09:15:24 +0800
+
+fastfetch (2.54.1~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Fix building on plucky
+
+ -- Carter Li <zhangsongcui@live.cn>  Mon, 20 Oct 2025 14:27:02 +0800
+
+fastfetch (2.54.0~#UBUNTU_CODENAME#) #UBUNTU_CODENAME#; urgency=medium
+
+  * Update to 2.54.0
+  * Test independent changelog entries for different Ubuntu releases
+
+ -- Carter Li <zhangsongcui@live.cn>  Mon, 20 Oct 2025 10:47:02 +0800
+
+fastfetch (2.53.0) jammy; urgency=medium
+
+  * Update to 2.53.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Tue, 23 Sep 2025 09:58:48 +0800
+
+fastfetch (2.52.0) jammy; urgency=medium
+
+  * Update to 2.52.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Fri, 05 Sep 2025 14:59:44 +0800
+
 fastfetch (2.51.0) jammy; urgency=medium

  * Update to 2.51.0
@@ -423,4 +496,3 @@ fastfetch (2.7.1) jammy; urgency=medium
  * Initial release.

 -- Carter Li <zhangsongcui@live.cn>  Tue, 06 Feb 2024 15:01:11 +0800
-
@@ -2,7 +2,7 @@ Source: fastfetch
 Section: universe/utils
 Priority: optional
 Maintainer: Carter Li <zhangsongcui@live.cn>
-Build-Depends: libvulkan-dev, libwayland-dev, libxrandr-dev, libxcb-randr0-dev, libdconf-dev, libdbus-1-dev, libmagickcore-dev, libxfconf-0-dev, libsqlite3-dev, librpm-dev, libegl-dev, libglx-dev, ocl-icd-opencl-dev, libpulse-dev, libdrm-dev, libddcutil-dev, libchafa-dev, directx-headers-dev, pkgconf, cmake (>= 3.12), debhelper (>= 11.2), dh-cmake, dh-cmake-compat (= 1), dh-sequence-cmake, dh-sequence-ctest, ninja-build
+Build-Depends: libelf-dev, libvulkan-dev, libwayland-dev, libxrandr-dev, libxcb-randr0-dev, libdconf-dev, libdbus-1-dev, libmagickcore-dev, libsqlite3-dev, librpm-dev, libegl-dev, libglx-dev, ocl-icd-opencl-dev, libpulse-dev, libdrm-dev, libddcutil-dev, libchafa-dev, pkgconf, cmake (>= 3.12), debhelper (>= 11.2), dh-cmake, dh-cmake-compat (= 1), dh-sequence-cmake, dh-sequence-ctest, ninja-build, python3-setuptools
 Standards-Version: 4.0.0
 Homepage: https://github.com/fastfetch-cli/fastfetch

@@ -1 +0,0 @@
-fastfetch_2.51.0_source.buildinfo universe/utils optional
@@ -1,4 +1,76 @@
 #!/usr/bin/env bash
+# WARNING: DO NOT RUN THIS SCRIPT UNLESS YOU KNOW WHAT YOU ARE DOING.

-debuild -S -i -I
-dput ppa:zhangsongcui3371/fastfetch ~/fastfetch_*.changes
+set -euo pipefail
+
+command -v debuild >/dev/null 2>&1 || { echo "debuild not found. Install devscripts." >&2; exit 1; }
+command -v dput >/dev/null 2>&1 || { echo "dput not found." >&2; exit 1; }
+
+SCRIPT_DIR="$(cd -- "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"
+ROOT_DIR="$(cd -- "$SCRIPT_DIR/.." >/dev/null 2>&1 && pwd)"
+OUT_DIR="$(dirname "$ROOT_DIR")"
+PPA="ppa:zhangsongcui3371/fastfetch"
+CODENAMES=( jammy noble plucky questing resolute )
+DRY_RUN=0
+
+if [[ -d "$OUT_DIR/build" ]]; then
+    echo "Output directory exists: $OUT_DIR/build" >&2
+    echo "Please move or delete it before proceeding." >&2
+    exit 1
+fi
+
+TEMPLATE="$ROOT_DIR/debian/changelog.tpl"
+CHANGELOG_DEBIAN="$ROOT_DIR/debian/changelog"
+
+if [[ ! -f "$TEMPLATE" ]]; then
+  echo "Template not found: $TEMPLATE" >&2
+  exit 1
+fi
+
+if ! grep -q '#UBUNTU_CODENAME#' "$TEMPLATE"; then
+  echo "Template missing placeholder: #UBUNTU_CODENAME#" >&2
+  exit 1
+fi
+
+echo "IMPORTANT: Before proceeding, please ensure that 'debian/changelog.tpl' is up-to-date"
+echo "   with the correct version number, release notes, and maintainer information."
+echo
+echo "   The template must contain a placeholder like '#UBUNTU_CODENAME#' for the codename."
+echo
+read -p "Have you reviewed and updated 'debian/changelog.tpl'? (y/N): " -r
+echo
+if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+    exit 1
+fi
+
+cleanup() {
+    rm -f "$CHANGELOG_DEBIAN"
+    rm -f "$ROOT_DIR/debian/files"
+}
+trap cleanup EXIT
+
+shopt -s nullglob
+
+for codename in "${CODENAMES[@]}"; do
+  echo "==> Publishing distro: $codename"
+  sed "s/#UBUNTU_CODENAME#/${codename}/g" "$TEMPLATE" > "$CHANGELOG_DEBIAN"
+
+  ( cd "$ROOT_DIR" && debuild -S -i -I )
+
+  changes=( "$OUT_DIR"/fastfetch_*~${codename}_source.changes )
+  if [[ ${#changes[@]} -ne 1 ]]; then
+    echo "Unable to uniquely identify .changes for '$codename' in: $OUT_DIR" >&2
+    printf 'Found:\n'; printf '  %s\n' "${changes[@]}" >&2 || true
+    exit 1
+  fi
+
+  if [[ $DRY_RUN -eq 1 ]]; then
+    echo "[DRY-RUN] dput \"$PPA\" \"${changes[0]}\""
+  else
+    dput "$PPA" "${changes[0]}"
+  fi
+
+  rm -f "$OUT_DIR"/fastfetch_*~${codename}_source.{changes,dsc,tar.*}
+
+  echo "<== Done: $codename"
+done
@@ -109,6 +109,7 @@
        },
        "tpm",
        "version",
+        "logo",
        "break",
        "colors"
    ]
@@ -1,4 +1,4 @@
-// Load with --load-config examples/2.jsonc
+// Load with --config examples/2.jsonc
 // Note that you must replace the image path to an existing image to display it.

 {
@@ -1,4 +1,4 @@
-// Load with --load-config examples/2.jsonc
+// Load with --config examples/2.jsonc
 // Note that you must replace the image path to an existing image to display it.

 {
@@ -9,25 +9,26 @@
        // Constants are reusable strings referenced by {$1}, {$2}, etc.
        // These contain ANSI escape codes for cursor positioning
        "constants": [
-            "──────────────────────────────────────────────", // {$1} - horizontal line for borders
+            "──────────────────────────────────────────────", // {$1} - horizontal line for inner borders
            "\u001b[47D",                                     // {$2} - move cursor left 47 columns
            "\u001b[47C",                                     // {$3} - move cursor right 47 columns
-            "\u001b[46C"                                      // {$4} - move cursor right 46 columns
+            "\u001b[46C",                                     // {$4} - move cursor right 46 columns
+            "══════════════════════════════════════════════"  // {$5} - horizontal line for outer borders
        ],
        "brightColor": false
    },
    "modules": [
        {
            "type": "version",
-            "key": "┌───────────────┬─{$1}┐\u001b[41D",
+            "key": "╔═══════════════╦═{$5}╗\u001b[41D",
            "format": "\u001b[1m{#keys} {1} - {2} "
        },
        {
            "type": "os",
            // Key format breakdown for OS module:
-            // "│  {icon}  \u001b[s{sysname}\u001b[u\u001b[10C│{$3}│{$2}"
+            // "║  {icon}  \u001b[s{sysname}\u001b[u\u001b[10C│{$3}║{$2}"
            //
-            // │                    - Left border of key block
+            // ║                    - Left border of key block
            //   {icon}             - OS icon (defined internally by fastfetch)
            //   \u001b[s           - ANSI escape: save cursor position (ESC[s)
            // {sysname}            - Format variable: system name (e.g., "Linux", "Darwin")
@@ -36,28 +37,28 @@
            // \u001b[10C           - ANSI escape: move cursor right 10 columns (ESC[10C)
            // │                    - Right border of key block (always 10 columns from left border)
            // {$3}                 - Reference to constants[2]: move cursor right 47 columns
-            // │                    - Right border of value block
+            // ║                    - Right border of value block
            // {$2}                 - Reference to constants[1]: move cursor left 47 columns
            //
            // This creates a fixed-width layout where the key block is exactly 10 columns wide,
            // regardless of the actual content length. The cursor manipulation ensures proper
            // alignment for the table-like structure.
-            "key": "│  {icon}  \u001b[s{sysname}\u001b[u\u001b[10C│{$3}│{$2}"
+            "key": "║  {icon}  \u001b[s{sysname}\u001b[u\u001b[10C║{$3}║{$2}"
        },
        {
            "type": "datetime",
-            "key": "│  {icon}  Fetched   │{$3}│{$2}",
+            "key": "║  {icon}  Fetched   ║{$3}║{$2}",
            "format": "{year}-{month-pretty}-{day-pretty} {hour-pretty}:{minute-pretty}:{second-pretty} {timezone-name}"
        },
        {
            "type": "locale",
-            "key": "│  {icon}  Locale    │{$3}│{$2}"
+            "key": "║  {icon}  Locale    ║{$3}║{$2}"
        },

        // Hardware section with cyan color theme
        {
            "type": "custom",
-            "key": "│{#cyan}┌──────────────┬{$1}┐{#keys}│\u001b[37D",
+            "key": "║{#cyan}┌──────────────┬{$1}┐{#keys}║\u001b[37D",
            "format": "{#bright_cyan} Hardware "
        },
        {
@@ -66,113 +67,113 @@
            // │{#cyan}│             - Left border with cyan color
            //  {icon}               - Chassis icon
            //  Chassis             - Fixed label text
-            // │{$4}│{#keys}│{$2}    - Positioning and borders for value area
-            "key": "│{#cyan}│ {icon}  Chassis   │{$4}│{#keys}│{$2}"
+            // │{$4}│{#keys}║{$2}    - Positioning and borders for value area
+            "key": "║{#cyan}│ {icon}  Chassis   │{$4}│{#keys}║{$2}"
        },
        {
            "type": "memory",
-            "key": "│{#cyan}│ {icon}  RAM       │{$4}│{#keys}│{$2}"
+            "key": "║{#cyan}│ {icon}  RAM       │{$4}│{#keys}║{$2}"
        },
        {
            "type": "swap",
-            "key": "│{#cyan}│ {icon}  SWAP      │{$4}│{#keys}│{$2}"
+            "key": "║{#cyan}│ {icon}  SWAP      │{$4}│{#keys}║{$2}"
        },
        {
            "type": "cpu",
-            "key": "│{#cyan}│ {icon}  CPU       │{$4}│{#keys}│{$2}",
+            "key": "║{#cyan}│ {icon}  CPU       │{$4}│{#keys}║{$2}",
            "showPeCoreCount": true
        },
        {
            "type": "gpu",
-            "key": "│{#cyan}│ {icon}  GPU       │{$4}│{#keys}│{$2}"
+            "key": "║{#cyan}│ {icon}  GPU       │{$4}│{#keys}║{$2}"
        },
        {
            "type": "disk",
-            "key": "│{#cyan}│ {icon}  Disk      │{$4}│{#keys}│{$2}",
+            "key": "║{#cyan}│ {icon}  Disk      │{$4}│{#keys}║{$2}",
            "format": "{size-used} \/ {size-total} ({size-percentage}) - {filesystem}",
        },
        {
            "type": "battery",
-            "key": "│{#cyan}│ {icon}  Battery   │{$4}│{#keys}│{$2}"
+            "key": "║{#cyan}│ {icon}  Battery   │{$4}│{#keys}║{$2}"
        },
        {
            "type": "custom",
-            "key": "│{#cyan}└──────────────┴{$1}┘{#keys}│",
+            "key": "║{#cyan}└──────────────┴{$1}┘{#keys}║",
            "format": ""
        },

        // Desktop section with green color theme
        {
            "type": "custom",
-            "key": "│{#green}┌──────────────┬{$1}┐{#keys}│\u001b[37D",
+            "key": "║{#green}┌──────────────┬{$1}┐{#keys}║\u001b[37D",
            "format": "{#bright_green} Desktop "
        },
        {
            "type": "de",
-            "key": "│{#green}│ {icon}  Desktop   │{$4}│{#keys}│{$2}"
+            "key": "║{#green}│ {icon}  Desktop   │{$4}│{#keys}║{$2}"
        },
        {
            "type": "wm",
-            "key": "│{#green}│ {icon}  Session   │{$4}│{#keys}│{$2}"
+            "key": "║{#green}│ {icon}  Session   │{$4}│{#keys}║{$2}"
        },
        {
            "type": "display",
-            "key": "│{#green}│ {icon}  Display   │{$4}│{#keys}│{$2}",
+            "key": "║{#green}│ {icon}  Display   │{$4}│{#keys}║{$2}",
            "compactType": "original-with-refresh-rate"
        },
        {
            "type": "gpu",
-            "key": "│{#green}│ {icon}  G-Driver  │{$4}│{#keys}│{$2}",
+            "key": "║{#green}│ {icon}  G-Driver  │{$4}│{#keys}║{$2}",
            "format": "{driver}"
        },
        {
            "type": "custom",
-            "key": "│{#green}└──────────────┴{$1}┘{#keys}│",
+            "key": "║{#green}└──────────────┴{$1}┘{#keys}║",
            "format": ""
        },

        // Terminal section with yellow color theme
        {
            "type": "custom",
-            "key": "│{#yellow}┌──────────────┬{$1}┐{#keys}│\u001b[37D",
+            "key": "║{#yellow}┌──────────────┬{$1}┐{#keys}║\u001b[37D",
            "format": "{#bright_yellow} Terminal "
        },
        {
            "type": "shell",
-            "key": "│{#yellow}│ {icon}  Shell     │{$4}│{#keys}│{$2}"
+            "key": "║{#yellow}│ {icon}  Shell     │{$4}│{#keys}║{$2}"
        },
        {
            "type": "terminal",
-            "key": "│{#yellow}│ {icon}  Terminal  │{$4}│{#keys}│{$2}"
+            "key": "║{#yellow}│ {icon}  Terminal  │{$4}│{#keys}║{$2}"
        },
        {
            "type": "terminalfont",
-            "key": "│{#yellow}│ {icon}  Term Font │{$4}│{#keys}│{$2}"
+            "key": "║{#yellow}│ {icon}  Term Font │{$4}│{#keys}║{$2}"
        },
        {
            "type": "terminaltheme",
-            "key": "│{#yellow}│ {icon}  Colors    │{$4}│{#keys}│{$2}"
+            "key": "║{#yellow}│ {icon}  Colors    │{$4}│{#keys}║{$2}"
        },
        {
            "type": "packages",
-            "key": "│{#yellow}│ {icon}  Packages  │{$4}│{#keys}│{$2}"
+            "key": "║{#yellow}│ {icon}  Packages  │{$4}│{#keys}║{$2}"
        },
        {
            "type": "custom",
-            "key": "│{#yellow}└──────────────┴{$1}┘{#keys}│",
+            "key": "║{#yellow}└──────────────┴{$1}┘{#keys}║",
            "format": ""
        },

        // Development section with red color theme
        {
            "type": "custom",
-            "key": "│{#red}┌──────────────┬{$1}┐{#keys}│\u001b[39D",
+            "key": "║{#red}┌──────────────┬{$1}┐{#keys}║\u001b[39D",
            "format": "{#bright_red} Development "
        },
        {
            "type": "command",
            "keyIcon": "",                                   // Custom icon override
-            "key": "│{#red}│ {icon}  Rust      │{$4}│{#keys}│{$2}",
+            "key": "║{#red}│ {icon}  Rust      │{$4}│{#keys}║{$2}",
            "text": "rustc --version",
            "format": "rustc {~6,13}"                         // Print 6th to 13th characters (version number)
        },
@@ -182,8 +183,8 @@
                "!system": "Windows"                          // Posix version
            },
            "keyIcon": "",
-            "key": "│{#red}│ {icon}  Clang     │{$4}│{#keys}│{$2}",
-            "text": "clang --version | head -1 | awk '{print $NF}'",
+            "key": "║{#red}│ {icon}  Clang     │{$4}│{#keys}║{$2}",
+            "text": "clang --version | sed -n 's/.*version \\([0-9][0-9.]*\\).*/\\1/p'",
            "format": "clang {}"
        },
        {
@@ -192,67 +193,67 @@
                "system": "Windows"                           // Windows version
            },
            "keyIcon": "",
-            "key": "│{#red}│ {icon}  Clang     │{$4}│{#keys}│{$2}",
+            "key": "║{#red}│ {icon}  Clang     │{$4}│{#keys}║{$2}",
            "text": "clang --version | findstr version",      // Finds the line with "version"
            "format": "clang {~-6}"                           // Prints the last 6 characters (version number)
        },
        {
            "type": "command",
            "keyIcon": "",
-            "key": "│{#red}│ {icon}  NodeJS    │{$4}│{#keys}│{$2}",
+            "key": "║{#red}│ {icon}  NodeJS    │{$4}│{#keys}║{$2}",
            "text": "node --version",
            "format": "node {~1}"                             // {~1} removes first character (v)
        },
        {
            "type": "command",
            "keyIcon": "",
-            "key": "│{#red}│ {icon}  Go        │{$4}│{#keys}│{$2}",
+            "key": "║{#red}│ {icon}  Go        │{$4}│{#keys}║{$2}",
            "text": "go version | cut -d' ' -f3",
            "format": "go {~2}"                               // {~2} removes first 2 characters (go)
        },
        {
            "type": "command",
            "keyIcon": "",
-            "key": "│{#red}│ {icon}  Zig       │{$4}│{#keys}│{$2}",
+            "key": "║{#red}│ {icon}  Zig       │{$4}│{#keys}║{$2}",
            "text": "zig version",
            "format": "zig {}"
        },
        {
            "type": "editor",
-            "key": "│{#red}│ {icon}  Editor    │{$4}│{#keys}│{$2}"
+            "key": "║{#red}│ {icon}  Editor    │{$4}│{#keys}║{$2}"
        },
        {
            "type": "command",
            "keyIcon": "󰊢",
-            "key": "│{#red}│ {icon}  Git       │{$4}│{#keys}│{$2}",
+            "key": "║{#red}│ {icon}  Git       │{$4}│{#keys}║{$2}",
            "text": "git version",
            "format": "git {~12}"
        },
        {
            "type": "font",
-            "key": "│{#red}│ {icon}  Interface │{$4}│{#keys}│{$2}"
+            "key": "║{#red}│ {icon}  Interface │{$4}│{#keys}║{$2}"
        },
        {
            "type": "custom",
-            "key": "│{#red}└──────────────┴{$1}┘{#keys}│",
+            "key": "║{#red}└──────────────┴{$1}┘{#keys}║",
            "format": ""
        },

        // Uptime section with magenta color theme
        {
            "type": "custom",
-            "key": "│{#magenta}┌──────────────┬{$1}┐{#keys}│\u001b[36D",
+            "key": "║{#magenta}┌──────────────┬{$1}┐{#keys}║\u001b[36D",
            "format": "{#bright_magenta} Uptime "
        },
        {
            "type": "uptime",
-            "key": "│{#magenta}│ {icon}  Uptime    │{$4}│{#keys}│{$2}"
+            "key": "║{#magenta}│ {icon}  Uptime    │{$4}│{#keys}║{$2}"
        },
        {
            "type": "users",
            "myselfOnly": true,                               // Only show current user
            "keyIcon": "",
-            "key": "│{#magenta}│ {icon}  Login     │{$4}│{#keys}│{$2}"
+            "key": "║{#magenta}│ {icon}  Login     │{$4}│{#keys}║{$2}"
        },
        {
            "condition": {                                    // Conditional module: only show on non-macOS
@@ -260,7 +261,7 @@
            },
            "type": "disk",
            "keyIcon": "",
-            "key": "│{#magenta}│ {icon}  OS Age    │{$4}│{#keys}│{$2}",
+            "key": "║{#magenta}│ {icon}  OS Age    │{$4}│{#keys}║{$2}",
            "folders": "/",                                   // Check root filesystem
            "format": "{create-time:10} [{days} days]"        // Show creation time and age in days
        },
@@ -270,18 +271,18 @@
            },
            "type": "disk",
            "keyIcon": "",
-            "key": "│{#magenta}│ {icon}  OS Age    │{$4}│{#keys}│{$2}",
+            "key": "║{#magenta}│ {icon}  OS Age    │{$4}│{#keys}║{$2}",
            "folders": "/System/Volumes/VM",                 // Work around for APFS on macOS
            "format": "{create-time:10} [{days} days]"
        },
        {
            "type": "custom",
-            "key": "│{#magenta}└──────────────┴{$1}┘{#keys}│",
+            "key": "║{#magenta}└──────────────┴{$1}┘{#keys}║",
            "format": ""
        },
        {
            "type": "custom",
-            "key": "└─────────────────{$1}┘",                // Bottom border of the entire layout
+            "key": "╚═════════════════{$5}╝",                // Bottom border of the entire layout
            "format": ""
        },

@@ -1,6 +1,6 @@
 // #1887
 {
-    "$schema": "file:///Users/carter/fastfetch/doc/json_schema.json",
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
    "logo": null,
    "display": {
        "constants": [
@@ -1,4 +1,4 @@
-// Load with --load-config examples/3.jsonc
+// Load with --config examples/3.jsonc

 {
    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
@@ -0,0 +1,87 @@
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": null,
+    "display": {
+        "key": {
+            "type": "both",
+            "paddingLeft": 6,
+            "width": 17
+        }
+    },
+    "modules": [
+        {
+            "type": "custom",
+            "format": "|---------------------: {#1}Hardware{#} : ---------------------|"
+        },
+        "break",
+        {
+            "keyColor": "green",
+            "type": "host"
+        },
+        {
+            "keyColor": "green",
+            "type": "cpu"
+        },
+        {
+            "keyColor": "yellow",
+            "type": "memory"
+        },
+        {
+            "keyColor": "yellow",
+            "type": "swap"
+        },
+        {
+            "type": "custom",
+            "keyIcon": "",
+            "key": "Disks"
+        },
+        {
+            "type": "disk",
+            "key": " ",
+            "format": "        [{mountpoint}] - {size-used} / {size-total} ({size-percentage})"
+        },
+        "break",
+        {
+            "type": "title",
+            "format": "|-------------------------------------------------------|\u001b[40D: {#1}{user-name} @ {host-name}{#} :"
+        },
+        "break",
+        {
+            "type": "os",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "kernel",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "packages",
+            "keyColor": "red",
+            "key": "Pkgs"
+        },
+        {
+            "type": "shell",
+            "keyColor": "red"
+        },
+        {
+            "type": "terminal",
+            "key": "Term",
+            "keyColor": "red"
+        },
+        {
+            "type": "locale",
+            "keyColor": "magenta"
+        },
+        "break",
+        {
+            "type": "custom",
+            "format": "|---------------------: {#1}Software{#} : ---------------------|"
+        },
+        "break",
+        {
+            "type": "colors",
+            "symbol": "circle",
+            "paddingLeft": 8
+        }
+    ]
+}
@@ -0,0 +1,57 @@
+// Inspired by microfetch
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "type": "small"
+    },
+    "general": {
+        "detectVersion": false
+    },
+    "display": {
+        "separator": "  ",
+        "brightColor": false,
+        "key": {
+            "type": "both-2"
+        }
+    },
+    "modules": [
+        {
+            "type": "title",
+            "format": "{user-name-colored}{#light_red}@{host-name-colored} {#}{cwd}"
+        },
+        {
+            "type": "os",
+            "key": "System       "
+        },
+        {
+            "type": "kernel",
+            "key": "Kernel       "
+        },
+        {
+            "type": "shell",
+            "key": "Shell        "
+        },
+        {
+            "type": "uptime",
+            "key": "Uptime       "
+        },
+        {
+            "type": "wm",
+            "key": "Desktop      "
+        },
+        {
+            "type": "memory",
+            "key": "Memory       "
+        },
+        {
+            "type": "disk",
+            "key": "Storage (/)  ",
+            "folders": "/"
+        },
+        {
+            "type": "colors",
+            "key": "Colors       ",
+            "symbol": "circle"
+        }
+    ]
+}
@@ -1,4 +1,4 @@
-// Load with --load-config examples/4.jsonc
+// Load with --config examples/4.jsonc

 {
    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
@@ -1,4 +1,4 @@
-// Load with --load-config examples/5.jsonc
+// Load with --config examples/5.jsonc

 {
    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
@@ -1,4 +1,4 @@
-// Load with --load-config examples/2.jsonc
+// Load with --config examples/2.jsonc
 // Note that you must replace the image path to an existing image to display it.

 {
@@ -1,4 +1,4 @@
-// Load with --load-config examples/2.jsonc
+// Load with --config examples/2.jsonc
 // Note that you must replace the image path to an existing image to display it.

 {
@@ -6,6 +6,9 @@ def main(amdgpu_ids_path: str):
    with open(amdgpu_ids_path, 'r') as f:
        full_text = f.read()

+    if full_text == '':
+        sys.exit(f'Error: {amdgpu_ids_path} file is empty')
+
    products = []
    for line in full_text.split('\n'):
        if not line or line[0] == '#' or not ',\t' in line:
@@ -18,6 +18,9 @@ def main(keep_vendor_list: set, pci_ids_path: str):
    with open(pci_ids_path, 'r') as f:
        full_text = f.read()

+    if full_text == '':
+        sys.exit(f'Error: {pci_ids_path} file is empty')
+
    dev_list_text = full_text[:full_text.rfind('\n\n\n')]  # remove known classes
    for line in dev_list_text.split('\n'):
        if not line or line[0] == '#':
@@ -1,7 +0,0 @@
-{
-    "home": "https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c",
-    "license": "MIT compatible (embed in source)",
-    "version": "2007-05-26 (Unicode 5.0)",
-    "author": "Markus Kuhn",
-    "modified": "CarterLi"
-}
@@ -1,314 +0,0 @@
-/*
- * This is an implementation of wcwidth() and wcswidth() (defined in
- * IEEE Std 1002.1-2001) for Unicode.
- *
- * http://www.opengroup.org/onlinepubs/007904975/functions/wcwidth.html
- * http://www.opengroup.org/onlinepubs/007904975/functions/wcswidth.html
- *
- * In fixed-width output devices, Latin characters all occupy a single
- * "cell" position of equal width, whereas ideographic CJK characters
- * occupy two such cells. Interoperability between terminal-line
- * applications and (teletype-style) character terminals using the
- * UTF-8 encoding requires agreement on which character should advance
- * the cursor by how many cell positions. No established formal
- * standards exist at present on which Unicode character shall occupy
- * how many cell positions on character terminals. These routines are
- * a first attempt of defining such behavior based on simple rules
- * applied to data provided by the Unicode Consortium.
- *
- * For some graphical characters, the Unicode standard explicitly
- * defines a character-cell width via the definition of the East Asian
- * FullWidth (F), Wide (W), Half-width (H), and Narrow (Na) classes.
- * In all these cases, there is no ambiguity about which width a
- * terminal shall use. For characters in the East Asian Ambiguous (A)
- * class, the width choice depends purely on a preference of backward
- * compatibility with either historic CJK or Western practice.
- * Choosing single-width for these characters is easy to justify as
- * the appropriate long-term solution, as the CJK practice of
- * displaying these characters as double-width comes from historic
- * implementation simplicity (8-bit encoded characters were displayed
- * single-width and 16-bit ones double-width, even for Greek,
- * Cyrillic, etc.) and not any typographic considerations.
- *
- * Much less clear is the choice of width for the Not East Asian
- * (Neutral) class. Existing practice does not dictate a width for any
- * of these characters. It would nevertheless make sense
- * typographically to allocate two character cells to characters such
- * as for instance EM SPACE or VOLUME INTEGRAL, which cannot be
- * represented adequately with a single-width glyph. The following
- * routines at present merely assign a single-cell width to all
- * neutral characters, in the interest of simplicity. This is not
- * entirely satisfactory and should be reconsidered before
- * establishing a formal standard in this area. At the moment, the
- * decision which Not East Asian (Neutral) characters should be
- * represented by double-width glyphs cannot yet be answered by
- * applying a simple rule from the Unicode database content. Setting
- * up a proper standard for the behavior of UTF-8 character terminals
- * will require a careful analysis not only of each Unicode character,
- * but also of each presentation form, something the author of these
- * routines has avoided to do so far.
- *
- * http://www.unicode.org/unicode/reports/tr11/
- *
- * Markus Kuhn -- 2007-05-26 (Unicode 5.0)
- *
- * Permission to use, copy, modify, and distribute this software
- * for any purpose and without fee is hereby granted. The author
- * disclaims all warranties with regard to this software.
- *
- * Latest version: http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
- */
-
-#include <wchar.h>
-
-struct interval {
-  int first;
-  int last;
-};
-
-/* auxiliary function for binary search in interval table */
-static int bisearch(wchar_t ucs, const struct interval *table, int max) {
-  int min = 0;
-  int mid;
-
-  if (ucs < table[0].first || ucs > table[max].last)
-    return 0;
-  while (max >= min) {
-    mid = (min + max) / 2;
-    if (ucs > table[mid].last)
-      min = mid + 1;
-    else if (ucs < table[mid].first)
-      max = mid - 1;
-    else
-      return 1;
-  }
-
-  return 0;
-}
-
-
-/* The following two functions define the column width of an ISO 10646
- * character as follows:
- *
- *    - The null character (U+0000) has a column width of 0.
- *
- *    - Other C0/C1 control characters and DEL will lead to a return
- *      value of -1.
- *
- *    - Non-spacing and enclosing combining characters (general
- *      category code Mn or Me in the Unicode database) have a
- *      column width of 0.
- *
- *    - SOFT HYPHEN (U+00AD) has a column width of 1.
- *
- *    - Other format characters (general category code Cf in the Unicode
- *      database) and ZERO WIDTH SPACE (U+200B) have a column width of 0.
- *
- *    - Hangul Jamo medial vowels and final consonants (U+1160-U+11FF)
- *      have a column width of 0.
- *
- *    - Spacing characters in the East Asian Wide (W) or East Asian
- *      Full-width (F) category as defined in Unicode Technical
- *      Report #11 have a column width of 2.
- *
- *    - All remaining characters (including all printable
- *      ISO 8859-1 and WGL4 characters, Unicode control characters,
- *      etc.) have a column width of 1.
- *
- * This implementation assumes that wchar_t characters are encoded
- * in ISO 10646.
- */
-
-int mk_wcwidth(wchar_t ucs)
-{
-  /* sorted list of non-overlapping intervals of non-spacing characters */
-  /* generated by "uniset +cat=Me +cat=Mn +cat=Cf -00AD +1160-11FF +200B c" */
-  static const struct interval combining[] = {
-    { 0x0300, 0x036F }, { 0x0483, 0x0486 }, { 0x0488, 0x0489 },
-    { 0x0591, 0x05BD }, { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 },
-    { 0x05C4, 0x05C5 }, { 0x05C7, 0x05C7 }, { 0x0600, 0x0603 },
-    { 0x0610, 0x0615 }, { 0x064B, 0x065E }, { 0x0670, 0x0670 },
-    { 0x06D6, 0x06E4 }, { 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED },
-    { 0x070F, 0x070F }, { 0x0711, 0x0711 }, { 0x0730, 0x074A },
-    { 0x07A6, 0x07B0 }, { 0x07EB, 0x07F3 }, { 0x0901, 0x0902 },
-    { 0x093C, 0x093C }, { 0x0941, 0x0948 }, { 0x094D, 0x094D },
-    { 0x0951, 0x0954 }, { 0x0962, 0x0963 }, { 0x0981, 0x0981 },
-    { 0x09BC, 0x09BC }, { 0x09C1, 0x09C4 }, { 0x09CD, 0x09CD },
-    { 0x09E2, 0x09E3 }, { 0x0A01, 0x0A02 }, { 0x0A3C, 0x0A3C },
-    { 0x0A41, 0x0A42 }, { 0x0A47, 0x0A48 }, { 0x0A4B, 0x0A4D },
-    { 0x0A70, 0x0A71 }, { 0x0A81, 0x0A82 }, { 0x0ABC, 0x0ABC },
-    { 0x0AC1, 0x0AC5 }, { 0x0AC7, 0x0AC8 }, { 0x0ACD, 0x0ACD },
-    { 0x0AE2, 0x0AE3 }, { 0x0B01, 0x0B01 }, { 0x0B3C, 0x0B3C },
-    { 0x0B3F, 0x0B3F }, { 0x0B41, 0x0B43 }, { 0x0B4D, 0x0B4D },
-    { 0x0B56, 0x0B56 }, { 0x0B82, 0x0B82 }, { 0x0BC0, 0x0BC0 },
-    { 0x0BCD, 0x0BCD }, { 0x0C3E, 0x0C40 }, { 0x0C46, 0x0C48 },
-    { 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 }, { 0x0CBC, 0x0CBC },
-    { 0x0CBF, 0x0CBF }, { 0x0CC6, 0x0CC6 }, { 0x0CCC, 0x0CCD },
-    { 0x0CE2, 0x0CE3 }, { 0x0D41, 0x0D43 }, { 0x0D4D, 0x0D4D },
-    { 0x0DCA, 0x0DCA }, { 0x0DD2, 0x0DD4 }, { 0x0DD6, 0x0DD6 },
-    { 0x0E31, 0x0E31 }, { 0x0E34, 0x0E3A }, { 0x0E47, 0x0E4E },
-    { 0x0EB1, 0x0EB1 }, { 0x0EB4, 0x0EB9 }, { 0x0EBB, 0x0EBC },
-    { 0x0EC8, 0x0ECD }, { 0x0F18, 0x0F19 }, { 0x0F35, 0x0F35 },
-    { 0x0F37, 0x0F37 }, { 0x0F39, 0x0F39 }, { 0x0F71, 0x0F7E },
-    { 0x0F80, 0x0F84 }, { 0x0F86, 0x0F87 }, { 0x0F90, 0x0F97 },
-    { 0x0F99, 0x0FBC }, { 0x0FC6, 0x0FC6 }, { 0x102D, 0x1030 },
-    { 0x1032, 0x1032 }, { 0x1036, 0x1037 }, { 0x1039, 0x1039 },
-    { 0x1058, 0x1059 }, { 0x1160, 0x11FF }, { 0x135F, 0x135F },
-    { 0x1712, 0x1714 }, { 0x1732, 0x1734 }, { 0x1752, 0x1753 },
-    { 0x1772, 0x1773 }, { 0x17B4, 0x17B5 }, { 0x17B7, 0x17BD },
-    { 0x17C6, 0x17C6 }, { 0x17C9, 0x17D3 }, { 0x17DD, 0x17DD },
-    { 0x180B, 0x180D }, { 0x18A9, 0x18A9 }, { 0x1920, 0x1922 },
-    { 0x1927, 0x1928 }, { 0x1932, 0x1932 }, { 0x1939, 0x193B },
-    { 0x1A17, 0x1A18 }, { 0x1B00, 0x1B03 }, { 0x1B34, 0x1B34 },
-    { 0x1B36, 0x1B3A }, { 0x1B3C, 0x1B3C }, { 0x1B42, 0x1B42 },
-    { 0x1B6B, 0x1B73 }, { 0x1DC0, 0x1DCA }, { 0x1DFE, 0x1DFF },
-    { 0x200B, 0x200F }, { 0x202A, 0x202E }, { 0x2060, 0x2063 },
-    { 0x206A, 0x206F }, { 0x20D0, 0x20EF }, { 0x302A, 0x302F },
-    { 0x3099, 0x309A }, { 0xA806, 0xA806 }, { 0xA80B, 0xA80B },
-    { 0xA825, 0xA826 }, { 0xFB1E, 0xFB1E }, { 0xFE00, 0xFE0F },
-    { 0xFE20, 0xFE23 }, { 0xFEFF, 0xFEFF }, { 0xFFF9, 0xFFFB },
-    { 0x10A01, 0x10A03 }, { 0x10A05, 0x10A06 }, { 0x10A0C, 0x10A0F },
-    { 0x10A38, 0x10A3A }, { 0x10A3F, 0x10A3F }, { 0x1D167, 0x1D169 },
-    { 0x1D173, 0x1D182 }, { 0x1D185, 0x1D18B }, { 0x1D1AA, 0x1D1AD },
-    { 0x1D242, 0x1D244 }, { 0xE0001, 0xE0001 }, { 0xE0020, 0xE007F },
-    { 0xE0100, 0xE01EF }
-  };
-
-  /* test for 8-bit control characters */
-  if (ucs == 0)
-    return 0;
-  if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0))
-    return -1;
-
-  /* binary search in table of non-spacing characters */
-  if (bisearch(ucs, combining,
-	       sizeof(combining) / sizeof(struct interval) - 1))
-    return 0;
-
-  /* if we arrive here, ucs is not a combining or C0/C1 control character */
-
-  return 1 +
-    (ucs >= 0x1100 &&
-     (ucs <= 0x115f ||                    /* Hangul Jamo init. consonants */
-      ucs == 0x2329 || ucs == 0x232a ||
-      (ucs >= 0x2e80 && ucs <= 0xa4cf &&
-       ucs != 0x303f) ||                  /* CJK ... Yi */
-      (ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */
-      (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */
-      (ucs >= 0xfe10 && ucs <= 0xfe19) || /* Vertical forms */
-      (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */
-      (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */
-      (ucs >= 0xffe0 && ucs <= 0xffe6) ||
-
-#ifndef _WIN32 // sizeof(wchar_t) == 2
-      (ucs >= 0x20000 && ucs <= 0x2fffd) ||
-      (ucs >= 0x30000 && ucs <= 0x3fffd) ||
-#endif
-      0
-    ));
-}
-
-
-int mk_wcswidth(const wchar_t *pwcs, size_t n)
-{
-  int w, width = 0;
-
-  for (;*pwcs && n-- > 0; pwcs++)
-    if ((w = mk_wcwidth(*pwcs)) < 0)
-      return -1;
-    else
-      width += w;
-
-  return width;
-}
-
-
-/*
- * The following functions are the same as mk_wcwidth() and
- * mk_wcswidth(), except that spacing characters in the East Asian
- * Ambiguous (A) category as defined in Unicode Technical Report #11
- * have a column width of 2. This variant might be useful for users of
- * CJK legacy encodings who want to migrate to UCS without changing
- * the traditional terminal character-width behaviour. It is not
- * otherwise recommended for general use.
- */
-int mk_wcwidth_cjk(wchar_t ucs)
-{
-  /* sorted list of non-overlapping intervals of East Asian Ambiguous
-   * characters, generated by "uniset +WIDTH-A -cat=Me -cat=Mn -cat=Cf c" */
-  static const struct interval ambiguous[] = {
-    { 0x00A1, 0x00A1 }, { 0x00A4, 0x00A4 }, { 0x00A7, 0x00A8 },
-    { 0x00AA, 0x00AA }, { 0x00AE, 0x00AE }, { 0x00B0, 0x00B4 },
-    { 0x00B6, 0x00BA }, { 0x00BC, 0x00BF }, { 0x00C6, 0x00C6 },
-    { 0x00D0, 0x00D0 }, { 0x00D7, 0x00D8 }, { 0x00DE, 0x00E1 },
-    { 0x00E6, 0x00E6 }, { 0x00E8, 0x00EA }, { 0x00EC, 0x00ED },
-    { 0x00F0, 0x00F0 }, { 0x00F2, 0x00F3 }, { 0x00F7, 0x00FA },
-    { 0x00FC, 0x00FC }, { 0x00FE, 0x00FE }, { 0x0101, 0x0101 },
-    { 0x0111, 0x0111 }, { 0x0113, 0x0113 }, { 0x011B, 0x011B },
-    { 0x0126, 0x0127 }, { 0x012B, 0x012B }, { 0x0131, 0x0133 },
-    { 0x0138, 0x0138 }, { 0x013F, 0x0142 }, { 0x0144, 0x0144 },
-    { 0x0148, 0x014B }, { 0x014D, 0x014D }, { 0x0152, 0x0153 },
-    { 0x0166, 0x0167 }, { 0x016B, 0x016B }, { 0x01CE, 0x01CE },
-    { 0x01D0, 0x01D0 }, { 0x01D2, 0x01D2 }, { 0x01D4, 0x01D4 },
-    { 0x01D6, 0x01D6 }, { 0x01D8, 0x01D8 }, { 0x01DA, 0x01DA },
-    { 0x01DC, 0x01DC }, { 0x0251, 0x0251 }, { 0x0261, 0x0261 },
-    { 0x02C4, 0x02C4 }, { 0x02C7, 0x02C7 }, { 0x02C9, 0x02CB },
-    { 0x02CD, 0x02CD }, { 0x02D0, 0x02D0 }, { 0x02D8, 0x02DB },
-    { 0x02DD, 0x02DD }, { 0x02DF, 0x02DF }, { 0x0391, 0x03A1 },
-    { 0x03A3, 0x03A9 }, { 0x03B1, 0x03C1 }, { 0x03C3, 0x03C9 },
-    { 0x0401, 0x0401 }, { 0x0410, 0x044F }, { 0x0451, 0x0451 },
-    { 0x2010, 0x2010 }, { 0x2013, 0x2016 }, { 0x2018, 0x2019 },
-    { 0x201C, 0x201D }, { 0x2020, 0x2022 }, { 0x2024, 0x2027 },
-    { 0x2030, 0x2030 }, { 0x2032, 0x2033 }, { 0x2035, 0x2035 },
-    { 0x203B, 0x203B }, { 0x203E, 0x203E }, { 0x2074, 0x2074 },
-    { 0x207F, 0x207F }, { 0x2081, 0x2084 }, { 0x20AC, 0x20AC },
-    { 0x2103, 0x2103 }, { 0x2105, 0x2105 }, { 0x2109, 0x2109 },
-    { 0x2113, 0x2113 }, { 0x2116, 0x2116 }, { 0x2121, 0x2122 },
-    { 0x2126, 0x2126 }, { 0x212B, 0x212B }, { 0x2153, 0x2154 },
-    { 0x215B, 0x215E }, { 0x2160, 0x216B }, { 0x2170, 0x2179 },
-    { 0x2190, 0x2199 }, { 0x21B8, 0x21B9 }, { 0x21D2, 0x21D2 },
-    { 0x21D4, 0x21D4 }, { 0x21E7, 0x21E7 }, { 0x2200, 0x2200 },
-    { 0x2202, 0x2203 }, { 0x2207, 0x2208 }, { 0x220B, 0x220B },
-    { 0x220F, 0x220F }, { 0x2211, 0x2211 }, { 0x2215, 0x2215 },
-    { 0x221A, 0x221A }, { 0x221D, 0x2220 }, { 0x2223, 0x2223 },
-    { 0x2225, 0x2225 }, { 0x2227, 0x222C }, { 0x222E, 0x222E },
-    { 0x2234, 0x2237 }, { 0x223C, 0x223D }, { 0x2248, 0x2248 },
-    { 0x224C, 0x224C }, { 0x2252, 0x2252 }, { 0x2260, 0x2261 },
-    { 0x2264, 0x2267 }, { 0x226A, 0x226B }, { 0x226E, 0x226F },
-    { 0x2282, 0x2283 }, { 0x2286, 0x2287 }, { 0x2295, 0x2295 },
-    { 0x2299, 0x2299 }, { 0x22A5, 0x22A5 }, { 0x22BF, 0x22BF },
-    { 0x2312, 0x2312 }, { 0x2460, 0x24E9 }, { 0x24EB, 0x254B },
-    { 0x2550, 0x2573 }, { 0x2580, 0x258F }, { 0x2592, 0x2595 },
-    { 0x25A0, 0x25A1 }, { 0x25A3, 0x25A9 }, { 0x25B2, 0x25B3 },
-    { 0x25B6, 0x25B7 }, { 0x25BC, 0x25BD }, { 0x25C0, 0x25C1 },
-    { 0x25C6, 0x25C8 }, { 0x25CB, 0x25CB }, { 0x25CE, 0x25D1 },
-    { 0x25E2, 0x25E5 }, { 0x25EF, 0x25EF }, { 0x2605, 0x2606 },
-    { 0x2609, 0x2609 }, { 0x260E, 0x260F }, { 0x2614, 0x2615 },
-    { 0x261C, 0x261C }, { 0x261E, 0x261E }, { 0x2640, 0x2640 },
-    { 0x2642, 0x2642 }, { 0x2660, 0x2661 }, { 0x2663, 0x2665 },
-    { 0x2667, 0x266A }, { 0x266C, 0x266D }, { 0x266F, 0x266F },
-    { 0x273D, 0x273D }, { 0x2776, 0x277F }, { 0xE000, 0xF8FF },
-    { 0xFFFD, 0xFFFD }, { 0xF0000, 0xFFFFD }, { 0x100000, 0x10FFFD }
-  };
-
-  /* binary search in table of non-spacing characters */
-  if (bisearch(ucs, ambiguous,
-	       sizeof(ambiguous) / sizeof(struct interval) - 1))
-    return 2;
-
-  return mk_wcwidth(ucs);
-}
-
-
-int mk_wcswidth_cjk(const wchar_t *pwcs, size_t n)
-{
-  int w, width = 0;
-
-  for (;*pwcs && n-- > 0; pwcs++)
-    if ((w = mk_wcwidth_cjk(*pwcs)) < 0)
-      return -1;
-    else
-      width += w;
-
-  return width;
-}
@@ -0,0 +1,6 @@
+{
+    "home": "https://github.com/ridiculousfish/widecharwidth",
+    "license": "Public domain",
+    "version": "Unicode 17",
+    "author": "ridiculousfish"
+}
@@ -1,26 +1,30 @@
 #pragma once

-#include "util/FFstrbuf.h"
-#include "util/FFlist.h"
+#include "common/FFstrbuf.h"
+#include "common/FFlist.h"

-typedef struct FFPlatformSysinfo
-{
+typedef struct FFPlatformSysinfo {
    FFstrbuf name;
    FFstrbuf release;
    FFstrbuf version;
    FFstrbuf architecture;
-    FFstrbuf displayVersion;
    uint32_t pageSize;
 } FFPlatformSysinfo;

-typedef struct FFPlatform
-{
+typedef struct FFPlatform {
    FFstrbuf homeDir;  // Trailing slash included
    FFstrbuf cacheDir; // Trailing slash included
    FFlist configDirs; // List of FFstrbuf, trailing slash included
    FFlist dataDirs;   // List of FFstrbuf, trailing slash included
-    FFstrbuf exePath; // The real path of current exe
+    FFstrbuf exePath;  // The real path of current exe (empty if unavailable)
+    FFstrbuf cwd;      // Trailing slash included

+    uint32_t pid;
+#ifndef _WIN32
+    uint32_t uid;
+#else
+    FFstrbuf sid;
+#endif
    FFstrbuf userName;
    FFstrbuf fullUserName;
    FFstrbuf hostName;
@@ -0,0 +1,141 @@
+#pragma once
+
+#include "common/attributes.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <assert.h>
+#include <stdlib.h>
+
+#define FF_LIST_DEFAULT_ALLOC 16
+
+typedef struct FFlist {
+    uint8_t* data;
+    uint32_t length;
+    uint32_t capacity;
+} FFlist;
+
+void* ffListAdd(FFlist* list, uint32_t elementSize);
+
+// Removes the first element, and copy its value to `*result`
+bool ffListShift(FFlist* list, uint32_t elementSize, void* result);
+// Removes the last element, and copy its value to `*result`
+bool ffListPop(FFlist* list, uint32_t elementSize, void* result);
+
+static inline void ffListInit(FFlist* list) {
+    list->capacity = 0;
+    list->length = 0;
+    list->data = NULL;
+}
+
+static inline void ffListInitA(FFlist* list, uint32_t elementSize, uint32_t capacity) {
+    ffListInit(list);
+    list->capacity = capacity;
+    list->data = __builtin_expect(capacity == 0, 0) ? NULL : (uint8_t*) malloc((size_t) capacity * elementSize);
+}
+
+FF_A_NODISCARD static inline FFlist ffListCreate() {
+    FFlist result;
+    ffListInit(&result);
+    return result;
+}
+
+FF_A_NODISCARD static inline FFlist ffListCreateA(uint32_t elementSize, uint32_t capacity) {
+    FFlist result;
+    ffListInitA(&result, elementSize, capacity);
+    return result;
+}
+
+FF_A_NODISCARD static inline void* ffListGet(const FFlist* list, uint32_t elementSize, uint32_t index) {
+    assert(list->capacity > index);
+    return list->data + (index * elementSize);
+}
+
+FF_A_NODISCARD static inline uint32_t ffListFirstIndexComp(const FFlist* list, uint32_t elementSize, void* compElement, bool (*compFunc)(const void*, const void*)) {
+    for (uint32_t i = 0; i < list->length; i++) {
+        if (compFunc(ffListGet(list, elementSize, i), compElement)) {
+            return i;
+        }
+    }
+
+    return list->length;
+}
+
+FF_A_NODISCARD static inline bool ffListContains(const FFlist* list, uint32_t elementSize, void* compElement, bool (*compFunc)(const void*, const void*)) {
+    return ffListFirstIndexComp(list, elementSize, compElement, compFunc) != list->length;
+}
+
+static inline void ffListSort(FFlist* list, uint32_t elementSize, int (*compar)(const void*, const void*)) {
+    qsort(list->data, list->length, elementSize, compar);
+}
+
+// Move the contents of `src` into `list`, and left `src` empty
+static inline void ffListInitMove(FFlist* list, FFlist* src) {
+    if (src) {
+        list->capacity = src->capacity;
+        list->length = src->length;
+        list->data = src->data;
+        ffListInit(src);
+    } else {
+        ffListInit(list);
+    }
+}
+
+static inline void ffListDestroy(FFlist* list) {
+    if (!list->data) {
+        return;
+    }
+
+    // Avoid free-after-use. These 3 assignments are cheap so don't remove them
+    list->capacity = list->length = 0;
+    free(list->data);
+    list->data = NULL;
+}
+
+static inline void ffListClear(FFlist* list) {
+    list->length = 0;
+}
+
+static inline void ffListReserve(FFlist* list, uint32_t elementSize, uint32_t newCapacity) {
+    if (__builtin_expect(newCapacity <= list->capacity, false)) {
+        return;
+    }
+
+    list->data = (uint8_t*) realloc(list->data, (size_t) newCapacity * elementSize);
+    list->capacity = newCapacity;
+}
+
+#define FF_LIST_FOR_EACH(itemType, itemVarName, listVar)                        \
+    for (itemType* itemVarName = (itemType*) (listVar).data;                    \
+        itemVarName - (itemType*) (listVar).data < (intptr_t) (listVar).length; \
+        ++itemVarName)
+
+#define FF_LIST_AUTO_DESTROY FFlist FF_A_CLEANUP(ffListDestroy)
+
+#define FF_LIST_GET(itemType, listVar, index) \
+    ({                                        \
+        assert((listVar).capacity > (index)); \
+        (itemType*) (listVar).data + (index); \
+    })
+
+#define FF_LIST_ADD(itemType, listVar) (itemType*) ffListAdd(&(listVar), (uint32_t) sizeof(itemType))
+
+#define FF_LIST_FIRST(itemType, listVar) FF_LIST_GET(itemType, listVar, 0)
+#define FF_LIST_LAST(itemType, listVar)                         \
+    ({                                                          \
+        assert((listVar).length > 0);                           \
+        FF_LIST_GET(itemType, listVar, ((listVar).length - 1)); \
+    })
+
+#define FF_LIST_CONTAINS(listVar, pCompElement, compFunc)                                                                              \
+    ({                                                                                                                                 \
+        typedef __typeof__(*(pCompElement)) compElementType;                                                                           \
+        typedef bool compFuncType(const compElementType*, const compElementType*);                                                     \
+        static_assert(__builtin_types_compatible_p(__typeof__(compFunc), compFuncType), "Incompatible callback function");             \
+        ffListContains(&(listVar), (uint32_t) sizeof(*(pCompElement)), (pCompElement), (bool (*)(const void*, const void*)) compFunc); \
+    })
+
+#define FF_LIST_SHIFT(listVar, pResult) \
+    ffListShift(&(listVar), (uint32_t) sizeof(*(pResult)), (pResult))
+#define FF_LIST_POP(listVar, pResult) \
+    ffListPop(&(listVar), (uint32_t) sizeof(*(pResult)), (pResult))
@@ -0,0 +1,567 @@
+#pragma once
+
+#include "common/attributes.h"
+
+#include <stdint.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#ifdef FF_USE_SYSTEM_YYJSON
+    #include <yyjson.h>
+#else
+    #include "3rdparty/yyjson/yyjson.h"
+#endif
+
+#ifdef _WIN32
+// #include <shlwapi.h>
+__stdcall char* StrStrIA(const char* lpFirst, const char* lpSrch);
+    #define strcasestr StrStrIA
+#endif
+
+#define FASTFETCH_STRBUF_DEFAULT_ALLOC 32
+
+// static string (allocated == 0), chars points to a string literal
+// dynamic string (allocated > 0), chars points to a heap allocated buffer
+typedef struct FFstrbuf {
+    uint32_t allocated;
+    uint32_t length;
+    char* chars;
+} FFstrbuf;
+
+static inline void ffStrbufInit(FFstrbuf* strbuf);
+void ffStrbufInitA(FFstrbuf* strbuf, uint32_t allocate);
+void ffStrbufInitVF(FFstrbuf* strbuf, const char* format, va_list arguments);
+void ffStrbufInitMoveNS(FFstrbuf* strbuf, uint32_t length, char* heapStr);
+
+void ffStrbufEnsureFree(FFstrbuf* strbuf, uint32_t free);
+void ffStrbufEnsureFixedLengthFree(FFstrbuf* strbuf, uint32_t free);
+
+void ffStrbufClear(FFstrbuf* strbuf);
+
+static inline void ffStrbufAppend(FFstrbuf* __restrict strbuf, const FFstrbuf* __restrict value);
+void ffStrbufAppendC(FFstrbuf* strbuf, char c);
+void ffStrbufAppendNC(FFstrbuf* strbuf, uint32_t num, char c);
+void ffStrbufAppendNS(FFstrbuf* strbuf, uint32_t length, const char* value);
+void ffStrbufAppendTransformS(FFstrbuf* strbuf, const char* value, int (*transformFunc)(int));
+FF_A_PRINTF(2, 3) void ffStrbufAppendF(FFstrbuf* strbuf, const char* format, ...);
+void ffStrbufAppendVF(FFstrbuf* strbuf, const char* format, va_list arguments);
+const char* ffStrbufAppendSUntilC(FFstrbuf* strbuf, const char* value, char until);
+
+void ffStrbufPrependNS(FFstrbuf* strbuf, uint32_t length, const char* value);
+void ffStrbufPrependC(FFstrbuf* strbuf, char c);
+
+void ffStrbufInsertNC(FFstrbuf* strbuf, uint32_t index, uint32_t num, char c);
+
+// Clear the content of strbuf and set new value
+// NOTE: Unlike ffStrbufAppend*, ffStrbufSet* functions may NOT reserve extra space
+void ffStrbufSet(FFstrbuf* strbuf, const FFstrbuf* value);
+void ffStrbufSetNS(FFstrbuf* strbuf, uint32_t length, const char* value);
+FF_A_PRINTF(2, 3) void ffStrbufSetF(FFstrbuf* strbuf, const char* format, ...);
+
+void ffStrbufTrimLeft(FFstrbuf* strbuf, char c);
+void ffStrbufTrimRight(FFstrbuf* strbuf, char c);
+void ffStrbufTrimLeftSpace(FFstrbuf* strbuf);
+void ffStrbufTrimRightSpace(FFstrbuf* strbuf);
+
+bool ffStrbufRemoveSubstr(FFstrbuf* strbuf, uint32_t startIndex, uint32_t endIndex);
+void ffStrbufRemoveS(FFstrbuf* strbuf, const char* str);
+void ffStrbufRemoveStrings(FFstrbuf* strbuf, uint32_t numStrings, const char* strings[]);
+
+FF_A_NODISCARD uint32_t ffStrbufNextIndexC(const FFstrbuf* strbuf, uint32_t start, char c);
+FF_A_NODISCARD uint32_t ffStrbufNextIndexS(const FFstrbuf* strbuf, uint32_t start, const char* str);
+
+FF_A_NODISCARD uint32_t ffStrbufPreviousIndexC(const FFstrbuf* strbuf, uint32_t start, char c);
+
+void ffStrbufReplaceAllC(FFstrbuf* strbuf, char find, char replace);
+
+// Returns true if the strbuf is modified
+bool ffStrbufSubstrBefore(FFstrbuf* strbuf, uint32_t index);
+bool ffStrbufSubstrAfter(FFstrbuf* strbuf, uint32_t index); // Not including the index
+bool ffStrbufSubstrAfterFirstC(FFstrbuf* strbuf, char c);
+bool ffStrbufSubstrAfterFirstS(FFstrbuf* strbuf, const char* str);
+bool ffStrbufSubstrAfterLastC(FFstrbuf* strbuf, char c);
+bool ffStrbufSubstr(FFstrbuf* strbuf, uint32_t start, uint32_t end);
+
+FF_A_NODISCARD uint32_t ffStrbufCountC(const FFstrbuf* strbuf, char c);
+
+bool ffStrbufRemoveIgnCaseEndS(FFstrbuf* strbuf, const char* end);
+
+bool ffStrbufEnsureEndsWithC(FFstrbuf* strbuf, char c);
+
+void ffStrbufWriteTo(const FFstrbuf* strbuf, FILE* file);
+void ffStrbufPutTo(const FFstrbuf* strbuf, FILE* file);
+
+FF_A_NODISCARD double ffStrbufToDouble(const FFstrbuf* strbuf, double defaultValue);
+FF_A_NODISCARD int64_t ffStrbufToSInt(const FFstrbuf* strbuf, int64_t defaultValue);
+FF_A_NODISCARD uint64_t ffStrbufToUInt(const FFstrbuf* strbuf, uint64_t defaultValue);
+
+void ffStrbufUpperCase(FFstrbuf* strbuf);
+void ffStrbufLowerCase(FFstrbuf* strbuf);
+
+// Function alters the buffer to extract lines or delimited segments (replaces the delimiter with '\0')
+// so that buffer MUST be heap allocated (NOT a static string)
+// `lineptr` must be `NULL` and `n` MUST be `0` for the first call
+// Caller MUST NOT free `*lineptr`
+bool ffStrbufGetdelim(char** lineptr, size_t* n, char delimiter, FFstrbuf* buffer);
+void ffStrbufGetdelimRestore(char** lineptr, size_t* n, char delimiter, FFstrbuf* buffer);
+
+/**
+ * @brief Read a line from a FFstrbuf.
+ *
+ * @details Behaves like getline(3) but reads from a FFstrbuf.
+ *
+ * @param[in,out] lineptr The pointer to a pointer that will be set to the start of the line
+                          (points to buffer's internal memory address to avoid memory allocation and copy).
+                          MUST NOT be freed by the caller, unlike `getline(3)`.
+ *                        MUST be NULL for the first call.
+ * @param[in,out] n The pointer to the size of the buffer of lineptr.
+                    MUST be 0 for the first call.
+ * @param[in] buffer The buffer to read from.
+                     MUST be heap allocated (NOT a static string).
+ *
+ * @return true if a line has been read, false if the end of the buffer has been reached.
+ */
+static inline bool ffStrbufGetline(char** lineptr, size_t* n, FFstrbuf* buffer) {
+    return ffStrbufGetdelim(lineptr, n, '\n', buffer);
+}
+/**
+ * @brief Restore the end of a line that was modified by ffStrbufGetline.
+ * @warning This function should be called before breaking an ffStrbufGetline loop if `buffer` will be used later.
+ */
+static inline void ffStrbufGetlineRestore(char** lineptr, size_t* n, FFstrbuf* buffer) {
+    ffStrbufGetdelimRestore(lineptr, n, '\n', buffer);
+}
+bool ffStrbufRemoveDupWhitespaces(FFstrbuf* strbuf);
+bool ffStrbufMatchSeparatedNS(const FFstrbuf* strbuf, uint32_t compLength, const char* comp, char separator);
+bool ffStrbufMatchSeparatedIgnCaseNS(const FFstrbuf* strbuf, uint32_t compLength, const char* comp, char separator);
+bool ffStrbufSeparatedContainNS(const FFstrbuf* strbuf, uint32_t compLength, const char* comp, char separator);
+bool ffStrbufSeparatedContainIgnCaseNS(const FFstrbuf* strbuf, uint32_t compLength, const char* comp, char separator);
+
+int ffStrbufAppendUtf32CodePoint(FFstrbuf* strbuf, uint32_t codepoint);
+
+void ffStrbufAppendSInt(FFstrbuf* strbuf, int64_t value);
+void ffStrbufAppendUInt(FFstrbuf* strbuf, uint64_t value);
+// Appends a double value to the string buffer with the specified precision (0~15).
+// if `precision < 0`, let yyjson decide the precision
+void ffStrbufAppendDouble(FFstrbuf* strbuf, double value, int8_t precision, bool trailingZeros);
+
+FF_A_NODISCARD static inline FFstrbuf ffStrbufCreateA(uint32_t allocate) {
+    FFstrbuf strbuf;
+    ffStrbufInitA(&strbuf, allocate);
+    return strbuf;
+}
+
+static inline void ffStrbufInitCopy(FFstrbuf* __restrict strbuf, const FFstrbuf* __restrict src) {
+    if (src->allocated == 0) { // static string
+        *strbuf = *src;
+    } else {
+        ffStrbufInitA(strbuf, src->allocated);
+        ffStrbufAppend(strbuf, src);
+    }
+}
+
+FF_A_NODISCARD static inline FFstrbuf ffStrbufCreateCopy(const FFstrbuf* src) {
+    FFstrbuf strbuf;
+    ffStrbufInitCopy(&strbuf, src);
+    return strbuf;
+}
+
+// Move the content of `src` into `strbuf`, and left `src` empty
+static inline void ffStrbufInitMove(FFstrbuf* strbuf, FFstrbuf* src) {
+    if (src) {
+        *strbuf = *src;
+        ffStrbufInit(src);
+    } else {
+        ffStrbufInit(strbuf);
+    }
+}
+
+FF_A_NODISCARD static inline FFstrbuf ffStrbufCreateMove(FFstrbuf* src) {
+    FFstrbuf strbuf;
+    ffStrbufInitMove(&strbuf, src);
+    return strbuf;
+}
+
+FF_A_NODISCARD static inline FFstrbuf ffStrbufCreateVF(const char* format, va_list arguments) {
+    FFstrbuf strbuf;
+    ffStrbufInitVF(&strbuf, format, arguments);
+    return strbuf;
+}
+
+FF_A_PRINTF(2, 3) static inline void ffStrbufInitF(FFstrbuf* strbuf, const char* format, ...) {
+    va_list arguments;
+    va_start(arguments, format);
+    ffStrbufInitVF(strbuf, format, arguments);
+    va_end(arguments);
+}
+
+FF_A_PRINTF(1, 2) FF_A_NODISCARD static inline FFstrbuf
+ffStrbufCreateF(const char* format, ...) {
+    FFstrbuf strbuf;
+
+    va_list arguments;
+    va_start(arguments, format);
+    ffStrbufInitVF(&strbuf, format, arguments);
+    va_end(arguments);
+
+    return strbuf;
+}
+
+static inline void ffStrbufInitMoveS(FFstrbuf* strbuf, char* heapStr) {
+    ffStrbufInitMoveNS(strbuf, (uint32_t) strlen(heapStr), heapStr);
+}
+
+// Despite the name, this function resets strbuf to the initial/unallocated state
+static inline void ffStrbufDestroy(FFstrbuf* strbuf) {
+    if (strbuf->allocated > 0) {
+        free(strbuf->chars);
+    }
+
+    ffStrbufInit(strbuf);
+}
+
+FF_A_NODISCARD static inline uint32_t ffStrbufGetFree(const FFstrbuf* strbuf) {
+    assert(strbuf != NULL);
+    if (strbuf->allocated == 0) {
+        return 0;
+    }
+
+    return strbuf->allocated - strbuf->length - 1; // - 1 for the null byte
+}
+
+static inline void ffStrbufRecalculateLength(FFstrbuf* strbuf) {
+    strbuf->length = (uint32_t) strlen(strbuf->chars);
+}
+
+static inline void ffStrbufSetS(FFstrbuf* strbuf, const char* value) {
+    assert(strbuf != NULL);
+
+    if (value == NULL) {
+        ffStrbufClear(strbuf);
+    } else {
+        ffStrbufSetNS(strbuf, (uint32_t) strlen(value), value);
+    }
+}
+
+static inline bool ffStrbufSetJsonVal(FFstrbuf* strbuf, yyjson_val* jsonVal) {
+    assert(strbuf != NULL);
+
+    if (yyjson_is_str(jsonVal)) {
+        ffStrbufSetNS(strbuf, (uint32_t) unsafe_yyjson_get_len(jsonVal), unsafe_yyjson_get_str(jsonVal));
+        return true;
+    }
+
+    ffStrbufClear(strbuf);
+    return false;
+}
+
+static inline void ffStrbufAppendS(FFstrbuf* strbuf, const char* value) {
+    if (value == NULL) {
+        return;
+    }
+    ffStrbufAppendNS(strbuf, (uint32_t) strlen(value), value);
+}
+
+static inline bool ffStrbufAppendJsonVal(FFstrbuf* strbuf, yyjson_val* jsonVal) {
+    if (yyjson_is_str(jsonVal)) {
+        ffStrbufAppendNS(strbuf, (uint32_t) unsafe_yyjson_get_len(jsonVal), unsafe_yyjson_get_str(jsonVal));
+        return true;
+    }
+    return false;
+}
+
+static inline void ffStrbufInit(FFstrbuf* strbuf) {
+    extern char* CHAR_NULL_PTR;
+    strbuf->allocated = strbuf->length = 0;
+    strbuf->chars = CHAR_NULL_PTR;
+}
+
+FF_A_NODISCARD static inline FFstrbuf ffStrbufCreate(void) {
+    FFstrbuf strbuf;
+    ffStrbufInit(&strbuf);
+    return strbuf;
+}
+
+static inline void ffStrbufInitStatic(FFstrbuf* strbuf, const char* str) {
+    ffStrbufInit(strbuf);
+    if (!str) {
+        return;
+    }
+
+    strbuf->allocated = 0;
+    strbuf->length = (uint32_t) strlen(str);
+    strbuf->chars = (char*) str;
+}
+
+FF_A_NODISCARD static inline FFstrbuf ffStrbufCreateStatic(const char* str) {
+    FFstrbuf strbuf;
+    ffStrbufInitStatic(&strbuf, str);
+    return strbuf;
+}
+
+static inline void ffStrbufSetStatic(FFstrbuf* strbuf, const char* value) {
+    if (strbuf->allocated > 0) {
+        free(strbuf->chars);
+    }
+
+    if (value != NULL) {
+        ffStrbufInitStatic(strbuf, value);
+    } else {
+        ffStrbufInit(strbuf);
+    }
+}
+
+static inline void ffStrbufInitNS(FFstrbuf* strbuf, uint32_t length, const char* str) {
+    ffStrbufInit(strbuf);
+    ffStrbufAppendNS(strbuf, length, str);
+}
+
+FF_A_NODISCARD static inline FFstrbuf ffStrbufCreateNS(uint32_t length, const char* str) {
+    FFstrbuf strbuf;
+    ffStrbufInitNS(&strbuf, length, str);
+    return strbuf;
+}
+
+static inline bool ffStrbufInitJsonVal(FFstrbuf* strbuf, yyjson_val* jsonVal) {
+    ffStrbufInit(strbuf);
+    return ffStrbufAppendJsonVal(strbuf, jsonVal);
+}
+
+static inline void ffStrbufInitS(FFstrbuf* strbuf, const char* str) {
+    ffStrbufInit(strbuf);
+    ffStrbufAppendS(strbuf, str);
+}
+
+FF_A_NODISCARD static inline FFstrbuf ffStrbufCreateS(const char* str) {
+    FFstrbuf strbuf;
+    ffStrbufInitS(&strbuf, str);
+    return strbuf;
+}
+
+static inline void ffStrbufAppend(FFstrbuf* __restrict strbuf, const FFstrbuf* __restrict value) {
+    assert(value != strbuf);
+    if (value == NULL) {
+        return;
+    }
+    ffStrbufAppendNS(strbuf, value->length, value->chars);
+}
+
+static inline void ffStrbufPrepend(FFstrbuf* strbuf, FFstrbuf* value) {
+    if (value == NULL) {
+        return;
+    }
+    ffStrbufPrependNS(strbuf, value->length, value->chars);
+}
+
+static inline void ffStrbufPrependS(FFstrbuf* strbuf, const char* value) {
+    if (value == NULL) {
+        return;
+    }
+    ffStrbufPrependNS(strbuf, (uint32_t) strlen(value), value);
+}
+
+static inline FF_A_NODISCARD int ffStrbufComp(const FFstrbuf* strbuf, const FFstrbuf* comp) {
+    uint32_t length = strbuf->length > comp->length ? comp->length : strbuf->length;
+    return memcmp(strbuf->chars, comp->chars, length + 1);
+}
+
+static inline FF_A_NODISCARD bool ffStrbufEqual(const FFstrbuf* strbuf, const FFstrbuf* comp) {
+    return ffStrbufComp(strbuf, comp) == 0;
+}
+
+static inline FF_A_NODISCARD int ffStrbufCompS(const FFstrbuf* strbuf, const char* comp) {
+    return strcmp(strbuf->chars, comp);
+}
+
+static inline FF_A_NODISCARD bool ffStrbufEqualS(const FFstrbuf* strbuf, const char* comp) {
+    return ffStrbufCompS(strbuf, comp) == 0;
+}
+
+static inline FF_A_NODISCARD int ffStrbufIgnCaseCompS(const FFstrbuf* strbuf, const char* comp) {
+    return strcasecmp(strbuf->chars, comp);
+}
+
+static inline FF_A_NODISCARD bool ffStrbufIgnCaseEqualS(const FFstrbuf* strbuf, const char* comp) {
+    return ffStrbufIgnCaseCompS(strbuf, comp) == 0;
+}
+
+static inline FF_A_NODISCARD int ffStrbufIgnCaseComp(const FFstrbuf* strbuf, const FFstrbuf* comp) {
+    return ffStrbufIgnCaseCompS(strbuf, comp->chars);
+}
+
+static inline FF_A_NODISCARD bool ffStrbufIgnCaseEqual(const FFstrbuf* strbuf, const FFstrbuf* comp) {
+    return ffStrbufIgnCaseComp(strbuf, comp) == 0;
+}
+
+static inline FF_A_NODISCARD bool ffStrbufContainC(const FFstrbuf* strbuf, char c) {
+    return memchr(strbuf->chars, c, strbuf->length) != NULL;
+}
+
+static inline FF_A_NODISCARD bool ffStrbufContainS(const FFstrbuf* strbuf, const char* str) {
+    return strstr(strbuf->chars, str) != NULL;
+}
+
+static inline FF_A_NODISCARD bool ffStrbufContain(const FFstrbuf* strbuf, const FFstrbuf* str) {
+    return ffStrbufContainS(strbuf, str->chars);
+}
+
+static inline FF_A_NODISCARD bool ffStrbufContainIgnCaseS(const FFstrbuf* strbuf, const char* str) {
+    return strcasestr(strbuf->chars, str) != NULL;
+}
+
+static inline FF_A_NODISCARD bool ffStrbufContainIgnCase(const FFstrbuf* strbuf, const FFstrbuf* str) {
+    return ffStrbufContainIgnCaseS(strbuf, str->chars);
+}
+
+static inline FF_A_NODISCARD uint32_t ffStrbufFirstIndexC(const FFstrbuf* strbuf, char c) {
+    return ffStrbufNextIndexC(strbuf, 0, c);
+}
+
+static inline FF_A_NODISCARD uint32_t ffStrbufFirstIndex(const FFstrbuf* strbuf, const FFstrbuf* searched) {
+    return ffStrbufNextIndexS(strbuf, 0, searched->chars);
+}
+
+static inline FF_A_NODISCARD uint32_t ffStrbufFirstIndexS(const FFstrbuf* strbuf, const char* str) {
+    return ffStrbufNextIndexS(strbuf, 0, str);
+}
+
+static inline FF_A_NODISCARD uint32_t ffStrbufLastIndexC(const FFstrbuf* strbuf, char c) {
+    if (strbuf->length == 0) {
+        return 0;
+    }
+
+    return ffStrbufPreviousIndexC(strbuf, strbuf->length - 1, c);
+}
+
+static inline bool ffStrbufSubstrBeforeFirstC(FFstrbuf* strbuf, char c) {
+    return ffStrbufSubstrBefore(strbuf, ffStrbufFirstIndexC(strbuf, c));
+}
+
+static inline bool ffStrbufSubstrBeforeLastC(FFstrbuf* strbuf, char c) {
+    return ffStrbufSubstrBefore(strbuf, ffStrbufLastIndexC(strbuf, c));
+}
+
+static inline FF_A_NODISCARD bool ffStrbufStartsWithC(const FFstrbuf* strbuf, char c) {
+    return strbuf->chars[0] == c;
+}
+
+static inline FF_A_NODISCARD bool ffStrbufStartsWithSN(const FFstrbuf* strbuf, const char* start, uint32_t length) {
+    if (length > strbuf->length) {
+        return false;
+    }
+
+    return memcmp(strbuf->chars, start, length) == 0;
+}
+
+static inline FF_A_NODISCARD bool ffStrbufStartsWithS(const FFstrbuf* strbuf, const char* start) {
+    return ffStrbufStartsWithSN(strbuf, start, (uint32_t) strlen(start));
+}
+
+static inline FF_A_NODISCARD bool ffStrbufStartsWith(const FFstrbuf* strbuf, const FFstrbuf* start) {
+    return ffStrbufStartsWithSN(strbuf, start->chars, start->length);
+}
+
+static inline FF_A_NODISCARD bool ffStrbufStartsWithIgnCaseNS(const FFstrbuf* strbuf, uint32_t length, const char* start) {
+    if (length > strbuf->length) {
+        return false;
+    }
+    return strncasecmp(strbuf->chars, start, length) == 0;
+}
+
+static inline FF_A_NODISCARD bool ffStrbufStartsWithIgnCaseS(const FFstrbuf* strbuf, const char* start) {
+    return ffStrbufStartsWithIgnCaseNS(strbuf, (uint32_t) strlen(start), start);
+}
+
+static inline FF_A_NODISCARD bool ffStrbufStartsWithIgnCase(const FFstrbuf* strbuf, const FFstrbuf* start) {
+    return ffStrbufStartsWithIgnCaseNS(strbuf, start->length, start->chars);
+}
+
+static inline FF_A_NODISCARD bool ffStrbufEndsWithC(const FFstrbuf* strbuf, char c) {
+    return strbuf->length == 0 ? false : strbuf->chars[strbuf->length - 1] == c;
+}
+
+static inline FF_A_NODISCARD bool ffStrbufEndsWithNS(const FFstrbuf* strbuf, uint32_t endLength, const char* end) {
+    if (endLength > strbuf->length) {
+        return false;
+    }
+
+    return memcmp(strbuf->chars + strbuf->length - endLength, end, endLength) == 0;
+}
+
+static inline FF_A_NODISCARD bool ffStrbufEndsWithS(const FFstrbuf* strbuf, const char* end) {
+    return ffStrbufEndsWithNS(strbuf, (uint32_t) strlen(end), end);
+}
+
+static inline FF_A_NODISCARD bool ffStrbufEndsWithFn(const FFstrbuf* strbuf, int (*const fn)(int)) {
+    return strbuf->length == 0 ? false : fn(strbuf->chars[strbuf->length - 1]);
+}
+
+static inline FF_A_NODISCARD bool ffStrbufEndsWith(const FFstrbuf* strbuf, const FFstrbuf* end) {
+    return ffStrbufEndsWithNS(strbuf, end->length, end->chars);
+}
+
+static inline FF_A_NODISCARD bool ffStrbufEndsWithIgnCaseNS(const FFstrbuf* strbuf, uint32_t endLength, const char* end) {
+    if (endLength > strbuf->length) {
+        return false;
+    }
+    return strcasecmp(strbuf->chars + strbuf->length - endLength, end) == 0;
+}
+
+static inline FF_A_NODISCARD bool ffStrbufEndsWithIgnCaseS(const FFstrbuf* strbuf, const char* end) {
+    return ffStrbufEndsWithIgnCaseNS(strbuf, (uint32_t) strlen(end), end);
+}
+
+static inline FF_A_NODISCARD bool ffStrbufEndsWithIgnCase(const FFstrbuf* strbuf, const FFstrbuf* end) {
+    return ffStrbufEndsWithIgnCaseNS(strbuf, end->length, end->chars);
+}
+
+static inline void ffStrbufTrim(FFstrbuf* strbuf, char c) {
+    ffStrbufTrimRight(strbuf, c);
+    ffStrbufTrimLeft(strbuf, c);
+}
+
+static inline void ffStrbufTrimSpace(FFstrbuf* strbuf) {
+    ffStrbufTrimRightSpace(strbuf);
+    ffStrbufTrimLeftSpace(strbuf);
+}
+
+static inline bool ffStrbufMatchSeparatedS(const FFstrbuf* strbuf, const char* comp, char separator) {
+    return ffStrbufMatchSeparatedNS(strbuf, (uint32_t) strlen(comp), comp, separator);
+}
+
+static inline bool ffStrbufMatchSeparated(const FFstrbuf* strbuf, const FFstrbuf* comp, char separator) {
+    return ffStrbufMatchSeparatedNS(strbuf, comp->length, comp->chars, separator);
+}
+
+static inline bool ffStrbufMatchSeparatedIgnCaseS(const FFstrbuf* strbuf, const char* comp, char separator) {
+    return ffStrbufMatchSeparatedIgnCaseNS(strbuf, (uint32_t) strlen(comp), comp, separator);
+}
+
+static inline bool ffStrbufMatchSeparatedIgnCase(const FFstrbuf* strbuf, const FFstrbuf* comp, char separator) {
+    return ffStrbufMatchSeparatedIgnCaseNS(strbuf, comp->length, comp->chars, separator);
+}
+
+static inline bool ffStrbufSeparatedContainS(const FFstrbuf* strbuf, const char* comp, char separator) {
+    return ffStrbufSeparatedContainNS(strbuf, (uint32_t) strlen(comp), comp, separator);
+}
+
+static inline bool ffStrbufSeparatedContain(const FFstrbuf* strbuf, const FFstrbuf* comp, char separator) {
+    return ffStrbufSeparatedContainNS(strbuf, comp->length, comp->chars, separator);
+}
+
+static inline bool ffStrbufSeparatedContainIgnCaseS(const FFstrbuf* strbuf, const char* comp, char separator) {
+    return ffStrbufSeparatedContainIgnCaseNS(strbuf, (uint32_t) strlen(comp), comp, separator);
+}
+
+static inline bool ffStrbufSeparatedContainIgnCase(const FFstrbuf* strbuf, const FFstrbuf* comp, char separator) {
+    return ffStrbufSeparatedContainIgnCaseNS(strbuf, comp->length, comp->chars, separator);
+}
+
+// Returns true if the strbuf is modified
+bool ffStrbufDecodeHexEscapeSequences(FFstrbuf* strbuf);
+
+#define FF_STRBUF_AUTO_DESTROY FFstrbuf FF_A_CLEANUP(ffStrbufDestroy)
@@ -0,0 +1,184 @@
+#include "cf_helpers.h"
+
+const char* ffCfNumGetInt64(CFTypeRef cf, int64_t* result) {
+    if (CFGetTypeID(cf) == CFNumberGetTypeID()) {
+        if (!CFNumberGetValue((CFNumberRef) cf, kCFNumberSInt64Type, result)) {
+            return "Number type is not SInt64";
+        }
+        return NULL;
+    } else if (CFGetTypeID(cf) == CFDataGetTypeID()) {
+        if (CFDataGetLength((CFDataRef) cf) != sizeof(int64_t)) {
+            return "Data length is not sizeof(int64_t)";
+        }
+        CFDataGetBytes((CFDataRef) cf, CFRangeMake(0, sizeof(int64_t)), (uint8_t*) result);
+        return NULL;
+    }
+
+    return "TypeID is neither 'CFNumber' nor 'CFData'";
+}
+
+const char* ffCfNumGetInt(CFTypeRef cf, int32_t* result) {
+    if (CFGetTypeID(cf) == CFNumberGetTypeID()) {
+        if (!CFNumberGetValue((CFNumberRef) cf, kCFNumberSInt32Type, result)) {
+            return "Number type is not SInt32";
+        }
+        return NULL;
+    } else if (CFGetTypeID(cf) == CFDataGetTypeID()) {
+        if (CFDataGetLength((CFDataRef) cf) != sizeof(int)) {
+            return "Data length is not sizeof(int)";
+        }
+        CFDataGetBytes((CFDataRef) cf, CFRangeMake(0, sizeof(int)), (uint8_t*) result);
+        return NULL;
+    }
+
+    return "TypeID is neither 'CFNumber' nor 'CFData'";
+}
+
+const char* ffCfStrGetString(CFTypeRef cf, FFstrbuf* result) {
+    ffStrbufClear(result);
+    if (!cf) {
+        return NULL;
+    }
+
+    if (CFGetTypeID(cf) == CFStringGetTypeID()) {
+        CFStringRef cfStr = (CFStringRef) cf;
+
+        const char* cstr = CFStringGetCStringPtr(cfStr, kCFStringEncodingUTF8);
+        if (cstr) {
+            ffStrbufSetS(result, cstr);
+        } else {
+            uint32_t length = (uint32_t) CFStringGetLength(cfStr);
+            if (length == 0) {
+                return NULL;
+            }
+            ffStrbufEnsureFixedLengthFree(result, (uint32_t) CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8));
+            if (!CFStringGetCString(cfStr, result->chars, result->allocated, kCFStringEncodingUTF8)) {
+                return "CFStringGetCString() failed";
+            }
+            // CFStringGetCString ensures the buffer is NUL terminated
+            // https://developer.apple.com/documentation/corefoundation/1542721-cfstringgetcstring
+            result->length = (uint32_t) strnlen(result->chars, (uint32_t) result->allocated);
+        }
+    } else if (CFGetTypeID(cf) == CFDataGetTypeID()) {
+        CFDataRef cfData = (CFDataRef) cf;
+        uint32_t length = (uint32_t) CFDataGetLength(cfData);
+        if (length == 0) {
+            return NULL;
+        }
+        ffStrbufEnsureFixedLengthFree(result, length + 1);
+        CFDataGetBytes(cfData, CFRangeMake(0, length), (uint8_t*) result->chars);
+        result->length = (uint32_t) strnlen(result->chars, length);
+        result->chars[result->length] = '\0';
+    } else {
+        return "TypeID is neither 'CFString' nor 'CFData'";
+    }
+
+    return NULL;
+}
+
+const char* ffCfDataGetDataAsString(CFTypeRef cf, FFstrbuf* result) {
+    ffStrbufClear(result);
+    if (!cf) {
+        return NULL;
+    }
+
+    if (CFGetTypeID(cf) == CFDataGetTypeID()) {
+        CFDataRef cfData = (CFDataRef) cf;
+        uint32_t length = (uint32_t) CFDataGetLength(cfData);
+        if (length == 0) {
+            return NULL;
+        }
+        ffStrbufEnsureFixedLengthFree(result, length + 1);
+        CFDataGetBytes(cfData, CFRangeMake(0, length), (uint8_t*) result->chars);
+        result->length = length;
+        result->chars[result->length] = '\0';
+    } else {
+        return "TypeID is not 'CFData'";
+    }
+
+    return NULL;
+}
+
+const char* ffCfDictGetString(CFDictionaryRef dict, CFStringRef key, FFstrbuf* result) {
+    CFTypeRef cf = (CFTypeRef) CFDictionaryGetValue(dict, key);
+    if (cf == NULL) {
+        return "CFDictionaryGetValue() failed";
+    }
+
+    return ffCfStrGetString(cf, result);
+}
+
+const char* ffCfDictGetDataAsString(CFDictionaryRef dict, CFStringRef key, FFstrbuf* result) {
+    CFTypeRef cf = (CFTypeRef) CFDictionaryGetValue(dict, key);
+    if (cf == NULL) {
+        return "CFDictionaryGetValue() failed";
+    }
+
+    return ffCfDataGetDataAsString(cf, result);
+}
+
+const char* ffCfDictGetBool(CFDictionaryRef dict, CFStringRef key, bool* result) {
+    CFBooleanRef cf = (CFBooleanRef) CFDictionaryGetValue(dict, key);
+    if (cf == NULL) {
+        return "CFDictionaryGetValue() failed";
+    }
+
+    if (CFGetTypeID(cf) != CFBooleanGetTypeID()) {
+        return "TypeID is not 'CFBoolean'";
+    }
+
+    *result = CFBooleanGetValue(cf);
+    return NULL;
+}
+
+const char* ffCfDictGetInt(CFDictionaryRef dict, CFStringRef key, int* result) {
+    CFTypeRef cf = (CFTypeRef) CFDictionaryGetValue(dict, key);
+    if (cf == NULL) {
+        return "CFDictionaryGetValue() failed";
+    }
+
+    return ffCfNumGetInt(cf, result);
+}
+
+const char* ffCfDictGetInt64(CFDictionaryRef dict, CFStringRef key, int64_t* result) {
+    CFTypeRef cf = (CFTypeRef) CFDictionaryGetValue(dict, key);
+    if (cf == NULL) {
+        return "CFDictionaryGetValue() failed";
+    }
+
+    return ffCfNumGetInt64(cf, result);
+}
+
+const char* ffCfDictGetData(CFDictionaryRef dict, CFStringRef key, uint32_t offset, uint32_t size, uint8_t* result, uint32_t* length) {
+    CFTypeRef cf = (CFTypeRef) CFDictionaryGetValue(dict, key);
+    if (cf == NULL) {
+        return "CFDictionaryGetValue() failed";
+    }
+
+    if (CFGetTypeID(cf) != CFDataGetTypeID()) {
+        return "TypeID is not 'CFData'";
+    }
+
+    CFIndex trueLength = CFDataGetLength((CFDataRef) cf);
+
+    if (trueLength < offset + size) {
+        return "Data length is less than offset + size";
+    }
+
+    if (length) {
+        *length = (uint32_t) trueLength;
+    }
+
+    CFDataGetBytes((CFDataRef) cf, CFRangeMake(offset, size), result);
+    return NULL;
+}
+
+const char* ffCfDictGetDict(CFDictionaryRef dict, CFStringRef key, CFDictionaryRef* result) {
+    CFDictionaryRef cf = (CFDictionaryRef) CFDictionaryGetValue(dict, key);
+    if (cf == NULL || CFGetTypeID(cf) != CFDictionaryGetTypeID()) {
+        return "TypeID is not 'CFDictionary'";
+    }
+
+    *result = cf;
+    return NULL;
+}
@@ -4,34 +4,36 @@
 #include <CoreFoundation/CoreFoundation.h>
 #include <IOKit/IOKitLib.h>

-//Return error info if failed, NULL otherwise
+// Return error info if failed, NULL otherwise
 const char* ffCfStrGetString(CFTypeRef cf, FFstrbuf* result);
 const char* ffCfNumGetInt(CFTypeRef cf, int32_t* result);
 const char* ffCfNumGetInt64(CFTypeRef cf, int64_t* result);
+const char* ffCfDataGetDataAsString(CFTypeRef cf, FFstrbuf* result);
 const char* ffCfDictGetString(CFDictionaryRef dict, CFStringRef key, FFstrbuf* result);
 const char* ffCfDictGetBool(CFDictionaryRef dict, CFStringRef key, bool* result);
 const char* ffCfDictGetInt(CFDictionaryRef dict, CFStringRef key, int* result);
 const char* ffCfDictGetInt64(CFDictionaryRef dict, CFStringRef key, int64_t* result);
 const char* ffCfDictGetData(CFDictionaryRef dict, CFStringRef key, uint32_t offset, uint32_t size, uint8_t* result, uint32_t* length);
+const char* ffCfDictGetDataAsString(CFDictionaryRef dict, CFStringRef key, FFstrbuf* result);
 const char* ffCfDictGetDict(CFDictionaryRef dict, CFStringRef key, CFDictionaryRef* result);

-static inline CFNumberRef ffCfCreateInt(int value)
-{
+static inline CFNumberRef ffCfCreateInt(int value) {
    return CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &value);
 }

-static inline void cfReleaseWrapper(void* type)
-{
-    if (*(CFTypeRef*) type)
+static inline void cfReleaseWrapper(void* type) {
+    assert(type);
+    if (*(CFTypeRef*) type) {
        CFRelease(*(CFTypeRef*) type);
+    }
 }

-#define FF_CFTYPE_AUTO_RELEASE __attribute__((__cleanup__(cfReleaseWrapper)))
+#define FF_CFTYPE_AUTO_RELEASE FF_A_CLEANUP(cfReleaseWrapper)

-static inline void wrapIoObjectRelease(io_object_t* service)
-{
+static inline void wrapIoObjectRelease(io_object_t* service) {
    assert(service);
-    if (*service)
+    if (*service) {
        IOObjectRelease(*service);
+    }
 }
-#define FF_IOOBJECT_AUTO_RELEASE __attribute__((__cleanup__(wrapIoObjectRelease)))
+#define FF_IOOBJECT_AUTO_RELEASE FF_A_CLEANUP(wrapIoObjectRelease)
@@ -0,0 +1,466 @@
+#include "smc_temps.h"
+#include "common/apple/cf_helpers.h"
+#include "common/stringUtils.h"
+
+#include <stdint.h>
+#include <math.h>
+#include <IOKit/IOKitLib.h>
+
+static const char kSmcCmdReadBytes = 5;
+static const char kSmcCmdReadKeyInfo = 9;
+static const uint32_t kKernelIndexSmc = 2;
+
+typedef struct
+{
+    char major;
+    char minor;
+    char build;
+    char reserved[1];
+    uint16_t release;
+} SmcKeyData_vers_t;
+
+typedef struct
+{
+    uint16_t version;
+    uint16_t length;
+    uint32_t cpuPLimit;
+    uint32_t gpuPLimit;
+    uint32_t memPLimit;
+} SmcKeyData_pLimitData_t;
+
+typedef struct
+{
+    uint32_t dataSize;
+    uint32_t dataType;
+    char dataAttributes;
+} SmcKeyData_keyInfo_t;
+
+typedef unsigned char SmcBytes_t[32];
+
+typedef struct
+{
+    uint32_t key;
+    SmcKeyData_vers_t vers;
+    SmcKeyData_pLimitData_t pLimitData;
+    SmcKeyData_keyInfo_t keyInfo;
+    char result;
+    char status;
+    char data8;
+    uint32_t data32;
+    SmcBytes_t bytes;
+} SmcKeyData_t;
+
+typedef char UInt32Char_t[5];
+
+typedef struct
+{
+    UInt32Char_t key;
+    uint32_t dataSize;
+    UInt32Char_t dataType;
+    SmcBytes_t bytes;
+} SmcVal_t;
+
+static uint32_t smcStrtoul(const char* str, int size, int base) {
+    uint32_t total = 0;
+
+    for (int i = 0; i < size; i++) {
+        if (base == 16) {
+            total += (uint32_t) (str[i] << (size - 1 - i) * 8);
+        } else {
+            total += (uint32_t) ((unsigned char) (str[i]) << (size - 1 - i) * 8);
+        }
+    }
+    return total;
+}
+
+static void smcUltostr(char* str, uint32_t val) {
+    str[0] = (char) (val >> 24);
+    str[1] = (char) (val >> 16);
+    str[2] = (char) (val >> 8);
+    str[3] = (char) val;
+    str[4] = '\0';
+}
+
+static const char* smcCall(io_connect_t conn, uint32_t selector, SmcKeyData_t* inputStructure, SmcKeyData_t* outputStructure) {
+    size_t size = sizeof(SmcKeyData_t);
+
+    if (IOConnectCallStructMethod(conn, selector, inputStructure, size, outputStructure, &size) != kIOReturnSuccess) {
+        return "IOConnectCallStructMethod(conn) failed";
+    }
+    return NULL;
+}
+
+// Provides key info, using a cache to dramatically improve the energy impact of smcFanControl
+static const char* smcGetKeyInfo(io_connect_t conn, const uint32_t key, SmcKeyData_keyInfo_t* key_info) {
+    SmcKeyData_t inputStructure = { 0 };
+    SmcKeyData_t outputStructure = { 0 };
+
+    inputStructure.key = key;
+    inputStructure.data8 = kSmcCmdReadKeyInfo;
+
+    const char* error = smcCall(conn, kKernelIndexSmc, &inputStructure, &outputStructure);
+    if (error) {
+        return error;
+    }
+
+    *key_info = outputStructure.keyInfo;
+    return NULL;
+}
+
+static const char* smcReadSmcVal(io_connect_t conn, const UInt32Char_t key, SmcVal_t* val) {
+    SmcKeyData_t inputStructure = { 0 };
+    SmcKeyData_t outputStructure = { 0 };
+
+    inputStructure.key = smcStrtoul(key, 4, 16);
+    strcpy(val->key, key);
+
+    const char* error = smcGetKeyInfo(conn, inputStructure.key, &outputStructure.keyInfo);
+    if (error) {
+        return error;
+    }
+
+    val->dataSize = outputStructure.keyInfo.dataSize;
+    smcUltostr(val->dataType, outputStructure.keyInfo.dataType);
+    inputStructure.keyInfo.dataSize = val->dataSize;
+    inputStructure.data8 = kSmcCmdReadBytes;
+
+    error = smcCall(conn, kKernelIndexSmc, &inputStructure, &outputStructure);
+    if (error) {
+        return error;
+    }
+
+    memcpy(val->bytes, outputStructure.bytes, sizeof(outputStructure.bytes));
+
+    return NULL;
+}
+
+static const char* smcOpen(io_connect_t* conn) {
+    FF_IOOBJECT_AUTO_RELEASE io_object_t device = IOServiceGetMatchingService(MACH_PORT_NULL, IOServiceMatching("AppleSMC"));
+    if (!device) {
+        return "No SMC device found";
+    }
+
+    if (IOServiceOpen(device, mach_task_self(), 0, conn) != kIOReturnSuccess) {
+        return "IOServiceOpen() failed";
+    }
+
+    return NULL;
+}
+
+static const char* smcReadValue(io_connect_t conn, const UInt32Char_t key, double* value) {
+    SmcVal_t val = { 0 };
+    const char* error = smcReadSmcVal(conn, key, &val);
+    if (error != NULL) {
+        return error;
+    }
+    if (val.dataSize == 0) {
+        return "Empty SMC result";
+    }
+
+    switch (val.dataType[0]) {
+        case 'u': // unsigned integer types
+            if (val.dataType[1] == 'i') {
+                switch (val.dataSize) {
+                    case 1:
+                        *value = *(uint8_t*) (val.bytes);
+                        break;
+                    case 2:
+                        *value = ntohs(*(uint16_t*) (val.bytes));
+                        break;
+                    case 4:
+                        *value = ntohl(*(uint32_t*) (val.bytes));
+                        break;
+                    case 8:
+                        *value = (double) ntohll(*(uint64_t*) (val.bytes));
+                        break;
+                    default:
+                        return "Unsupported SMC unsigned integer data size";
+                }
+            } else {
+                return "Unsupported SMC unsigned data type";
+            }
+            break;
+
+        case 'f': // floating point types
+            if (ffStrEquals(val.dataType, "flt ") && val.dataSize == 4) {
+                *value = *(float*) (val.bytes);
+            } else if (val.dataType[1] == 'p' && val.dataSize == 2) // fixed point types
+            {
+                if (ffStrEquals(val.dataType, "fp1f")) {
+                    *value = ntohs(*(uint16_t*) (val.bytes)) / 32768.0;
+                } else if (ffStrEquals(val.dataType, "fp4c")) {
+                    *value = ntohs(*(uint16_t*) (val.bytes)) / 4096.0;
+                } else if (ffStrEquals(val.dataType, "fp5b")) {
+                    *value = ntohs(*(uint16_t*) (val.bytes)) / 2048.0;
+                } else if (ffStrEquals(val.dataType, "fp6a")) {
+                    *value = ntohs(*(uint16_t*) (val.bytes)) / 1024.0;
+                } else if (ffStrEquals(val.dataType, "fp79")) {
+                    *value = ntohs(*(uint16_t*) (val.bytes)) / 512.0;
+                } else if (ffStrEquals(val.dataType, "fp88")) {
+                    *value = ntohs(*(uint16_t*) (val.bytes)) / 256.0;
+                } else if (ffStrEquals(val.dataType, "fpa6")) {
+                    *value = ntohs(*(uint16_t*) (val.bytes)) / 64.0;
+                } else if (ffStrEquals(val.dataType, "fpc4")) {
+                    *value = ntohs(*(uint16_t*) (val.bytes)) / 16.0;
+                } else if (ffStrEquals(val.dataType, "fpe2")) {
+                    *value = ntohs(*(uint16_t*) (val.bytes)) / 4.0;
+                } else {
+                    return "Unsupported SMC floating point data type";
+                }
+            } else {
+                return "Unsupported SMC floating point data type";
+            }
+            break;
+
+        case 's': // signed integer types
+            if (val.dataType[1] == 'i') {
+                switch (val.dataSize) {
+                    case 1:
+                        *value = *(int8_t*) (val.bytes);
+                        break;
+                    case 2:
+                        *value = ntohs(*(int16_t*) (val.bytes));
+                        break;
+                    case 4:
+                        *value = ntohl(*(int32_t*) (val.bytes));
+                        break;
+                    case 8:
+                        *value = (double) ntohll(*(int64_t*) (val.bytes));
+                        break;
+                    default:
+                        return "Unsupported SMC signed integer data size";
+                }
+            } else if (val.dataType[1] == 'p' && val.dataSize == 2) // signed fixed point types
+            {
+                if (ffStrEquals(val.dataType, "sp1e")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 16384.0;
+                } else if (ffStrEquals(val.dataType, "sp3c")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 4096.0;
+                } else if (ffStrEquals(val.dataType, "sp4b")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 2048.0;
+                } else if (ffStrEquals(val.dataType, "sp5a")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 1024.0;
+                } else if (ffStrEquals(val.dataType, "sp69")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 512.0;
+                } else if (ffStrEquals(val.dataType, "sp78")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 256.0;
+                } else if (ffStrEquals(val.dataType, "sp87")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 128.0;
+                } else if (ffStrEquals(val.dataType, "sp96")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 64.0;
+                } else if (ffStrEquals(val.dataType, "spb4")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 16.0;
+                } else if (ffStrEquals(val.dataType, "spf0")) {
+                    *value = (int16_t) ntohs(*(int16_t*) (val.bytes)) / 1.0;
+                } else {
+                    return "Unsupported SMC signed integer data type";
+                }
+            } else {
+                return "Unsupported SMC signed data type";
+            }
+            break;
+
+        case '{': // special types like pwm
+            if (ffStrEquals(val.dataType, "{pwm") && val.dataSize == 2) {
+                *value = (double) ntohs(*(uint16_t*) (val.bytes)) * 100 / 65536.0;
+            } else {
+                return "Unsupported SMC special data type";
+            }
+            break;
+
+        default:
+            return "Unsupported SMC data type";
+    }
+    return NULL;
+}
+
+static bool detectTemp(io_connect_t conn, const char* sensor, double* sum) {
+    double temp = 0;
+    const char* error = smcReadValue(conn, sensor, &temp);
+    if (error) {
+        return false;
+    }
+    // https://github.com/exelban/stats/blob/14e29c4d60229c363cca9c9d25c30c87b7870830/Modules/Sensors/readers.swift#L124
+    if (temp < 10 || temp > 120) {
+        return false;
+    }
+    *sum += temp;
+    return true;
+}
+
+static io_connect_t conn;
+
+const char* ffDetectSmcSpecificTemp(const char* sensor, double* result) {
+    if (!conn) {
+        if (smcOpen(&conn) != NULL) {
+            conn = (io_connect_t) -1;
+        }
+    }
+    if (conn == (io_connect_t) -1) {
+        return "Could not open SMC connection";
+    }
+
+    if (!detectTemp(conn, sensor, result)) {
+        return "Could not read SMC temperature";
+    }
+
+    return NULL;
+}
+
+const char* ffDetectSmcTemps(enum FFTempType type, double* result) {
+    if (!conn) {
+        if (smcOpen(&conn) != NULL) {
+            conn = (io_connect_t) -1;
+        }
+    }
+    if (conn == (io_connect_t) -1) {
+        return "Could not open SMC connection";
+    }
+
+    uint32_t count = 0;
+    *result = 0;
+
+    // https://github.com/exelban/stats/blob/master/Modules/Sensors/values.swift
+    switch (type) {
+        case FF_TEMP_CPU_X64:
+            count += detectTemp(conn, "TC0D", result); // CPU diode
+            count += detectTemp(conn, "TC0E", result); // CPU diode virtual
+            count += detectTemp(conn, "TC0F", result); // CPU diode filtered
+            count += detectTemp(conn, "TC0P", result); // CPU proximity
+            break;
+
+        case FF_TEMP_CPU_M1X:
+            count += detectTemp(conn, "Tp09", result); // CPU efficient core 1
+            count += detectTemp(conn, "Tp0T", result); // CPU efficient core 2
+
+            count += detectTemp(conn, "Tp01", result); // CPU performance core 1
+            count += detectTemp(conn, "Tp05", result); // CPU performance core 2
+            count += detectTemp(conn, "Tp0D", result); // CPU performance core 3
+            count += detectTemp(conn, "Tp0H", result); // CPU performance core 4
+            count += detectTemp(conn, "Tp0L", result); // CPU performance core 5
+            count += detectTemp(conn, "Tp0P", result); // CPU performance core 6
+            count += detectTemp(conn, "Tp0X", result); // CPU performance core 7
+            count += detectTemp(conn, "Tp0b", result); // CPU performance core 8
+            break;
+
+        case FF_TEMP_CPU_M2X:
+            count += detectTemp(conn, "Tp1h", result); // CPU efficiency core 1
+            count += detectTemp(conn, "Tp1t", result); // CPU efficiency core 2
+            count += detectTemp(conn, "Tp1p", result); // CPU efficiency core 3
+            count += detectTemp(conn, "Tp1l", result); // CPU efficiency core 4
+
+            count += detectTemp(conn, "Tp01", result); // CPU performance core 1
+            count += detectTemp(conn, "Tp05", result); // CPU performance core 2
+            count += detectTemp(conn, "Tp09", result); // CPU performance core 3
+            count += detectTemp(conn, "Tp0D", result); // CPU performance core 4
+            count += detectTemp(conn, "Tp0X", result); // CPU performance core 5
+            count += detectTemp(conn, "Tp0b", result); // CPU performance core 6
+            count += detectTemp(conn, "Tp0f", result); // CPU performance core 7
+            count += detectTemp(conn, "Tp0j", result); // CPU performance core 8
+            break;
+
+        case FF_TEMP_CPU_M3X:
+            count += detectTemp(conn, "Te05", result); // CPU efficiency core 1
+            count += detectTemp(conn, "Te0L", result); // CPU efficiency core 2
+            count += detectTemp(conn, "Te0P", result); // CPU efficiency core 3
+            count += detectTemp(conn, "Te0S", result); // CPU efficiency core 4
+            count += detectTemp(conn, "Tf04", result); // CPU performance core 1
+            count += detectTemp(conn, "Tf09", result); // CPU performance core 2
+            count += detectTemp(conn, "Tf0A", result); // CPU performance core 3
+            count += detectTemp(conn, "Tf0B", result); // CPU performance core 4
+            count += detectTemp(conn, "Tf0D", result); // CPU performance core 5
+            count += detectTemp(conn, "Tf0E", result); // CPU performance core 6
+            count += detectTemp(conn, "Tf44", result); // CPU performance core 7
+            count += detectTemp(conn, "Tf49", result); // CPU performance core 8
+            count += detectTemp(conn, "Tf4A", result); // CPU performance core 9
+            count += detectTemp(conn, "Tf4B", result); // CPU performance core 10
+            count += detectTemp(conn, "Tf4D", result); // CPU performance core 11
+            count += detectTemp(conn, "Tf4E", result); // CPU performance core 12
+            break;
+
+        case FF_TEMP_CPU_M4X:
+            count += detectTemp(conn, "Te05", result); // CPU efficiency core 1
+            count += detectTemp(conn, "Te0S", result); // CPU efficiency core 2
+            count += detectTemp(conn, "Te09", result); // CPU efficiency core 3
+            count += detectTemp(conn, "Te0H", result); // CPU efficiency core 4
+            count += detectTemp(conn, "Tp01", result); // CPU performance core 1
+            count += detectTemp(conn, "Tp05", result); // CPU performance core 2
+            count += detectTemp(conn, "Tp09", result); // CPU performance core 3
+            count += detectTemp(conn, "Tp0D", result); // CPU performance core 4
+            count += detectTemp(conn, "Tp0V", result); // CPU performance core 5
+            count += detectTemp(conn, "Tp0Y", result); // CPU performance core 6
+            count += detectTemp(conn, "Tp0b", result); // CPU performance core 7
+            count += detectTemp(conn, "Tp0e", result); // CPU performance core 8
+            break;
+
+        case FF_TEMP_GPU_INTEL:
+            count += detectTemp(conn, "TCGC", result); // GPU Intel Graphics
+            goto gpu_unknown;
+
+        case FF_TEMP_GPU_AMD:
+            count += detectTemp(conn, "TGDD", result); // GPU AMD Radeon
+            goto gpu_unknown;
+
+        case FF_TEMP_GPU_UNKNOWN: // Nvidia?
+        gpu_unknown:
+            count += detectTemp(conn, "TG0D", result); // GPU diode
+            count += detectTemp(conn, "TG0P", result); // GPU proximity
+            break;
+
+        case FF_TEMP_GPU_M1X:
+            count += detectTemp(conn, "Tg05", result); // GPU 1
+            count += detectTemp(conn, "Tg0D", result); // GPU 2
+            count += detectTemp(conn, "Tg0L", result); // GPU 3
+            count += detectTemp(conn, "Tg0T", result); // GPU 4
+            break;
+
+        case FF_TEMP_GPU_M2X:
+            count += detectTemp(conn, "Tg0f", result); // GPU 1
+            count += detectTemp(conn, "Tg0j", result); // GPU 2
+            break;
+
+        case FF_TEMP_GPU_M3X:
+            count += detectTemp(conn, "Tf14", result); // GPU 1
+            count += detectTemp(conn, "Tf18", result); // GPU 2
+            count += detectTemp(conn, "Tf19", result); // GPU 3
+            count += detectTemp(conn, "Tf1A", result); // GPU 4
+            count += detectTemp(conn, "Tf24", result); // GPU 5
+            count += detectTemp(conn, "Tf28", result); // GPU 6
+            count += detectTemp(conn, "Tf29", result); // GPU 7
+            count += detectTemp(conn, "Tf2A", result); // GPU 8
+            break;
+
+        case FF_TEMP_GPU_M4X:
+            count += detectTemp(conn, "Tg0G", result); // GPU 1 (Basic)
+            count += detectTemp(conn, "Tg0H", result); // GPU 2 (Basic)
+            count += detectTemp(conn, "Tg1U", result); // GPU 1 (Pro / Max)
+            count += detectTemp(conn, "Tg1k", result); // GPU 2 (Pro / Max)
+            count += detectTemp(conn, "Tg0K", result); // GPU 3
+            count += detectTemp(conn, "Tg0L", result); // GPU 4
+            count += detectTemp(conn, "Tg0d", result); // GPU 5
+            count += detectTemp(conn, "Tg0e", result); // GPU 6
+            count += detectTemp(conn, "Tg0j", result); // GPU 7
+            count += detectTemp(conn, "Tg0k", result); // GPU 8
+            break;
+
+        case FF_TEMP_BATTERY:
+            count += detectTemp(conn, "TB1T", result); // Battery
+            count += detectTemp(conn, "TB2T", result); // Battery
+            break;
+
+        case FF_TEMP_MEMORY:
+            count += detectTemp(conn, "Tm02", result); // Memory 1
+            count += detectTemp(conn, "Tm06", result); // Memory 2
+            count += detectTemp(conn, "Tm08", result); // Memory 3
+            count += detectTemp(conn, "Tm09", result); // Memory 4
+            break;
+    }
+
+    if (count == 0) {
+        return "No temperatures detected";
+    }
+
+    *result /= count;
+
+    return NULL;
+}
@@ -2,15 +2,13 @@

 #include "fastfetch.h"

-typedef struct FFTempValue
-{
+typedef struct FFTempValue {
    FFstrbuf name;
    FFstrbuf deviceClass;
    double value;
 } FFTempValue;

-enum FFTempType
-{
+enum FFTempType {
    FF_TEMP_CPU_X64,
    FF_TEMP_CPU_M1X,
    FF_TEMP_CPU_M2X,
@@ -30,4 +28,5 @@ enum FFTempType
    FF_TEMP_MEMORY,
 };

+const char* ffDetectSmcSpecificTemp(const char* sensor, double* result);
 const char* ffDetectSmcTemps(enum FFTempType type, double* result);
@@ -0,0 +1,44 @@
+#pragma once
+
+#include "common/FFstrbuf.h"
+
+// For ffRegReadValue(s)
+// If length is 0, data will be allocated with malloc() and must be freed by the caller
+// Otherwise, data must point to a buffer of at least length bytes, and the actual length of the data will be written to length.
+typedef struct FFArgBuffer {
+    void* data;
+    uint32_t length;
+} FFArgBuffer;
+
+typedef enum FF_A_PACKED FFArgType {
+    FF_ARG_TYPE_NULL = 0,
+    FF_ARG_TYPE_UINT,
+    FF_ARG_TYPE_UINT64,
+    FF_ARG_TYPE_UINT16,
+    FF_ARG_TYPE_UINT8,
+    FF_ARG_TYPE_INT,
+    FF_ARG_TYPE_STRING,
+    FF_ARG_TYPE_STRBUF,
+    FF_ARG_TYPE_FLOAT,
+    FF_ARG_TYPE_DOUBLE,
+    FF_ARG_TYPE_LIST,
+    FF_ARG_TYPE_BOOL,
+    FF_ARG_TYPE_BUFFER,
+} FFArgType;
+
+#define FF_ARG(variable, var_name) { _Generic((variable),                                   \
+        uint32_t: FF_ARG_TYPE_UINT,                                                         \
+        uint64_t: FF_ARG_TYPE_UINT64,                                                       \
+        uint16_t: FF_ARG_TYPE_UINT16,                                                       \
+        uint8_t: FF_ARG_TYPE_UINT8,                                                         \
+        int32_t: FF_ARG_TYPE_INT,                                                           \
+        char*: FF_ARG_TYPE_STRING,                                                          \
+        const char*: FF_ARG_TYPE_STRING,                                                    \
+        FFstrbuf: FF_ARG_TYPE_STRBUF,                                                       \
+        float: FF_ARG_TYPE_FLOAT,                                                           \
+        double: FF_ARG_TYPE_DOUBLE,                                                         \
+        FFlist: FF_ARG_TYPE_LIST,                                                           \
+        bool: FF_ARG_TYPE_BOOL,                                                             \
+        FFArgBuffer: FF_ARG_TYPE_BUFFER),                                                   \
+    _Generic((variable), char*: (variable), const char*: (variable), default: &(variable)), \
+    (var_name) }
@@ -3,7 +3,9 @@
 #include <assert.h>

 #ifdef __has_builtin
-    #if __has_builtin(__is_array)
+    #if !__cplusplus && FF_SUPPORTS_COUNT_OF
+        #define ARRAY_SIZE(x) _Countof(x)
+    #elif __has_builtin(__is_array)
        #define ARRAY_SIZE(x) ({ static_assert(__is_array(__typeof__(x)), "Must be an array"); (uint32_t) (sizeof(x) / sizeof(*(x))); })
    #elif __has_builtin(__builtin_types_compatible_p)
        #define ARRAY_SIZE(x) ({ static_assert(!__builtin_types_compatible_p(__typeof__(x), __typeof__(&*(x))), "Must not be a pointer"); (uint32_t) (sizeof(x) / sizeof(*(x))); })
@@ -0,0 +1,18 @@
+#pragma once
+
+#ifndef __has_attribute
+    #error Unsupported compiler
+    #define __attribute__(x)
+#endif
+
+#define FF_A_FALLTHROUGH __attribute__((__fallthrough__))
+#define FF_A_DEPRECATED __attribute__((__deprecated__))
+#define FF_A_CLEANUP(func) __attribute__((__cleanup__(func)))
+#define FF_A_NODISCARD __attribute__((__warn_unused_result__))
+#define FF_A_PRINTF(formatStrIndex, argsStartIndex) __attribute__((__format__(printf, formatStrIndex, argsStartIndex)))
+#define FF_A_SCANF(formatStrIndex, argsStartIndex) __attribute__((__format__(scanf, formatStrIndex, argsStartIndex)))
+#define FF_A_NONNULL(argIndex, ...) __attribute__((__nonnull__(argIndex, ##__VA_ARGS__)))
+#define FF_A_RETURNS_NONNULL __attribute__((__returns_nonnull__))
+#define FF_A_UNUSED __attribute__((__unused__))
+#define FF_A_PACKED __attribute__((__packed__))
+#define FF_A_WEAK_IMPORT __attribute__((__weak_import__))
@@ -2,9 +2,8 @@

 #include "fastfetch.h"

-void ffBase64EncodeRaw(uint32_t size, const char *str, uint32_t *out_size, char *output);
-static inline FFstrbuf ffBase64EncodeStrbuf(const FFstrbuf* in)
-{
+void ffBase64EncodeRaw(uint32_t size, const char* str, uint32_t* out_size, char* output);
+static inline FFstrbuf ffBase64EncodeStrbuf(const FFstrbuf* in) {
    FFstrbuf out = ffStrbufCreateA(10 + in->length * 4 / 3);
    ffBase64EncodeRaw(in->length, in->chars, &out.length, out.chars);
    assert(out.length < out.allocated);
@@ -12,9 +11,8 @@ static inline FFstrbuf ffBase64EncodeStrbuf(const FFstrbuf* in)
    return out;
 }

-bool ffBase64DecodeRaw(uint32_t size, const char *str, uint32_t *out_size, char *output);
-static inline FFstrbuf ffBase64DecodeStrbuf(const FFstrbuf* in)
-{
+bool ffBase64DecodeRaw(uint32_t size, const char* str, uint32_t* out_size, char* output);
+static inline FFstrbuf ffBase64DecodeStrbuf(const FFstrbuf* in) {
    FFstrbuf out = ffStrbufCreateA(10 + in->length * 3 / 4);
    ffBase64DecodeRaw(in->length, in->chars, &out.length, out.chars);
    assert(out.length < out.allocated);
@@ -1,239 +0,0 @@
-#include "commandoption.h"
-#include "common/color.h"
-#include "common/printing.h"
-#include "common/time.h"
-#include "common/jsonconfig.h"
-#include "fastfetch_datatext.h"
-#include "modules/modules.h"
-#include "util/stringUtils.h"
-
-#include <ctype.h>
-#include <inttypes.h>
-
-bool ffParseModuleOptions(const char* key, const char* value)
-{
-    if (!ffStrStartsWith(key, "--") || !ffCharIsEnglishAlphabet(key[2])) return false;
-    if (value && !*value) value = NULL;
-    for (FFModuleBaseInfo** modules = ffModuleInfos[toupper(key[2]) - 'A']; *modules; ++modules)
-    {
-        FFModuleBaseInfo* baseInfo = *modules;
-        const char* subKey = ffOptionTestPrefix(key, baseInfo->name);
-        if (subKey != NULL)
-        {
-            if (subKey[0] == '\0' || subKey[0] == '-') // Key is exactly the module name or has a leading '-'
-            {
-                fprintf(stderr, "Error: unknown module key %s\n", key);
-                exit(477);
-            }
-
-            FF_STRBUF_AUTO_DESTROY moduleName = ffStrbufCreateS(baseInfo->name);
-            ffStrbufLowerCase(&moduleName);
-
-            FF_STRBUF_AUTO_DESTROY jsonKey = ffStrbufCreate();
-            bool flag = false;
-            for (const char* p = subKey; *p; ++p)
-            {
-                if (*p == '-')
-                {
-                    if (flag)
-                    {
-                        fprintf(stderr, "Error: invalid double `-` in module key %s\n", key);
-                        exit(477);
-                    }
-                    flag = true;
-                }
-                else
-                {
-                    if (!isalpha((unsigned char)*p) && !isdigit((unsigned char)*p))
-                    {
-                        fprintf(stderr, "Error: invalid character `%c` in module key %s\n", *p, key);
-                        exit(477);
-                    }
-
-                    if (flag)
-                    {
-                        flag = false;
-                        ffStrbufAppendC(&jsonKey, (char) toupper((unsigned char) *p));
-                    }
-                    else
-                        ffStrbufAppendC(&jsonKey, *p);
-                }
-            }
-            fprintf(stderr, "Error: Unsupported module option: %s\n", key);
-            fputs("       Support of module options has been removed. Please add the flag to the JSON config instead.\n", stderr);
-            fprintf(stderr, "       Example (demonstration only): `{ \"modules\": [ { \"type\": \"%s\", \"%s\": %s%s%s } ] }`\n", moduleName.chars, jsonKey.chars, value ? "\"" : "", value ? value : "true", value ? "\"" : "");
-            fputs("       See <https://github.com/fastfetch-cli/fastfetch/wiki/Configuration> for more information.\n", stderr);
-            exit(477);
-        }
-    }
-    return false;
-}
-
-void ffPrepareCommandOption(FFdata* data)
-{
-    //If we don't have a custom structure, use the default one
-    if(data->structure.length == 0)
-        ffStrbufAppendS(&data->structure, FASTFETCH_DATATEXT_STRUCTURE); // Cannot use `ffStrbufSetStatic` here because we will modify the string
-
-    if(ffStrbufContainIgnCaseS(&data->structure, FF_CPUUSAGE_MODULE_NAME))
-        ffPrepareCPUUsage();
-
-    if(ffStrbufContainIgnCaseS(&data->structure, FF_DISKIO_MODULE_NAME))
-    {
-        __attribute__((__cleanup__(ffDestroyDiskIOOptions))) FFDiskIOOptions options;
-        ffInitDiskIOOptions(&options);
-        ffPrepareDiskIO(&options);
-    }
-
-    if(ffStrbufContainIgnCaseS(&data->structure, FF_NETIO_MODULE_NAME))
-    {
-        __attribute__((__cleanup__(ffDestroyNetIOOptions))) FFNetIOOptions options;
-        ffInitNetIOOptions(&options);
-        ffPrepareNetIO(&options);
-    }
-
-    if(instance.config.general.multithreading)
-    {
-        if(ffStrbufContainIgnCaseS(&data->structure, FF_PUBLICIP_MODULE_NAME))
-        {
-            __attribute__((__cleanup__(ffDestroyPublicIpOptions))) FFPublicIPOptions options;
-            ffInitPublicIpOptions(&options);
-            ffPreparePublicIp(&options);
-        }
-
-        if(ffStrbufContainIgnCaseS(&data->structure, FF_WEATHER_MODULE_NAME))
-        {
-            __attribute__((__cleanup__(ffDestroyWeatherOptions))) FFWeatherOptions options;
-            ffInitWeatherOptions(&options);
-            ffPrepareWeather(&options);
-        }
-    }
-}
-
-static void genJsonConfig(FFModuleBaseInfo* baseInfo, void* options, yyjson_mut_doc* doc)
-{
-    yyjson_mut_val* modules = yyjson_mut_obj_get(doc->root, "modules");
-    if (!modules)
-        modules = yyjson_mut_obj_add_arr(doc, doc->root, "modules");
-
-    FF_STRBUF_AUTO_DESTROY type = ffStrbufCreateS(baseInfo->name);
-    ffStrbufLowerCase(&type);
-
-    if (instance.state.fullConfig)
-    {
-        yyjson_mut_val* module = yyjson_mut_obj(doc);
-        yyjson_mut_obj_add_strbuf(doc, module, "type", &type);
-
-        if (baseInfo->generateJsonConfig)
-            baseInfo->generateJsonConfig(options, doc, module);
-
-        if (yyjson_mut_obj_size(module) > 1)
-            yyjson_mut_arr_add_val(modules, module);
-        else
-            yyjson_mut_arr_add_strbuf(doc, modules, &type);
-    }
-    else
-    {
-        yyjson_mut_arr_add_strbuf(doc, modules, &type);
-    }
-}
-
-static void genJsonResult(FFModuleBaseInfo* baseInfo, void* options, yyjson_mut_doc* doc)
-{
-    yyjson_mut_val* module = yyjson_mut_arr_add_obj(doc, doc->root);
-    yyjson_mut_obj_add_str(doc, module, "type", baseInfo->name);
-    if (baseInfo->generateJsonResult)
-        baseInfo->generateJsonResult(options, doc, module);
-    else
-        yyjson_mut_obj_add_str(doc, module, "error", "Unsupported for JSON format");
-}
-
-static void parseStructureCommand(
-    const char* line,
-    void (*fn)(FFModuleBaseInfo* baseInfo, void* options, yyjson_mut_doc* jsonDoc),
-    yyjson_mut_doc* jsonDoc
-)
-{
-    if(ffCharIsEnglishAlphabet(line[0]))
-    {
-        for (FFModuleBaseInfo** modules = ffModuleInfos[toupper(line[0]) - 'A']; *modules; ++modules)
-        {
-            FFModuleBaseInfo* baseInfo = *modules;
-            if (ffStrEqualsIgnCase(line, baseInfo->name))
-            {
-                uint8_t optionBuf[FF_OPTION_MAX_SIZE];
-                baseInfo->initOptions(optionBuf);
-                if (__builtin_expect(jsonDoc != NULL, false))
-                    fn(baseInfo, optionBuf, jsonDoc);
-                else
-                    baseInfo->printModule(optionBuf);
-                baseInfo->destroyOptions(optionBuf);
-                return;
-            }
-        }
-    }
-
-    ffPrintError(line, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "<no implementation provided>");
-}
-
-void ffPrintCommandOption(FFdata* data, yyjson_mut_doc* jsonDoc)
-{
-    //Parse the structure and call the modules
-    int32_t thres = instance.config.display.stat;
-    uint32_t startIndex = 0;
-    while (startIndex < data->structure.length)
-    {
-        uint32_t colonIndex = ffStrbufNextIndexC(&data->structure, startIndex, ':');
-        data->structure.chars[colonIndex] = '\0';
-
-        double ms = 0;
-        if(thres >= 0)
-            ms = ffTimeGetTick();
-
-        parseStructureCommand(data->structure.chars + startIndex, genJsonResult, jsonDoc);
-
-        if(thres >= 0)
-        {
-            ms = ffTimeGetTick() - ms;
-
-            if (jsonDoc)
-            {
-                yyjson_mut_val* moduleJson = yyjson_mut_arr_get_last(jsonDoc->root);
-                yyjson_mut_obj_add_real(jsonDoc, moduleJson, "stat", ms);
-            }
-            else
-            {
-                char str[64];
-                int len = snprintf(str, sizeof str, "%.3fms", ms);
-                if (thres > 0)
-                    snprintf(str, sizeof str, "\e[%sm%.3fms\e[m", (ms <= thres ? FF_COLOR_FG_GREEN : ms <= 2 * thres ? FF_COLOR_FG_YELLOW : FF_COLOR_FG_RED), ms);
-                printf("\e7\e[1A\e[9999999C\e[%dD%s\e8", len, str); // Save; Up 1; Right 9999999; Left <len>; Print <str>; Load
-            }
-        }
-
-        #if defined(_WIN32)
-            if (!jsonDoc && !instance.config.display.noBuffer) fflush(stdout);
-        #endif
-
-        startIndex = colonIndex + 1;
-    }
-}
-
-void ffMigrateCommandOptionToJsonc(FFdata* data, yyjson_mut_doc* jsonDoc)
-{
-    //If we don't have a custom structure, use the default one
-    if(data->structure.length == 0)
-        ffStrbufAppendS(&data->structure, FASTFETCH_DATATEXT_STRUCTURE); // Cannot use `ffStrbufSetStatic` here because we will modify the string
-
-    //Parse the structure and call the modules
-    uint32_t startIndex = 0;
-    while (startIndex < data->structure.length)
-    {
-        uint32_t colonIndex = ffStrbufNextIndexC(&data->structure, startIndex, ':');
-        data->structure.chars[colonIndex] = '\0';
-
-        parseStructureCommand(data->structure.chars + startIndex, genJsonConfig, jsonDoc);
-
-        startIndex = colonIndex + 1;
-    }
-}
@@ -1,15 +1,8 @@
 #pragma once

-#include "fastfetch.h"
-
-// Things only needed by fastfetch
-typedef struct FFdata
-{
-    FFstrbuf structure;
-    bool configLoaded;
-} FFdata;
+#include "common/ffdata.h"

 void ffPrepareCommandOption(FFdata* data);
-void ffPrintCommandOption(FFdata* data, yyjson_mut_doc* jsonDoc);
-void ffMigrateCommandOptionToJsonc(FFdata* data, yyjson_mut_doc* jsonDoc);
+void ffPrintCommandOption(FFdata* data);
+void ffMigrateCommandOptionToJsonc(FFdata* data);
 bool ffParseModuleOptions(const char* key, const char* value);
@@ -1,13 +1,12 @@
 #pragma once

 #ifdef FF_HAVE_DBUS
-#include <dbus/dbus.h>
+    #include <dbus/dbus.h>

-#include "util/FFstrbuf.h"
-#include "common/library.h"
+    #include "common/FFstrbuf.h"
+    #include "common/library.h"

-typedef struct FFDBusLibrary
-{
+typedef struct FFDBusLibrary {
    FF_LIBRARY_SYMBOL(dbus_bus_get)
    FF_LIBRARY_SYMBOL(dbus_message_new_method_call)
    FF_LIBRARY_SYMBOL(dbus_message_append_args)
@@ -19,15 +18,15 @@ typedef struct FFDBusLibrary
    FF_LIBRARY_SYMBOL(dbus_message_iter_next)
    FF_LIBRARY_SYMBOL(dbus_message_unref)
    FF_LIBRARY_SYMBOL(dbus_connection_send_with_reply_and_block)
+    FF_LIBRARY_SYMBOL(dbus_connection_unref)
 } FFDBusLibrary;

-typedef struct FFDBusData
-{
+typedef struct FFDBusData {
    const FFDBusLibrary* lib;
    DBusConnection* connection;
 } FFDBusData;

-const char* ffDBusLoadData(DBusBusType busType, FFDBusData* data); //Returns an error message or NULL on success
+const char* ffDBusLoadData(DBusBusType busType, FFDBusData* data); // Returns an error message or NULL on success
 bool ffDBusGetString(FFDBusData* dbus, DBusMessageIter* iter, FFstrbuf* result);
 bool ffDBusGetBool(FFDBusData* dbus, DBusMessageIter* iter, bool* result);
 bool ffDBusGetUint(FFDBusData* dbus, DBusMessageIter* iter, uint32_t* result);
@@ -36,10 +35,12 @@ DBusMessage* ffDBusGetProperty(FFDBusData* dbus, const char* busName, const char
 bool ffDBusGetPropertyString(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property, FFstrbuf* result);
 bool ffDBusGetInt(FFDBusData* dbus, DBusMessageIter* iter, int32_t* result);
 bool ffDBusGetPropertyUint(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property, uint32_t* result);
+void ffDBusDestroyData(FFDBusData* data);

-static inline DBusMessage* ffDBusGetAllProperties(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface)
-{
+static inline DBusMessage* ffDBusGetAllProperties(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface) {
    return ffDBusGetMethodReply(dbus, busName, objectPath, "org.freedesktop.DBus.Properties", "GetAll", interface, NULL);
 }

+    #define FF_DBUS_AUTO_DESTROY_DATA FF_A_CLEANUP(ffDBusDestroyData)
+
 #endif // FF_HAVE_DBUS
@@ -0,0 +1,37 @@
+#pragma once
+
+#include "fastfetch.h"
+#include "common/time.h"
+
+static inline const char* ffFindFileName(const char* file) {
+    const char* lastSlash = __builtin_strrchr(file, '/');
+#ifdef _WIN32
+    if (lastSlash == NULL) {
+        lastSlash = __builtin_strrchr(file, '\\');
+    }
+#endif
+    if (lastSlash != NULL) {
+        return lastSlash + 1;
+    }
+    return file;
+}
+
+#ifndef NDEBUG
+    #define FF_DEBUG_PRINT(file_, line_, format_, ...)                                                                                      \
+        do {                                                                                                                                \
+            if (instance.config.display.debugMode)                                                                                          \
+                fprintf(stderr, "[%s%4d, %s] " format_ "\n", ffFindFileName(file_), line_, ffTimeToTimeStr(ffTimeGetNow()), ##__VA_ARGS__); \
+        } while (0)
+#else
+    #define FF_DEBUG_PRINT(file_, line_, format_, ...) \
+        do {                                           \
+        } while (0)
+#endif
+
+#define FF_DEBUG(format, ...) FF_DEBUG_PRINT(__FILE__, __LINE__, format, ##__VA_ARGS__)
+
+#if _WIN32
+const char* ffDebugWin32Error(DWORD errorCode);
+const char* ffDebugNtStatus(NTSTATUS status);
+const char* ffDebugHResult(HRESULT hr);
+#endif
@@ -1,3 +1,5 @@
+#pragma once
+
 #include "fastfetch.h"

 void ffDurationAppendNum(uint64_t totalSeconds, FFstrbuf* result);
@@ -1,7 +1,7 @@
 #pragma once

 #include <stdint.h>
-#include "util/FFstrbuf.h"
+#include "common/FFstrbuf.h"

 void ffEdidGetVendorAndModel(const uint8_t edid[128], FFstrbuf* result);
 bool ffEdidGetName(const uint8_t edid[128], FFstrbuf* name);
@@ -10,3 +10,4 @@ void ffEdidGetPhysicalResolution(const uint8_t edid[128], uint32_t* width, uint3
 void ffEdidGetPhysicalSize(const uint8_t edid[128], uint32_t* width, uint32_t* height); // in mm
 void ffEdidGetSerialAndManufactureDate(const uint8_t edid[128], uint32_t* serial, uint16_t* year, uint16_t* week);
 bool ffEdidGetHdrCompatible(const uint8_t* edid, uint32_t length);
+bool ffEdidIsValid(const uint8_t edid[128], uint32_t length);
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "common/FFstrbuf.h"
+
+typedef enum FF_A_PACKED FFDataResultDocType {
+    FF_RESULT_DOC_TYPE_DEFAULT = 0,
+    FF_RESULT_DOC_TYPE_JSON,
+    FF_RESULT_DOC_TYPE_CONFIG,
+    FF_RESULT_DOC_TYPE_CONFIG_FULL,
+} FFDataResultDocType;
+
+// FFdata aggregates configuration, generation parameters, and output state used by fastfetch.
+// It holds the parsed configuration document, a mutable JSON document for results, and related metadata.
+typedef struct FFdata {
+    yyjson_doc* configDoc;       // Parsed JSON configuration document
+    yyjson_mut_doc* resultDoc;   // Mutable JSON document for storing results
+    FFstrbuf structure;          // Custom output structure from command line
+    FFstrbuf structureDisabled;  // Disabled modules in the output structure from command line
+    FFstrbuf genConfigPath;      // Path to generate configuration file
+    FFDataResultDocType docType; // Type of result document
+    bool configLoaded;
+} FFdata;
@@ -1,221 +0,0 @@
-#include "fastfetch.h"
-#include "common/font.h"
-
-#include <string.h>
-#include <ctype.h>
-
-void ffFontInit(FFfont* font)
-{
-    // Ensure no memory allocates
-    ffStrbufInit(&font->pretty);
-    ffStrbufInit(&font->name);
-    ffStrbufInit(&font->size);
-    ffListInit(&font->styles, sizeof(FFstrbuf));
-}
-
-static void strbufAppendNSExcludingC(FFstrbuf* strbuf, uint32_t length, const char* value, char exclude)
-{
-    if(value == NULL || length == 0)
-        return;
-
-    ffStrbufEnsureFree(strbuf, length);
-
-    for(uint32_t i = 0; i < length; i++)
-    {
-        if(value[i] != exclude)
-        strbuf->chars[strbuf->length++] = value[i];
-    }
-
-    strbuf->chars[strbuf->length] = '\0';
-}
-
-static void fontInitPretty(FFfont* font)
-{
-    ffStrbufAppend(&font->pretty, &font->name);
-
-    if(font->size.length == 0 && font->styles.length == 0)
-        return;
-    else if(font->pretty.length == 0)
-        ffStrbufAppendS(&font->pretty, "default");
-
-    ffStrbufAppendS(&font->pretty, " (");
-
-    if(font->size.length > 0)
-    {
-        ffStrbufAppend(&font->pretty, &font->size);
-        ffStrbufAppendS(&font->pretty, "pt");
-
-        if(font->styles.length > 0)
-            ffStrbufAppendS(&font->pretty, ", ");
-    }
-
-    for(uint32_t i = 0; i < font->styles.length; i++)
-    {
-        ffStrbufAppend(&font->pretty, FF_LIST_GET(FFstrbuf, font->styles, i));
-
-        if(i < font->styles.length - 1)
-            ffStrbufAppendS(&font->pretty, ", ");
-    }
-
-    ffStrbufAppendC(&font->pretty, ')');
-}
-
-void ffFontInitQt(FFfont* font, const char* data)
-{
-    ffFontInit(font);
-
-    //See https://doc.qt.io/qt-5/qfont.html#toString
-
-    //Family
-    data = ffStrbufAppendSUntilC(&font->name, data, ',');
-    ffStrbufTrim(&font->name, ' ');
-    if (!data) goto exit;
-    data++;
-
-    //Size
-    data = ffStrbufAppendSUntilC(&font->size, data, ',');
-    ffStrbufTrim(&font->size, ' ');
-    if (!data) goto exit;
-    data++;
-
-    //Style
-    data = strrchr(data, ',');
-    if (!data) goto exit;
-    data++;
-    if (isalpha(*data))
-    {
-        do
-        {
-            FFstrbuf* style = (FFstrbuf*) ffListAdd(&font->styles);
-            ffStrbufInit(style);
-            data = ffStrbufAppendSUntilC(style, data, ' ');
-            if (data) data++;
-        } while (data);
-    }
-
-exit:
-    fontInitPretty(font);
-}
-
-static void fontPangoParseWord(const char** data, FFfont* font, FFstrbuf* alternativeBuffer)
-{
-    while(**data == ' ' || **data == '\t' || **data == ',')
-        ++(*data);
-
-    const char* wordStart = *data;
-
-    while(**data != ' ' && **data != '\t' && **data != ',' && **data != '\0' && **data != '`' && **data != '\\')
-        ++(*data);
-
-    uint32_t wordLength = (uint32_t) (*data - wordStart);
-    if(wordLength == 0)
-        return;
-
-    if(**data == '\0' || **data == '`' || **data == '\\')
-    {
-        ffStrbufAppendNS(&font->size, wordLength, wordStart);
-        if(ffStrbufEndsWithS(&font->size, "px"))
-            ffStrbufSubstrBefore(&font->size, font->size.length - 2);
-
-        double dummy;
-        if(sscanf(font->size.chars, "%lf", &dummy) == 1)
-            return;
-
-        ffStrbufClear(&font->size);
-    }
-
-    if(
-        strncasecmp(wordStart, "Ultra", 5) == 0 ||
-        strncasecmp(wordStart, "Extra", 5) == 0 ||
-        strncasecmp(wordStart, "Semi", 4) == 0 ||
-        strncasecmp(wordStart, "Demi", 4) == 0 ||
-        strncasecmp(wordStart, "Normal", wordLength) == 0 ||
-        strncasecmp(wordStart, "Roman", wordLength) == 0 ||
-        strncasecmp(wordStart, "Oblique", wordLength) == 0 ||
-        strncasecmp(wordStart, "Italic", wordLength) == 0 ||
-        strncasecmp(wordStart, "Thin", wordLength) == 0 ||
-        strncasecmp(wordStart, "Light", wordLength) == 0 ||
-        strncasecmp(wordStart, "Bold", wordLength) == 0 ||
-        strncasecmp(wordStart, "Black", wordLength) == 0 ||
-        strncasecmp(wordStart, "Condensed", wordLength) == 0 ||
-        strncasecmp(wordStart, "Expanded", wordLength) == 0
-    ) {
-        if(alternativeBuffer == NULL)
-        {
-            alternativeBuffer = (FFstrbuf*) ffListAdd(&font->styles);
-            ffStrbufInit(alternativeBuffer);
-        }
-
-        strbufAppendNSExcludingC(alternativeBuffer, wordLength, wordStart, '-');
-
-        if(
-            strncasecmp(wordStart, "Ultra ", 6) == 0 ||
-            strncasecmp(wordStart, "Extra ", 6) == 0 ||
-            strncasecmp(wordStart, "Semi ", 5) == 0 ||
-            strncasecmp(wordStart, "Demi ", 5) == 0
-        ) {
-            fontPangoParseWord(data, font, alternativeBuffer);
-        }
-
-        return;
-    }
-
-    if(alternativeBuffer != NULL)
-    {
-        strbufAppendNSExcludingC(alternativeBuffer, wordLength, wordStart, '-');
-        return;
-    }
-
-    if(font->name.length > 0)
-        ffStrbufAppendC(&font->name, ' ');
-    ffStrbufAppendNS(&font->name, wordLength, wordStart);
-}
-
-void ffFontInitPango(FFfont* font, const char* data)
-{
-    ffFontInit(font);
-
-    while(*data != '\0' && *data != '`' && *data != '\\')
-        fontPangoParseWord(&data, font, NULL);
-
-    fontInitPretty(font);
-}
-
-void ffFontInitValues(FFfont* font, const char* name, const char* size)
-{
-    ffFontInit(font);
-
-    ffStrbufAppendS(&font->name, name);
-    ffStrbufTrim(&font->name, '"');
-    ffStrbufAppendS(&font->size, size);
-
-    fontInitPretty(font);
-}
-
-void ffFontInitWithSpace(FFfont* font, const char* rawName)
-{
-    const char* pspace = strrchr(rawName, ' ');
-    if(pspace == NULL)
-    {
-        ffFontInitCopy(font, rawName);
-        return;
-    }
-
-    ffFontInit(font);
-
-    ffStrbufAppendNS(&font->name, (uint32_t)(pspace - rawName), rawName);
-    ffStrbufAppendS(&font->size, pspace + 1);
-
-    fontInitPretty(font);
-}
-
-void ffFontDestroy(FFfont* font)
-{
-    ffStrbufDestroy(&font->pretty);
-    ffStrbufDestroy(&font->name);
-    ffStrbufDestroy(&font->size);
-
-    FF_LIST_FOR_EACH(FFstrbuf, str, font->styles)
-        ffStrbufDestroy(str);
-    ffListDestroy(&font->styles);
-}
@@ -1,10 +1,9 @@
 #pragma once

-#include "util/FFstrbuf.h"
-#include "util/FFlist.h"
+#include "common/FFstrbuf.h"
+#include "common/FFlist.h"

-typedef struct FFfont
-{
+typedef struct FFfont {
    FFstrbuf pretty;
    FFstrbuf name;
    FFstrbuf size;
@@ -15,10 +14,12 @@ void ffFontInit(FFfont* font);
 void ffFontInitQt(FFfont* font, const char* data);
 void ffFontInitPango(FFfont* font, const char* data);
 void ffFontInitValues(FFfont* font, const char* name, const char* size);
+void ffFontInitXlfd(FFfont* font, const char* xlfd);
+void ffFontInitXft(FFfont* font, const char* xft);
+void ffFontInitMoveValues(FFfont* font, FFstrbuf* name, FFstrbuf* size, FFstrbuf* style);
 void ffFontInitWithSpace(FFfont* font, const char* rawName);
 void ffFontDestroy(FFfont* font);

-static inline void ffFontInitCopy(FFfont* font, const char* name)
-{
+static inline void ffFontInitCopy(FFfont* font, const char* name) {
    ffFontInitValues(font, name, NULL);
 }
@@ -1,41 +1,9 @@
 #pragma once

-#include "util/FFstrbuf.h"
+#include "common/argType.h"

-typedef enum __attribute__((__packed__)) FFformatArgType
-{
-    FF_FORMAT_ARG_TYPE_NULL = 0,
-    FF_FORMAT_ARG_TYPE_UINT,
-    FF_FORMAT_ARG_TYPE_UINT64,
-    FF_FORMAT_ARG_TYPE_UINT16,
-    FF_FORMAT_ARG_TYPE_UINT8,
-    FF_FORMAT_ARG_TYPE_INT,
-    FF_FORMAT_ARG_TYPE_STRING,
-    FF_FORMAT_ARG_TYPE_STRBUF,
-    FF_FORMAT_ARG_TYPE_FLOAT,
-    FF_FORMAT_ARG_TYPE_DOUBLE,
-    FF_FORMAT_ARG_TYPE_LIST,
-    FF_FORMAT_ARG_TYPE_BOOL
-} FFformatArgType;
-
-#define FF_FORMAT_ARG(variable, var_name) { _Generic((variable), \
-        uint32_t: FF_FORMAT_ARG_TYPE_UINT, \
-        uint64_t: FF_FORMAT_ARG_TYPE_UINT64, \
-        uint16_t: FF_FORMAT_ARG_TYPE_UINT16, \
-        uint8_t: FF_FORMAT_ARG_TYPE_UINT8, \
-        int32_t: FF_FORMAT_ARG_TYPE_INT, \
-        char*: FF_FORMAT_ARG_TYPE_STRING, \
-        const char*: FF_FORMAT_ARG_TYPE_STRING, \
-        FFstrbuf: FF_FORMAT_ARG_TYPE_STRBUF, \
-        float: FF_FORMAT_ARG_TYPE_FLOAT, \
-        double: FF_FORMAT_ARG_TYPE_DOUBLE, \
-        FFlist: FF_FORMAT_ARG_TYPE_LIST, \
-        bool: FF_FORMAT_ARG_TYPE_BOOL \
-    ), _Generic((variable), char*: (variable), const char*: (variable), default: &(variable) ), (var_name) }
-
-typedef struct FFformatarg
-{
-    FFformatArgType type;
+typedef struct FFformatarg {
+    FFArgType type;
    const void* value;
    const char* name; // argument name, must start with an alphabet
 } FFformatarg;
@@ -1,3 +1,5 @@
+#pragma once
+
 #include "fastfetch.h"

 bool ffFreqAppendNum(uint32_t mhz, FFstrbuf* result);
@@ -5,20 +5,22 @@ extern "C" {
 #include <File.h>
 #include <AppFileInfo.h>

-bool ffGetFileVersion(const char* filePath, FFstrbuf* version)
-{
+bool ffGetFileVersion(const char* filePath, FFstrbuf* version) {
    BFile f(filePath, B_READ_ONLY);
-    if (f.InitCheck() != B_OK)
+    if (f.InitCheck() != B_OK) {
        return false;
+    }

    BAppFileInfo fileInfo(&f);
-    if (f.InitCheck() != B_OK)
+    if (f.InitCheck() != B_OK) {
        return false;
+    }

    version_info info;
-    if (fileInfo.GetVersionInfo(&info, B_SYSTEM_VERSION_KIND) != B_OK)
+    if (fileInfo.GetVersionInfo(&info, B_SYSTEM_VERSION_KIND) != B_OK) {
        return false;
+    }

-    ffStrbufSetF(version, "%d.%d.%d", (int)info.major, (int)info.middle, (int)info.minor);
+    ffStrbufSetF(version, "%d.%d.%d", (int) info.major, (int) info.middle, (int) info.minor);
    return true;
 }
@@ -1,3 +1,3 @@
-#include "util/FFstrbuf.h"
+#include "common/FFstrbuf.h"

 bool ffGetFileVersion(const char* filePath, FFstrbuf* version);
@@ -1,21 +1,25 @@
 #include "FFPlatform_private.h"
-#include "util/stringUtils.h"
-#include "common/io/io.h"
+#include "common/stringUtils.h"
+#include "common/io.h"
 #include "detection/version/version.h"

-void ffPlatformInit(FFPlatform* platform)
-{
+void ffPlatformInit(FFPlatform* platform) {
    ffStrbufInit(&platform->homeDir);
    ffStrbufInit(&platform->cacheDir);
-    ffListInit(&platform->configDirs, sizeof(FFstrbuf));
-    ffListInit(&platform->dataDirs, sizeof(FFstrbuf));
+    ffListInit(&platform->configDirs);
+    ffListInit(&platform->dataDirs);
    ffStrbufInit(&platform->exePath);
+    ffStrbufInit(&platform->cwd);

    ffStrbufInit(&platform->userName);
    ffStrbufInit(&platform->fullUserName);
    ffStrbufInit(&platform->hostName);
    ffStrbufInit(&platform->userShell);

+#ifdef _WIN32
+    ffStrbufInit(&platform->sid);
+#endif
+
    FFPlatformSysinfo* info = &platform->sysinfo;

    ffStrbufInit(&info->name);
@@ -25,57 +29,65 @@ void ffPlatformInit(FFPlatform* platform)

    ffPlatformInitImpl(platform);

-    if(info->name.length == 0)
+    if (info->name.length == 0) {
        ffStrbufSetStatic(&info->name, ffVersionResult.sysName);
+    }

-    if(info->architecture.length == 0)
+    if (info->architecture.length == 0) {
        ffStrbufSetStatic(&info->architecture, ffVersionResult.architecture);
+    }
 }

-void ffPlatformDestroy(FFPlatform* platform)
-{
+void ffPlatformDestroy(FFPlatform* platform) {
    ffStrbufDestroy(&platform->homeDir);
    ffStrbufDestroy(&platform->cacheDir);

-    FF_LIST_FOR_EACH(FFstrbuf, dir, platform->configDirs)
+    FF_LIST_FOR_EACH (FFstrbuf, dir, platform->configDirs) {
        ffStrbufDestroy(dir);
+    }
    ffListDestroy(&platform->configDirs);

-    FF_LIST_FOR_EACH(FFstrbuf, dir, platform->dataDirs)
+    FF_LIST_FOR_EACH (FFstrbuf, dir, platform->dataDirs) {
        ffStrbufDestroy(dir);
+    }
    ffListDestroy(&platform->dataDirs);
    ffStrbufDestroy(&platform->exePath);
+    ffStrbufDestroy(&platform->cwd);

    ffStrbufDestroy(&platform->userName);
    ffStrbufDestroy(&platform->hostName);
    ffStrbufDestroy(&platform->userShell);
    ffStrbufDestroy(&platform->fullUserName);

+#ifdef _WIN32
+    ffStrbufDestroy(&platform->sid);
+#endif
+
    FFPlatformSysinfo* info = &platform->sysinfo;
    ffStrbufDestroy(&info->architecture);
    ffStrbufDestroy(&info->name);
    ffStrbufDestroy(&info->release);
    ffStrbufDestroy(&info->version);
-    ffStrbufDestroy(&info->displayVersion);
 }

-void ffPlatformPathAddAbsolute(FFlist* dirs, const char* path)
-{
-    if (!ffPathExists(path, FF_PATHTYPE_DIRECTORY))
+void ffPlatformPathAddAbsolute(FFlist* dirs, const char* path) {
+    if (!ffPathExists(path, FF_PATHTYPE_DIRECTORY)) {
        return;
+    }

    FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreateS(path);
    ffStrbufEnsureEndsWithC(&buffer, '/');
-    if (!ffListContains(dirs, &buffer, (void*) ffStrbufEqual))
-        ffStrbufInitMove((FFstrbuf*) ffListAdd(dirs), &buffer);
+    if (!FF_LIST_CONTAINS(*dirs, &buffer, ffStrbufEqual)) {
+        ffStrbufInitMove(FF_LIST_ADD(FFstrbuf, *dirs), &buffer);
+    }
 }

-void ffPlatformPathAddHome(FFlist* dirs, const FFPlatform* platform, const char* suffix)
-{
+void ffPlatformPathAddHome(FFlist* dirs, const FFPlatform* platform, const char* suffix) {
    FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreateA(64);
    ffStrbufAppend(&buffer, &platform->homeDir);
    ffStrbufAppendS(&buffer, suffix);
    ffStrbufEnsureEndsWithC(&buffer, '/');
-    if (ffPathExists(buffer.chars, FF_PATHTYPE_DIRECTORY) && !ffListContains(dirs, &buffer, (void*) ffStrbufEqual))
-        ffStrbufInitMove((FFstrbuf*) ffListAdd(dirs), &buffer);
+    if (ffPathExists(buffer.chars, FF_PATHTYPE_DIRECTORY) && !FF_LIST_CONTAINS(*dirs, &buffer, ffStrbufEqual)) {
+        ffStrbufInitMove(FF_LIST_ADD(FFstrbuf, *dirs), &buffer);
+    }
 }
@@ -1,6 +1,6 @@
 #pragma once

-#include "FFPlatform.h"
+#include "common/FFPlatform.h"

 void ffPlatformInitImpl(FFPlatform* platform);

@@ -0,0 +1,320 @@
+#include "FFPlatform_private.h"
+#include "common/FFstrbuf.h"
+#include "common/arrayUtils.h"
+#include "common/stringUtils.h"
+#include "common/io.h"
+#include "fastfetch_config.h"
+
+#include <unistd.h>
+#include <pwd.h>
+#include <limits.h>
+#include <sys/utsname.h>
+#include <paths.h>
+
+#ifdef __APPLE__
+    #include <mach-o/dyld.h>
+    #include <sys/sysctl.h>
+#elif defined(__FreeBSD__) || defined(__NetBSD__)
+    #include <sys/sysctl.h>
+#elif defined(__OpenBSD__)
+    #include <sys/sysctl.h>
+    #include <kvm.h>
+    #include "common/path.h"
+#elif defined(__HAIKU__)
+    #include <image.h>
+    #include <OS.h>
+#endif
+
+static void getExePath(FFPlatform* platform) {
+    char exePath[PATH_MAX];
+#if defined(__linux__) || defined(__GNU__)
+    ssize_t exePathLen = readlink("/proc/self/exe", exePath, sizeof(exePath) - 1);
+    if (exePathLen >= 0) {
+        exePath[exePathLen] = '\0';
+    }
+#elif defined(__APPLE__)
+    uint32_t exePathLen = sizeof(exePath);
+    if (_NSGetExecutablePath(exePath, &exePathLen) == 0) {
+        exePathLen = (uint32_t) strlen(exePath);
+    } else {
+        exePathLen = 0;
+    }
+#elif defined(__FreeBSD__) || defined(__NetBSD__)
+    size_t exePathLen = sizeof(exePath);
+    if (sysctl(
+            (int[]) { CTL_KERN,
+    #ifdef __FreeBSD__
+                KERN_PROC,
+                KERN_PROC_PATHNAME,
+                (pid_t) platform->pid
+    #else
+                KERN_PROC_ARGS,
+                (pid_t) platform->pid,
+                KERN_PROC_PATHNAME
+    #endif
+            },
+            4,
+            exePath,
+            &exePathLen,
+            NULL,
+            0) < 0)
+        exePathLen = 0;
+    else {
+        exePathLen--; // remove terminating NUL
+    }
+#elif defined(__OpenBSD__)
+    // OpenBSD doesn't have a reliable way to get the executable path.
+    // Current implementation uses argv[0], which can be easily spoofed.
+    // See #2195
+    size_t exePathLen = 0;
+    kvm_t* kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, NULL);
+    if (kd) {
+        int kpCount;
+        struct kinfo_proc* kp = kvm_getprocs(kd, KERN_PROC_PID, (pid_t) platform->pid, sizeof(*kp), &kpCount);
+        if (kp && kpCount == 1) {
+            char** argv = kvm_getargv(kd, kp, 0);
+            if (argv && argv[0]) {
+                char* arg0 = argv[0];
+                if (arg0[0]) {
+                    if (strchr(arg0, '/') != NULL) // likely a path (absolute or relative)
+                    {
+                        exePathLen = strlen(arg0);
+                        if (exePathLen < ARRAY_SIZE(exePath)) {
+                            memcpy(exePath, arg0, exePathLen);
+                            exePath[exePathLen] = '\0';
+                        } else {
+                            exePathLen = 0;
+                        }
+                    } else {
+                        FF_STRBUF_AUTO_DESTROY tmpPath = ffStrbufCreate();
+                        if (ffFindExecutableInPath(arg0, &tmpPath) == NULL && tmpPath.length < ARRAY_SIZE(exePath)) {
+                            memcpy(exePath, tmpPath.chars, tmpPath.length + 1);
+                            exePathLen = tmpPath.length;
+                        }
+                    }
+
+                    if (exePathLen > 0) {
+                        struct stat st;
+                        if (stat(exePath, &st) == 0 && S_ISREG(st.st_mode)) {
+                            int cntp;
+                            struct kinfo_file* kf = kvm_getfiles(kd, KERN_FILE_BYPID, platform->pid, sizeof(*kf), &cntp);
+                            if (kf) {
+                                int i;
+                                for (i = 0; i < cntp; i++) {
+                                    if (kf[i].fd_fd == KERN_FILE_TEXT) {
+                                        // KERN_FILE_TEXT is the executable file, not a shared library, and should be unique in the list.
+                                        if (st.st_dev != (dev_t) kf[i].va_fsid || st.st_ino != (ino_t) kf[i].va_fileid) {
+                                            i = -1;
+                                        }
+                                        break;
+                                    }
+                                }
+                                if (i < 0) {
+                                    exePathLen = 0;
+                                }
+                            } else {
+                                // If we can't get the list of open files, we can't verify that the file is actually the executable
+                                // Assume it is
+                            }
+                        } else {
+                            exePathLen = 0;
+                        }
+                    }
+                }
+            }
+        }
+        kvm_close(kd);
+    }
+#elif defined(__sun)
+    ssize_t exePathLen = readlink("/proc/self/path/a.out", exePath, sizeof(exePath) - 1);
+    if (exePathLen >= 0) {
+        exePath[exePathLen] = '\0';
+    }
+#elif defined(__HAIKU__)
+    size_t exePathLen = 0;
+    image_info info;
+    int32 cookie = 0;
+
+    while (get_next_image_info(B_CURRENT_TEAM, &cookie, &info) == B_OK) {
+        if (info.type == B_APP_IMAGE) {
+            exePathLen = strlcpy(exePath, info.name, sizeof(exePath));
+            break;
+        }
+    }
+#endif
+    if (exePathLen > 0) {
+        ffStrbufEnsureFree(&platform->exePath, PATH_MAX);
+        if (realpath(exePath, platform->exePath.chars)) {
+            ffStrbufRecalculateLength(&platform->exePath);
+        } else {
+            ffStrbufSetNS(&platform->exePath, (uint32_t) exePathLen, exePath);
+        }
+    }
+}
+
+static void platformPathAddEnv(FFlist* dirs, const char* env) {
+    const char* envValue = getenv(env);
+    if (!ffStrSet(envValue)) {
+        return;
+    }
+
+    FF_STRBUF_AUTO_DESTROY value = ffStrbufCreateA(64);
+    ffStrbufAppendS(&value, envValue);
+
+    uint32_t startIndex = 0;
+    while (startIndex < value.length) {
+        uint32_t colonIndex = ffStrbufNextIndexC(&value, startIndex, ':');
+        value.chars[colonIndex] = '\0';
+
+        if (!ffStrSet(value.chars + startIndex)) {
+            startIndex = colonIndex + 1;
+            continue;
+        }
+
+        ffPlatformPathAddAbsolute(dirs, value.chars + startIndex);
+
+        startIndex = colonIndex + 1;
+    }
+}
+
+static void getHomeDir(FFPlatform* platform, const struct passwd* pwd) {
+    const char* home = pwd ? pwd->pw_dir : getenv("HOME");
+    ffStrbufAppendS(&platform->homeDir, home);
+    ffStrbufEnsureEndsWithC(&platform->homeDir, '/');
+}
+
+static void getCacheDir(FFPlatform* platform) {
+    const char* cache = getenv("XDG_CACHE_HOME");
+    if (ffStrSet(cache)) {
+        ffStrbufAppendS(&platform->cacheDir, cache);
+        ffStrbufEnsureEndsWithC(&platform->cacheDir, '/');
+    } else {
+        ffStrbufAppend(&platform->cacheDir, &platform->homeDir);
+        ffStrbufAppendS(&platform->cacheDir, ".cache/");
+    }
+}
+
+static void getConfigDirs(FFPlatform* platform) {
+    // Always make sure `${XDG_CONFIG_HOME:-$HOME/.config}` is the first entry
+    platformPathAddEnv(&platform->configDirs, "XDG_CONFIG_HOME");
+    ffPlatformPathAddHome(&platform->configDirs, platform, ".config/");
+
+#if defined(__APPLE__)
+    ffPlatformPathAddHome(&platform->configDirs, platform, "Library/Preferences/");
+    ffPlatformPathAddHome(&platform->configDirs, platform, "Library/Application Support/");
+#endif
+#if defined(__HAIKU__)
+    ffPlatformPathAddHome(&platform->configDirs, platform, "config/settings/");
+#endif
+
+    ffPlatformPathAddHome(&platform->configDirs, platform, "");
+    platformPathAddEnv(&platform->configDirs, "XDG_CONFIG_DIRS");
+
+#if !defined(__APPLE__)
+    ffPlatformPathAddAbsolute(&platform->configDirs, FASTFETCH_TARGET_DIR_ETC "/xdg/");
+#endif
+
+    ffPlatformPathAddAbsolute(&platform->configDirs, FASTFETCH_TARGET_DIR_ETC "/");
+    ffPlatformPathAddAbsolute(&platform->configDirs, FASTFETCH_TARGET_DIR_INSTALL_SYSCONF "/");
+}
+
+static void getDataDirs(FFPlatform* platform) {
+    platformPathAddEnv(&platform->dataDirs, "XDG_DATA_HOME");
+    ffPlatformPathAddHome(&platform->dataDirs, platform, ".local/share/");
+
+    // Add ${currentExePath}/../share
+    if (platform->exePath.length > 0) {
+        FF_STRBUF_AUTO_DESTROY path = ffStrbufCreateCopy(&platform->exePath);
+        ffStrbufSubstrBeforeLastC(&path, '/');
+        ffStrbufSubstrBeforeLastC(&path, '/');
+        ffStrbufAppendS(&path, "/share");
+        ffPlatformPathAddAbsolute(&platform->dataDirs, path.chars);
+    }
+
+#ifdef __APPLE__
+    ffPlatformPathAddHome(&platform->dataDirs, platform, "Library/Application Support/");
+#endif
+
+    ffPlatformPathAddHome(&platform->dataDirs, platform, "");
+    platformPathAddEnv(&platform->dataDirs, "XDG_DATA_DIRS");
+#ifdef _PATH_LOCALBASE
+    ffPlatformPathAddAbsolute(&platform->dataDirs, _PATH_LOCALBASE "/share/");
+#endif
+    ffPlatformPathAddAbsolute(&platform->dataDirs, FASTFETCH_TARGET_DIR_USR "/local/share/");
+    ffPlatformPathAddAbsolute(&platform->dataDirs, FASTFETCH_TARGET_DIR_USR "/share/");
+}
+
+static void getUserName(FFPlatform* platform, const struct passwd* pwd) {
+    if (pwd) {
+        ffStrbufSetS(&platform->userName, pwd->pw_name);
+        ffStrbufSetS(&platform->fullUserName, pwd->pw_gecos);
+        ffStrbufTrimSpace(&platform->fullUserName);
+    } else {
+        ffStrbufSetS(&platform->userName, getenv("USER"));
+    }
+}
+
+static void getHostName(FFPlatform* platform, const struct utsname* uts) {
+    ffStrbufAppendS(&platform->hostName, uts->nodename);
+}
+
+static void getUserShell(FFPlatform* platform, const struct passwd* pwd) {
+    const char* shell = getenv("SHELL");
+    if (!ffStrSet(shell) && pwd) {
+        shell = pwd->pw_shell;
+    }
+
+    ffStrbufAppendS(&platform->userShell, shell);
+}
+
+static void getSysinfo(FFPlatformSysinfo* info, const struct utsname* uts) {
+    ffStrbufAppendS(&info->name, uts->sysname);
+    ffStrbufAppendS(&info->release, uts->release);
+    ffStrbufAppendS(&info->version, uts->version);
+#ifdef __HAIKU__
+    /* historical reason */
+    if (ffStrEquals(uts->machine, "BePC")) {
+        ffStrbufSetStatic(&info->architecture, "i386");
+    } else
+#endif
+        ffStrbufAppendS(&info->architecture, uts->machine);
+
+#if defined(__FreeBSD__) || defined(__APPLE__) || defined(__OpenBSD__) || defined(__NetBSD__)
+    size_t length = sizeof(info->pageSize);
+    sysctl((int[]) { CTL_HW, HW_PAGESIZE }, 2, &info->pageSize, &length, NULL, 0);
+#else
+    info->pageSize = (uint32_t) sysconf(_SC_PAGESIZE);
+#endif
+}
+
+static void getCwd(FFPlatform* platform) {
+    char cwd[PATH_MAX];
+    if (getcwd(cwd, sizeof(cwd)) != NULL) {
+        ffStrbufSetS(&platform->cwd, cwd);
+        ffStrbufEnsureEndsWithC(&platform->cwd, '/');
+    }
+}
+
+void ffPlatformInitImpl(FFPlatform* platform) {
+    platform->pid = (uint32_t) getpid();
+    platform->uid = getuid();
+    struct passwd* pwd = getpwuid(platform->uid);
+
+    struct utsname uts;
+    if (uname(&uts) < 0) {
+        memset(&uts, 0, sizeof(uts));
+    }
+
+    getExePath(platform);
+    getCwd(platform);
+    getHomeDir(platform, pwd);
+    getCacheDir(platform);
+    getConfigDirs(platform);
+    getDataDirs(platform);
+
+    getUserName(platform, pwd);
+    getHostName(platform, &uts);
+    getUserShell(platform, pwd);
+
+    getSysinfo(&platform->sysinfo, &uts);
+}
@@ -0,0 +1,313 @@
+#include "FFPlatform_private.h"
+#include "common/io.h"
+#include "common/library.h"
+#include "common/stringUtils.h"
+#include "common/windows/unicode.h"
+#include "common/windows/registry.h"
+#include "common/windows/nt.h"
+
+#include <stdalign.h>
+#include <windows.h>
+#include <shlobj.h>
+#include <sddl.h>
+
+#define SECURITY_WIN32 1 // For secext.h
+#include <secext.h>
+
+static void getExePath(FFPlatform* platform) {
+    wchar_t exePathW[MAX_PATH];
+
+    FF_AUTO_CLOSE_FD HANDLE hPath = CreateFileW(
+        ffGetPeb()->ProcessParameters->ImagePathName.Buffer,
+        GENERIC_READ,
+        FILE_SHARE_READ,
+        NULL,
+        OPEN_EXISTING,
+        FILE_FLAG_BACKUP_SEMANTICS,
+        NULL);
+    if (hPath != INVALID_HANDLE_VALUE) {
+        DWORD len = GetFinalPathNameByHandleW(hPath, exePathW, MAX_PATH, FILE_NAME_NORMALIZED);
+        if (len > 0 && len < MAX_PATH) {
+            ffStrbufSetNWS(&platform->exePath, len, exePathW);
+            if (ffStrbufStartsWithS(&platform->exePath, "\\\\?\\")) {
+                ffStrbufSubstrAfter(&platform->exePath, 3);
+            }
+        }
+    }
+
+    if (platform->exePath.length == 0) {
+        PCUNICODE_STRING imagePathName = &ffGetPeb()->ProcessParameters->ImagePathName;
+        ffStrbufSetNWS(&platform->exePath, imagePathName->Length / sizeof(wchar_t), imagePathName->Buffer);
+    }
+
+    ffStrbufReplaceAllC(&platform->exePath, '\\', '/');
+}
+
+static void getHomeDir(FFPlatform* platform) {
+    PWSTR pPath = NULL;
+    if (SUCCEEDED(SHGetKnownFolderPath(&FOLDERID_Profile, KF_FLAG_DEFAULT, NULL, &pPath))) {
+        ffStrbufSetWS(&platform->homeDir, pPath);
+        ffStrbufReplaceAllC(&platform->homeDir, '\\', '/');
+        ffStrbufEnsureEndsWithC(&platform->homeDir, '/');
+    } else {
+        ffStrbufSetS(&platform->homeDir, getenv("USERPROFILE"));
+        ffStrbufReplaceAllC(&platform->homeDir, '\\', '/');
+        ffStrbufEnsureEndsWithC(&platform->homeDir, '/');
+    }
+    CoTaskMemFree(pPath);
+}
+
+static void getCacheDir(FFPlatform* platform) {
+    PWSTR pPath = NULL;
+    if (SUCCEEDED(SHGetKnownFolderPath(&FOLDERID_LocalAppData, KF_FLAG_DEFAULT, NULL, &pPath))) {
+        ffStrbufSetWS(&platform->cacheDir, pPath);
+        ffStrbufReplaceAllC(&platform->cacheDir, '\\', '/');
+        ffStrbufEnsureEndsWithC(&platform->cacheDir, '/');
+    } else {
+        ffStrbufAppend(&platform->cacheDir, &platform->homeDir);
+        ffStrbufAppendS(&platform->cacheDir, "AppData/Local/");
+    }
+    CoTaskMemFree(pPath);
+}
+
+static void platformPathAddKnownFolder(FFlist* dirs, REFKNOWNFOLDERID folderId) {
+    PWSTR pPath = NULL;
+    if (SUCCEEDED(SHGetKnownFolderPath(folderId, KF_FLAG_DEFAULT, NULL, &pPath))) {
+        FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreateWS(pPath);
+        CoTaskMemFree(pPath);
+        ffStrbufReplaceAllC(&buffer, '\\', '/');
+        ffStrbufEnsureEndsWithC(&buffer, '/');
+        if (!FF_LIST_CONTAINS(*dirs, &buffer, ffStrbufEqual)) {
+            ffStrbufInitMove(FF_LIST_ADD(FFstrbuf, *dirs), &buffer);
+        }
+    }
+}
+
+static void platformPathAddEnvSuffix(FFlist* dirs, const char* env, const char* suffix) {
+    const char* value = getenv(env);
+    if (!ffStrSet(value)) {
+        return;
+    }
+
+    FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreateA(64);
+    ffStrbufAppendS(&buffer, value);
+    ffStrbufReplaceAllC(&buffer, '\\', '/');
+    ffStrbufEnsureEndsWithC(&buffer, '/');
+    if (suffix) {
+        ffStrbufAppendS(&buffer, suffix);
+        ffStrbufEnsureEndsWithC(&buffer, '/');
+    }
+
+    if (ffPathExists(buffer.chars, FF_PATHTYPE_DIRECTORY) && !FF_LIST_CONTAINS(*dirs, &buffer, ffStrbufEqual)) {
+        ffStrbufInitMove(FF_LIST_ADD(FFstrbuf, *dirs), &buffer);
+    }
+}
+
+static void getConfigDirs(FFPlatform* platform) {
+    if (getenv("MSYSTEM")) {
+        // We are in MSYS2 / Git Bash
+        platformPathAddEnvSuffix(&platform->configDirs, "HOME", ".config/");
+        platformPathAddEnvSuffix(&platform->configDirs, "HOME", NULL);
+        platformPathAddEnvSuffix(&platform->configDirs, "MINGW_PREFIX", "etc");
+    }
+
+    ffPlatformPathAddHome(&platform->configDirs, platform, ".config/");
+    platformPathAddKnownFolder(&platform->configDirs, &FOLDERID_ProgramData);
+    platformPathAddKnownFolder(&platform->configDirs, &FOLDERID_RoamingAppData);
+    platformPathAddKnownFolder(&platform->configDirs, &FOLDERID_LocalAppData);
+    ffPlatformPathAddHome(&platform->configDirs, platform, "");
+}
+
+static void getDataDirs(FFPlatform* platform) {
+    if (getenv("MSYSTEM") && getenv("HOME")) {
+        // We are in MSYS2 / Git Bash
+        platformPathAddEnvSuffix(&platform->dataDirs, "HOME", ".local/share/");
+        platformPathAddEnvSuffix(&platform->dataDirs, "HOME", NULL);
+        platformPathAddEnvSuffix(&platform->dataDirs, "MINGW_PREFIX", "share");
+    }
+    ffPlatformPathAddHome(&platform->dataDirs, platform, ".local/share/");
+    platformPathAddKnownFolder(&platform->dataDirs, &FOLDERID_ProgramData);
+    platformPathAddKnownFolder(&platform->dataDirs, &FOLDERID_RoamingAppData);
+    platformPathAddKnownFolder(&platform->dataDirs, &FOLDERID_LocalAppData);
+    ffPlatformPathAddHome(&platform->dataDirs, platform, "");
+}
+
+static void getUserName(FFPlatform* platform) {
+    wchar_t buffer[256];
+    DWORD size = ARRAY_SIZE(buffer);
+    if (GetUserNameExW(NameDisplay, buffer, &size)) {
+        ffStrbufSetWS(&platform->fullUserName, buffer);
+    }
+
+    NTSYSAPI NTSTATUS NTAPI LsaGetUserName(
+        _Outptr_ PLSA_UNICODE_STRING * UserName,
+        _Outptr_opt_ PLSA_UNICODE_STRING * DomainName);
+    PLSA_UNICODE_STRING userName = NULL;
+    if (NT_SUCCESS(LsaGetUserName(&userName, NULL))) {
+        ffStrbufSetNWS(&platform->userName, userName->Length / sizeof(wchar_t), userName->Buffer);
+        RtlFreeUnicodeString(userName);
+        LsaFreeMemory(userName);
+    } else {
+        ffStrbufSetS(&platform->userName, getenv("USERNAME"));
+    }
+
+    alignas(TOKEN_USER) char buf[SECURITY_MAX_SID_SIZE + sizeof(TOKEN_USER)];
+    if (NT_SUCCESS(NtQueryInformationToken(NtCurrentProcessToken(), TokenUser, buf, sizeof(buf), &size))) {
+        TOKEN_USER* tokenUser = (TOKEN_USER*) buf;
+        UNICODE_STRING sidString = { .Buffer = buffer, .Length = 0, .MaximumLength = sizeof(buffer) };
+        if (NT_SUCCESS(RtlConvertSidToUnicodeString(&sidString, tokenUser->User.Sid, FALSE))) {
+            ffStrbufSetNWS(&platform->sid, sidString.Length / sizeof(wchar_t), sidString.Buffer);
+        }
+    }
+}
+
+static void getHostName(FFPlatform* platform) {
+    wchar_t buffer[256];
+    DWORD len = ARRAY_SIZE(buffer);
+    if (GetComputerNameExW(ComputerNameDnsHostname, buffer, &len) && len > 0) {
+        ffStrbufSetNWS(&platform->hostName, len, buffer);
+    } else {
+        len = ARRAY_SIZE(buffer);
+        if (GetComputerNameExW(ComputerNameNetBIOS, buffer, &len) && len > 0) {
+            ffStrbufSetNWS(&platform->hostName, len, buffer);
+        }
+    }
+}
+
+static void getUserShell(FFPlatform* platform) {
+    // Works in MSYS2
+    const char* userShell = getenv("SHELL");
+    if (userShell) {
+        ffStrbufAppendS(&platform->userShell, userShell);
+        ffStrbufReplaceAllC(&platform->userShell, '\\', '/');
+    }
+}
+
+static const char* detectWine(void) {
+    const char* __cdecl wine_get_version(void);
+    void* hntdll = ffLibraryGetModule(L"ntdll.dll");
+    if (!hntdll) {
+        return NULL;
+    }
+    FF_LIBRARY_LOAD_SYMBOL_LAZY(hntdll, wine_get_version);
+    if (!ffwine_get_version) {
+        return NULL;
+    }
+    return ffwine_get_version();
+}
+
+static void getSystemReleaseAndVersion(FFPlatformSysinfo* info) {
+    FF_AUTO_CLOSE_FD HANDLE hKey = NULL;
+    if (!ffRegOpenKeyForRead(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", &hKey, NULL)) {
+        return;
+    }
+
+    uint32_t ubr = 0;
+    ffRegReadValues(hKey, 2, (FFRegValueArg[]) {
+                                 FF_ARG(ubr, L"UBR"),
+                                 FF_ARG(info->version, L"BuildLabEx"),
+                             },
+        NULL);
+
+    PPEB_FULL peb = ffGetPeb();
+
+    ffStrbufSetF(&info->release,
+        "%u.%u.%u.%u",
+        (unsigned) peb->OSMajorVersion,
+        (unsigned) peb->OSMinorVersion,
+        (unsigned) peb->OSBuildNumber,
+        (unsigned) ubr);
+
+    const char* wineVersion = detectWine();
+    if (wineVersion) {
+        ffStrbufSetF(&info->name, "Wine_%s", wineVersion);
+    } else {
+        ffStrbufSetStatic(&info->name, "WIN32_NT");
+    }
+}
+
+static void getSystemPageSize(FFPlatformSysinfo* info) {
+    SYSTEM_BASIC_INFORMATION sbi;
+    if (NT_SUCCESS(NtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi), NULL))) {
+        info->pageSize = sbi.PhysicalPageSize;
+    } else {
+        info->pageSize = 4096;
+    }
+}
+
+static void getSystemArchitecture(FFPlatformSysinfo* info) {
+    SYSTEM_PROCESSOR_INFORMATION spi;
+    if (NT_SUCCESS(NtQuerySystemInformation(SystemProcessorInformation, &spi, sizeof(spi), NULL))) {
+        switch (spi.ProcessorArchitecture) {
+            case PROCESSOR_ARCHITECTURE_AMD64:
+                ffStrbufSetStatic(&info->architecture, "x86_64");
+                break;
+            case PROCESSOR_ARCHITECTURE_IA64:
+                ffStrbufSetStatic(&info->architecture, "ia64");
+                break;
+            case PROCESSOR_ARCHITECTURE_INTEL:
+                switch (spi.ProcessorLevel) {
+                    case 4:
+                        ffStrbufSetStatic(&info->architecture, "i486");
+                        break;
+                    case 5:
+                        ffStrbufSetStatic(&info->architecture, "i586");
+                        break;
+                    case 6:
+                        ffStrbufSetStatic(&info->architecture, "i686");
+                        break;
+                    default:
+                        ffStrbufSetStatic(&info->architecture, "i386");
+                        break;
+                }
+                break;
+            case PROCESSOR_ARCHITECTURE_ARM64:
+                ffStrbufSetStatic(&info->architecture, "aarch64");
+                break;
+            case PROCESSOR_ARCHITECTURE_ARM:
+                ffStrbufSetStatic(&info->architecture, "arm");
+                break;
+            case PROCESSOR_ARCHITECTURE_PPC:
+                ffStrbufSetStatic(&info->architecture, "ppc");
+                break;
+            case PROCESSOR_ARCHITECTURE_MIPS:
+                ffStrbufSetStatic(&info->architecture, "mips");
+                break;
+            case PROCESSOR_ARCHITECTURE_ALPHA:
+                ffStrbufSetStatic(&info->architecture, "alpha");
+                break;
+            case PROCESSOR_ARCHITECTURE_ALPHA64:
+                ffStrbufSetStatic(&info->architecture, "alpha64");
+                break;
+            case PROCESSOR_ARCHITECTURE_UNKNOWN:
+            default:
+                ffStrbufSetStatic(&info->architecture, "unknown");
+                break;
+        }
+    }
+}
+
+static void getCwd(FFPlatform* platform) {
+    PCURDIR cwd = &ffGetPeb()->ProcessParameters->CurrentDirectory;
+    ffStrbufSetNWS(&platform->cwd, cwd->DosPath.Length / sizeof(WCHAR), cwd->DosPath.Buffer);
+    ffStrbufReplaceAllC(&platform->cwd, '\\', '/');
+    ffStrbufEnsureEndsWithC(&platform->cwd, '/');
+}
+
+void ffPlatformInitImpl(FFPlatform* platform) {
+    platform->pid = (uint32_t) (uintptr_t) ffGetTeb()->ClientId.UniqueProcess;
+    getExePath(platform);
+    getCwd(platform);
+    getHomeDir(platform);
+    getCacheDir(platform);
+    getConfigDirs(platform);
+    getDataDirs(platform);
+
+    getUserName(platform);
+    getHostName(platform);
+    getUserShell(platform);
+
+    getSystemReleaseAndVersion(&platform->sysinfo);
+    getSystemArchitecture(&platform->sysinfo);
+    getSystemPageSize(&platform->sysinfo);
+}
@@ -0,0 +1,34 @@
+#include "common/FFlist.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+void* ffListAdd(FFlist* list, uint32_t elementSize) {
+    if (list->length == list->capacity) {
+        ffListReserve(list, elementSize, list->capacity == 0 ? FF_LIST_DEFAULT_ALLOC : list->capacity * 2);
+    }
+
+    ++list->length;
+    return ffListGet(list, elementSize, list->length - 1);
+}
+
+bool ffListShift(FFlist* list, uint32_t elementSize, void* result) {
+    if (list->length == 0) {
+        return false;
+    }
+
+    memcpy(result, list->data, elementSize);
+    memmove(list->data, list->data + elementSize, (size_t) elementSize * (list->length - 1));
+    --list->length;
+    return true;
+}
+
+bool ffListPop(FFlist* list, uint32_t elementSize, void* result) {
+    if (list->length == 0) {
+        return false;
+    }
+
+    memcpy(result, ffListGet(list, elementSize, list->length - 1), elementSize);
+    --list->length;
+    return true;
+}
@@ -0,0 +1,927 @@
+#include "common/FFstrbuf.h"
+#include "common/mallocHelper.h"
+#include "common/stringUtils.h"
+
+#include <ctype.h>
+#include <inttypes.h>
+#include <math.h>
+
+char* CHAR_NULL_PTR = "";
+
+void ffStrbufInitA(FFstrbuf* strbuf, uint32_t allocate) {
+    strbuf->allocated = allocate;
+
+    if (strbuf->allocated > 0) {
+        strbuf->chars = (char*) malloc(sizeof(char) * strbuf->allocated);
+    }
+
+    // This will set the length to zero and the null byte.
+    ffStrbufClear(strbuf);
+}
+
+void ffStrbufInitVF(FFstrbuf* strbuf, const char* format, va_list arguments) {
+    assert(format != NULL);
+
+    char* buffer = NULL;
+    int len = vasprintf(&buffer, format, arguments);
+    assert(len >= 0);
+
+    ffStrbufInitMoveNS(strbuf, (uint32_t) len, buffer);
+}
+
+// Takes ownership of `heapStr`. The caller must not free `heapStr` after calling this
+// function; the memory will be managed and freed via the associated FFstrbuf.
+void ffStrbufInitMoveNS(FFstrbuf* strbuf, uint32_t length, char* heapStr) {
+    assert(heapStr != NULL);
+
+    strbuf->length = length;
+    size_t allocSize = ffMallocUsableSize(heapStr);
+    if (allocSize == 0) {
+        allocSize = length + 1;
+    } else if (allocSize > UINT32_MAX) {
+        allocSize = UINT32_MAX;
+    }
+    strbuf->allocated = (uint32_t) allocSize;
+    strbuf->chars = heapStr;
+}
+
+void ffStrbufEnsureFree(FFstrbuf* strbuf, uint32_t free) {
+    if (ffStrbufGetFree(strbuf) >= free && !(strbuf->allocated == 0 && strbuf->length > 0)) {
+        return;
+    }
+
+    uint32_t allocate = strbuf->allocated;
+    if (allocate < FASTFETCH_STRBUF_DEFAULT_ALLOC) {
+        allocate = FASTFETCH_STRBUF_DEFAULT_ALLOC;
+    }
+
+    while ((strbuf->length + free + 1) > allocate) { // + 1 for the null byte
+        allocate *= 2;
+    }
+
+    if (strbuf->allocated == 0) {
+        char* newbuf = malloc(sizeof(*strbuf->chars) * allocate);
+        if (strbuf->length == 0) {
+            *newbuf = '\0';
+        } else {
+            memcpy(newbuf, strbuf->chars, strbuf->length + 1);
+        }
+        strbuf->chars = newbuf;
+    } else {
+        strbuf->chars = realloc(strbuf->chars, sizeof(*strbuf->chars) * allocate);
+    }
+
+    strbuf->allocated = allocate;
+}
+
+// Ensure that at least `free` bytes are available in the buffer besides the current length
+// for an empty buffer, free + 1 length memory will be allocated(+1 for the NUL)
+void ffStrbufEnsureFixedLengthFree(FFstrbuf* strbuf, uint32_t free) {
+    uint32_t oldFree = ffStrbufGetFree(strbuf);
+    if (oldFree >= free && !(strbuf->allocated == 0 && strbuf->length > 0)) {
+        return;
+    }
+
+    uint32_t newCap = strbuf->allocated + (free - oldFree);
+
+    if (strbuf->allocated == 0) {
+        newCap += strbuf->length + 1;
+        char* newbuf = malloc(sizeof(*strbuf->chars) * newCap);
+        if (strbuf->length == 0) {
+            *newbuf = '\0';
+        } else {
+            memcpy(newbuf, strbuf->chars, strbuf->length + 1);
+        }
+        strbuf->chars = newbuf;
+    } else {
+        strbuf->chars = realloc(strbuf->chars, sizeof(*strbuf->chars) * newCap);
+    }
+
+    strbuf->allocated = newCap;
+}
+
+void ffStrbufClear(FFstrbuf* strbuf) {
+    assert(strbuf != NULL);
+
+    if (strbuf->allocated == 0) {
+        strbuf->chars = CHAR_NULL_PTR;
+    } else {
+        strbuf->chars[0] = '\0';
+    }
+
+    strbuf->length = 0;
+}
+
+void ffStrbufAppendC(FFstrbuf* strbuf, char c) {
+    ffStrbufEnsureFree(strbuf, 1);
+    strbuf->chars[strbuf->length++] = c;
+    strbuf->chars[strbuf->length] = '\0';
+}
+
+void ffStrbufAppendNC(FFstrbuf* strbuf, uint32_t num, char c) {
+    if (num == 0) {
+        return;
+    }
+
+    ffStrbufEnsureFree(strbuf, num);
+    memset(&strbuf->chars[strbuf->length], c, num);
+    strbuf->length += num;
+    strbuf->chars[strbuf->length] = '\0';
+}
+
+void ffStrbufAppendNS(FFstrbuf* strbuf, uint32_t length, const char* value) {
+    if (value == NULL || length == 0) {
+        return;
+    }
+
+    ffStrbufEnsureFree(strbuf, length);
+    memcpy(&strbuf->chars[strbuf->length], value, length);
+    strbuf->length += length;
+    strbuf->chars[strbuf->length] = '\0';
+}
+
+void ffStrbufAppendTransformS(FFstrbuf* strbuf, const char* value, int (*transformFunc)(int)) {
+    if (value == NULL) {
+        return;
+    }
+
+    // Ensure capacity > 0 or the modification below will fail
+    uint32_t length = (uint32_t) strlen(value);
+    if (length == 0) {
+        return;
+    }
+
+    ffStrbufEnsureFree(strbuf, length);
+    for (uint32_t i = 0; value[i] != '\0'; i++) {
+        strbuf->chars[strbuf->length++] = (char) transformFunc(value[i]);
+    }
+    strbuf->chars[strbuf->length] = '\0';
+}
+
+void ffStrbufAppendVF(FFstrbuf* strbuf, const char* format, va_list arguments) {
+    assert(format != NULL);
+
+    va_list copy;
+    va_copy(copy, arguments);
+
+    uint32_t free = ffStrbufGetFree(strbuf);
+    int written = vsnprintf(strbuf->chars + strbuf->length, strbuf->allocated > 0 ? free + 1 : 0, format, arguments);
+
+    if (written > 0 && (uint32_t) written > free) {
+        ffStrbufEnsureFree(strbuf, (uint32_t) written);
+        written = vsnprintf(strbuf->chars + strbuf->length, (uint32_t) written + 1, format, copy);
+    }
+
+    va_end(copy);
+
+    if (written > 0) {
+        strbuf->length += (uint32_t) written;
+    }
+}
+
+const char* ffStrbufAppendSUntilC(FFstrbuf* strbuf, const char* value, char until) {
+    if (value == NULL) {
+        return NULL;
+    }
+
+    const char* end = strchr(value, until);
+    if (end == NULL) {
+        ffStrbufAppendS(strbuf, value);
+    } else {
+        ffStrbufAppendNS(strbuf, (uint32_t) (end - value), value);
+    }
+    return end;
+}
+
+void ffStrbufSetF(FFstrbuf* strbuf, const char* format, ...) {
+    assert(format != NULL);
+
+    va_list arguments;
+    va_start(arguments, format);
+
+    if (strbuf->allocated == 0) {
+        ffStrbufInitVF(strbuf, format, arguments);
+        va_end(arguments);
+        return;
+    }
+
+    ffStrbufClear(strbuf);
+    ffStrbufAppendVF(strbuf, format, arguments);
+    va_end(arguments);
+}
+
+void ffStrbufAppendF(FFstrbuf* strbuf, const char* format, ...) {
+    assert(format != NULL);
+
+    va_list arguments;
+    va_start(arguments, format);
+    ffStrbufAppendVF(strbuf, format, arguments);
+    va_end(arguments);
+}
+
+void ffStrbufPrependNS(FFstrbuf* strbuf, uint32_t length, const char* value) {
+    if (value == NULL || length == 0) {
+        return;
+    }
+
+    ffStrbufEnsureFree(strbuf, length);
+    memmove(strbuf->chars + length, strbuf->chars, strbuf->length + 1); // + 1 for the null byte
+    memcpy(strbuf->chars, value, length);
+    strbuf->length += length;
+}
+
+void ffStrbufPrependC(FFstrbuf* strbuf, char c) {
+    ffStrbufEnsureFree(strbuf, 1);
+    memmove(strbuf->chars + 1, strbuf->chars, strbuf->length + 1); // + 1 for the null byte
+    strbuf->chars[0] = c;
+    strbuf->length += 1;
+}
+
+void ffStrbufSetNS(FFstrbuf* strbuf, uint32_t length, const char* value) {
+    assert(strbuf != NULL);
+
+    if (length == 0) {
+        ffStrbufClear(strbuf);
+        return;
+    }
+
+    assert(value != NULL);
+
+    if (strbuf->allocated <= length) {
+        char* newBuf = malloc(sizeof(char) * (length + 1));
+        memcpy(newBuf, value, length);
+        if (strbuf->allocated > 0) {
+            free(strbuf->chars);
+        }
+        strbuf->chars = newBuf;
+        strbuf->allocated = length + 1;
+    } else {
+        memmove(strbuf->chars, value, length);
+    }
+
+    strbuf->length = length;
+    strbuf->chars[length] = '\0';
+}
+
+void ffStrbufSet(FFstrbuf* strbuf, const FFstrbuf* value) {
+    assert(value && value != strbuf);
+
+    if (value->length == 0) {
+        ffStrbufClear(strbuf);
+        return;
+    }
+
+    if (value->allocated == 0) // static string
+    {
+        if (strbuf->allocated != 0) {
+            free(strbuf->chars);
+            strbuf->allocated = 0;
+        }
+        strbuf->chars = value->chars;
+        strbuf->length = value->length;
+        return;
+    }
+    ffStrbufSetNS(strbuf, value->length, value->chars);
+}
+
+void ffStrbufTrimLeft(FFstrbuf* strbuf, char c) {
+    if (strbuf->length == 0) {
+        return;
+    }
+
+    uint32_t index = 0;
+    while (index < strbuf->length && strbuf->chars[index] == c) {
+        ++index;
+    }
+
+    if (index == 0) {
+        return;
+    }
+
+    if (strbuf->allocated == 0) {
+        // static string
+        strbuf->length -= index;
+        strbuf->chars += index;
+        return;
+    }
+
+    memmove(strbuf->chars, strbuf->chars + index, strbuf->length - index);
+    strbuf->length -= index;
+    strbuf->chars[strbuf->length] = '\0';
+}
+
+void ffStrbufTrimRight(FFstrbuf* strbuf, char c) {
+    if (strbuf->length == 0) {
+        return;
+    }
+
+    if (!ffStrbufEndsWithC(strbuf, c)) {
+        return;
+    }
+
+    do {
+        --strbuf->length;
+    } while (ffStrbufEndsWithC(strbuf, c));
+
+    if (strbuf->allocated == 0) {
+        // static string
+        ffStrbufInitNS(strbuf, strbuf->length, strbuf->chars);
+        return;
+    }
+
+    strbuf->chars[strbuf->length] = '\0';
+}
+
+void ffStrbufTrimLeftSpace(FFstrbuf* strbuf) {
+    if (strbuf->length == 0) {
+        return;
+    }
+
+    uint32_t index = 0;
+    while (index < strbuf->length && isspace(strbuf->chars[index])) {
+        ++index;
+    }
+
+    if (index == 0) {
+        return;
+    }
+
+    if (strbuf->allocated == 0) {
+        // static string
+        strbuf->length -= index;
+        strbuf->chars += index;
+        return;
+    }
+
+    memmove(strbuf->chars, strbuf->chars + index, strbuf->length - index);
+    strbuf->length -= index;
+    strbuf->chars[strbuf->length] = '\0';
+}
+
+void ffStrbufTrimRightSpace(FFstrbuf* strbuf) {
+    if (strbuf->length == 0) {
+        return;
+    }
+
+    if (!ffStrbufEndsWithFn(strbuf, isspace)) {
+        return;
+    }
+
+    do {
+        --strbuf->length;
+    } while (ffStrbufEndsWithFn(strbuf, isspace));
+
+    if (strbuf->allocated == 0) {
+        // static string
+        ffStrbufInitNS(strbuf, strbuf->length, strbuf->chars);
+        return;
+    }
+
+    strbuf->chars[strbuf->length] = '\0';
+}
+
+bool ffStrbufRemoveSubstr(FFstrbuf* strbuf, uint32_t startIndex, uint32_t endIndex) {
+    if (startIndex > strbuf->length || startIndex >= endIndex) {
+        return false;
+    }
+
+    if (endIndex > strbuf->length) {
+        ffStrbufSubstrBefore(strbuf, startIndex);
+        return true;
+    }
+
+    ffStrbufEnsureFree(strbuf, 0);
+    memmove(strbuf->chars + startIndex, strbuf->chars + endIndex, strbuf->length - endIndex);
+    strbuf->length -= (endIndex - startIndex);
+    strbuf->chars[strbuf->length] = '\0';
+    return true;
+}
+
+void ffStrbufRemoveS(FFstrbuf* strbuf, const char* str) {
+    uint32_t stringLength = (uint32_t) strlen(str);
+
+    for (uint32_t i = ffStrbufNextIndexS(strbuf, 0, str); i < strbuf->length; i = ffStrbufNextIndexS(strbuf, i, str)) {
+        ffStrbufRemoveSubstr(strbuf, i, i + stringLength);
+    }
+}
+
+void ffStrbufRemoveStrings(FFstrbuf* strbuf, uint32_t numStrings, const char* strings[]) {
+    for (uint32_t i = 0; i < numStrings; i++) {
+        ffStrbufRemoveS(strbuf, strings[i]);
+    }
+}
+
+uint32_t ffStrbufNextIndexC(const FFstrbuf* strbuf, uint32_t start, char c) {
+    assert(start <= strbuf->length);
+
+    const char* ptr = (const char*) memchr(strbuf->chars + start, c, strbuf->length - start);
+    return ptr ? (uint32_t) (ptr - strbuf->chars) : strbuf->length;
+}
+
+uint32_t ffStrbufNextIndexS(const FFstrbuf* strbuf, uint32_t start, const char* str) {
+    assert(start <= strbuf->length);
+
+    const char* ptr = strstr(strbuf->chars + start, str);
+    return ptr ? (uint32_t) (ptr - strbuf->chars) : strbuf->length;
+}
+
+uint32_t ffStrbufPreviousIndexC(const FFstrbuf* strbuf, uint32_t start, char c) {
+    assert(start <= strbuf->length);
+
+    // We need to loop one higher than the actual index, because uint32_t is guaranteed to be >= 0, so this statement would always be true
+    for (uint32_t i = start + 1; i > 0; i--) {
+        if (strbuf->chars[i - 1] == c) {
+            return i - 1;
+        }
+    }
+    return strbuf->length;
+}
+
+void ffStrbufReplaceAllC(FFstrbuf* strbuf, char find, char replace) {
+    if (strbuf->length == 0) {
+        return;
+    }
+
+    ffStrbufEnsureFree(strbuf, 0);
+    for (
+        char* current_pos = memchr(strbuf->chars, find, strbuf->length);
+        current_pos;
+        current_pos = memchr(
+            current_pos + 1,
+            find,
+            strbuf->length - (uint32_t) (current_pos + 1 - strbuf->chars))) {
+        *current_pos = replace;
+    }
+}
+
+bool ffStrbufSubstrBefore(FFstrbuf* strbuf, uint32_t index) {
+    if (strbuf->length <= index) {
+        return false;
+    }
+
+    if (strbuf->allocated == 0) {
+        // static string
+        if (index < strbuf->length) {
+            ffStrbufInitNS(strbuf, index, strbuf->chars);
+        }
+        return true;
+    }
+
+    strbuf->length = index;
+    strbuf->chars[strbuf->length] = '\0';
+    return true;
+}
+
+bool ffStrbufSubstrAfter(FFstrbuf* strbuf, uint32_t index) {
+    if (index >= strbuf->length) {
+        ffStrbufClear(strbuf);
+        return true;
+    }
+
+    if (strbuf->allocated == 0) {
+        // static string
+        strbuf->length -= index + 1;
+        strbuf->chars += index + 1;
+        return true;
+    }
+
+    memmove(strbuf->chars, strbuf->chars + index + 1, strbuf->length - index - 1);
+    strbuf->length -= (index + 1);
+    strbuf->chars[strbuf->length] = '\0';
+    return true;
+}
+
+bool ffStrbufSubstrAfterFirstC(FFstrbuf* strbuf, char c) {
+    uint32_t index = ffStrbufFirstIndexC(strbuf, c);
+    if (index >= strbuf->length) {
+        return false;
+    }
+    ffStrbufSubstrAfter(strbuf, index);
+    return true;
+}
+
+bool ffStrbufSubstrAfterFirstS(FFstrbuf* strbuf, const char* str) {
+    if (*str == '\0') {
+        return false;
+    }
+
+    uint32_t index = ffStrbufFirstIndexS(strbuf, str) + (uint32_t) strlen(str) - 1; // -1, because firstIndexS is already pointing to str[0], we want to add only the remaining length
+    if (index >= strbuf->length) {
+        return false;
+    }
+
+    ffStrbufSubstrAfter(strbuf, index);
+    return true;
+}
+
+bool ffStrbufSubstrAfterLastC(FFstrbuf* strbuf, char c) {
+    uint32_t index = ffStrbufLastIndexC(strbuf, c);
+    if (index >= strbuf->length) {
+        return false;
+    }
+
+    ffStrbufSubstrAfter(strbuf, index);
+    return true;
+}
+
+bool ffStrbufSubstr(FFstrbuf* strbuf, uint32_t start, uint32_t end) {
+    if (__builtin_expect(start >= end, false)) {
+        ffStrbufClear(strbuf);
+        return false;
+    }
+
+    if (__builtin_expect(start == 0, false)) {
+        return ffStrbufSubstrBefore(strbuf, end);
+    }
+    if (__builtin_expect(end >= strbuf->length, false)) {
+        return ffStrbufSubstrAfter(strbuf, start - 1);
+    }
+
+    uint32_t len = end - start;
+    ffStrbufEnsureFixedLengthFree(strbuf, len); // In case of static string
+    memmove(strbuf->chars, strbuf->chars + start, len);
+
+    strbuf->length = len;
+    strbuf->chars[len] = '\0';
+    return true;
+}
+
+uint32_t ffStrbufCountC(const FFstrbuf* strbuf, char c) {
+    uint32_t result = 0;
+    for (uint32_t i = 0; i < strbuf->length; i++) {
+        if (strbuf->chars[i] == c) {
+            result++;
+        }
+    }
+
+    return result;
+}
+
+bool ffStrbufRemoveIgnCaseEndS(FFstrbuf* strbuf, const char* end) {
+    uint32_t endLength = (uint32_t) strlen(end);
+    if (ffStrbufEndsWithIgnCaseNS(strbuf, endLength, end)) {
+        ffStrbufSubstrBefore(strbuf, strbuf->length - endLength);
+        return true;
+    }
+
+    return false;
+}
+
+bool ffStrbufEnsureEndsWithC(FFstrbuf* strbuf, char c) {
+    if (ffStrbufEndsWithC(strbuf, c)) {
+        return false;
+    }
+
+    ffStrbufAppendC(strbuf, c);
+    return true;
+}
+
+void ffStrbufWriteTo(const FFstrbuf* strbuf, FILE* file) {
+    fwrite(strbuf->chars, sizeof(*strbuf->chars), strbuf->length, file);
+}
+
+void ffStrbufPutTo(const FFstrbuf* strbuf, FILE* file) {
+    ffStrbufWriteTo(strbuf, file);
+    fputc('\n', file);
+}
+
+double ffStrbufToDouble(const FFstrbuf* strbuf, double defaultValue) {
+    char* str_end;
+    double result = strtod(strbuf->chars, &str_end);
+    return str_end == strbuf->chars ? defaultValue : result;
+}
+
+uint64_t ffStrbufToUInt(const FFstrbuf* strbuf, uint64_t defaultValue) {
+    char* str_end;
+    unsigned long long result = strtoull(strbuf->chars, &str_end, 10);
+    return str_end == strbuf->chars ? defaultValue : (uint64_t) result;
+}
+
+int64_t ffStrbufToSInt(const FFstrbuf* strbuf, int64_t defaultValue) {
+    char* str_end;
+    long long result = strtoll(strbuf->chars, &str_end, 10);
+    return str_end == strbuf->chars ? defaultValue : (int64_t) result;
+}
+
+void ffStrbufAppendSInt(FFstrbuf* strbuf, int64_t value) {
+    ffStrbufEnsureFree(strbuf, 21); // Required by yyjson_write_number
+    char* start = strbuf->chars + strbuf->length;
+
+    yyjson_val val = {};
+    unsafe_yyjson_set_sint(&val, value);
+    char* end = yyjson_write_number(&val, start);
+
+    assert(end != NULL);
+
+    strbuf->length += (uint32_t) (end - start);
+}
+
+void ffStrbufAppendUInt(FFstrbuf* strbuf, uint64_t value) {
+    ffStrbufEnsureFree(strbuf, 21); // Required by yyjson_write_number
+    char* start = strbuf->chars + strbuf->length;
+
+    yyjson_val val = {};
+    unsafe_yyjson_set_uint(&val, value);
+    char* end = yyjson_write_number(&val, start);
+
+    assert(end != NULL);
+
+    strbuf->length += (uint32_t) (end - start);
+}
+
+void ffStrbufAppendDouble(FFstrbuf* strbuf, double value, int8_t precision, bool trailingZeros) {
+    assert(precision <= 15); // yyjson_write_number supports up to 15 digits after the decimal point
+
+    ffStrbufEnsureFree(strbuf, 40); // Required by yyjson_write_number
+    char* start = strbuf->chars + strbuf->length;
+
+    if (precision == 0) {
+        value = round(value);
+    }
+    yyjson_val val = {};
+    unsafe_yyjson_set_double(&val, value);
+    if (precision > 0) {
+        unsafe_yyjson_set_fp_to_fixed(&val, precision);
+    }
+
+    // Write at most <precision> digits after the decimal point; doesn't append trailing zeros
+    char* end = yyjson_write_number(&val, start);
+
+    assert(end > start);
+
+    strbuf->length += (uint32_t) (end - start);
+
+    if (__builtin_expect(value > 1e21 || value < -1e21, false)) {
+        // If the value is too large, yyjson_write_number will write it in scientific notation
+        return;
+    }
+
+    if (trailingZeros) {
+        if (precision > 1) {
+            for (char* p = end - 1; *p != '.' && p > start; --p) {
+                --precision;
+            }
+            if (precision > 0) {
+                ffStrbufAppendNC(strbuf, (uint32_t) precision, '0');
+            }
+        } else if (precision == 0 || (precision < 0 && end[-1] == '0')) {
+            goto removeDecimalPoint;
+        }
+    } else {
+        if (end[-1] == '0') {
+        removeDecimalPoint:
+            // yyjson always appends ".0" to make it a float point number. We need to remove it
+            strbuf->length -= 2;
+            strbuf->chars[strbuf->length] = '\0';
+        }
+    }
+}
+
+void ffStrbufUpperCase(FFstrbuf* strbuf) {
+    for (uint32_t i = 0; i < strbuf->length; ++i) {
+        strbuf->chars[i] = (char) toupper(strbuf->chars[i]);
+    }
+}
+
+void ffStrbufLowerCase(FFstrbuf* strbuf) {
+    for (uint32_t i = 0; i < strbuf->length; ++i) {
+        strbuf->chars[i] = (char) tolower(strbuf->chars[i]);
+    }
+}
+
+void ffStrbufInsertNC(FFstrbuf* strbuf, uint32_t index, uint32_t num, char c) {
+    if (num == 0) {
+        return;
+    }
+    if (index >= strbuf->length) {
+        index = strbuf->length;
+    }
+
+    ffStrbufEnsureFree(strbuf, num);
+    memmove(strbuf->chars + index + num, strbuf->chars + index, strbuf->length - index + 1);
+    memset(&strbuf->chars[index], c, num);
+    strbuf->length += num;
+}
+
+bool ffStrbufGetdelim(char** lineptr, size_t* n, char delimiter, FFstrbuf* buffer) {
+    assert(lineptr && n && buffer);
+    assert(buffer->allocated > 0 || (buffer->allocated == 0 && buffer->length == 0));
+    assert(!*lineptr || (*lineptr >= buffer->chars && *lineptr <= buffer->chars + buffer->length));
+
+    const char* pBufferEnd = buffer->chars + buffer->length;
+    if (!*lineptr) {
+        *lineptr = buffer->chars;
+    } else {
+        *lineptr += *n;
+        if (*lineptr >= pBufferEnd) { // non-empty last line
+            return false;
+        }
+        **lineptr = delimiter;
+        ++*lineptr;
+    }
+    if (*lineptr >= pBufferEnd) { // empty last line
+        return false;
+    }
+
+    size_t remaining = (size_t) (pBufferEnd - *lineptr);
+    char* ending = memchr(*lineptr, delimiter, remaining);
+    if (ending) {
+        *n = (size_t) (ending - *lineptr);
+        *ending = '\0';
+    } else {
+        *n = remaining;
+    }
+    return true;
+}
+
+void ffStrbufGetdelimRestore(char** lineptr, size_t* n, char delimiter, FFstrbuf* buffer) {
+    assert(buffer && lineptr && n);
+    assert(buffer->allocated > 0 || (buffer->allocated == 0 && buffer->length == 0));
+    assert(!*lineptr || (*lineptr >= buffer->chars && *lineptr <= buffer->chars + buffer->length));
+
+    if (!*lineptr) {
+        return;
+    }
+
+    *lineptr += *n;
+    if (*lineptr < buffer->chars + buffer->length) {
+        **lineptr = delimiter;
+    }
+}
+
+bool ffStrbufRemoveDupWhitespaces(FFstrbuf* strbuf) {
+    if (strbuf->allocated == 0) {
+        return false; // Doesn't work with static strings
+    }
+
+    bool changed = false;
+    for (uint32_t i = 0; i < strbuf->length; i++) {
+        if (strbuf->chars[i] != ' ') {
+            continue;
+        }
+
+        i++;
+        uint32_t j = i;
+        for (; j < strbuf->length && strbuf->chars[j] == ' '; j++);
+
+        if (j == i) {
+            continue;
+        }
+        memmove(&strbuf->chars[i], &strbuf->chars[j], strbuf->length - j + 1);
+        strbuf->length -= j - i;
+        changed = true;
+    }
+
+    return changed;
+}
+
+/// @brief Check if a separated string (comp) contains a substring (strbuf).
+/// @param strbuf The substring to check.
+/// @param compLength The length of the separated string to check.
+/// @param comp The separated string to check.
+/// @param separator The separator character.
+bool ffStrbufMatchSeparatedNS(const FFstrbuf* strbuf, uint32_t compLength, const char* comp, char separator) {
+    if (strbuf->length == 0) {
+        return true;
+    }
+
+    if (compLength == 0) {
+        return false;
+    }
+
+    for (const char* p = comp; p < comp + compLength;) {
+        const char* colon = memchr(p, separator, compLength);
+        if (colon == NULL) {
+            return strcmp(strbuf->chars, p) == 0;
+        }
+
+        uint32_t substrLength = (uint32_t) (colon - p);
+        if (strbuf->length == substrLength && memcmp(strbuf->chars, p, substrLength) == 0) {
+            return true;
+        }
+
+        p = colon + 1;
+    }
+
+    return false;
+}
+
+/// @brief Case insensitive version of ffStrbufMatchSeparatedNS.
+bool ffStrbufMatchSeparatedIgnCaseNS(const FFstrbuf* strbuf, uint32_t compLength, const char* comp, char separator) {
+    if (strbuf->length == 0) {
+        return true;
+    }
+
+    if (compLength == 0) {
+        return false;
+    }
+
+    for (const char* p = comp; p < comp + compLength;) {
+        const char* colon = memchr(p, separator, compLength);
+        if (colon == NULL) {
+            return strcasecmp(strbuf->chars, p) == 0;
+        }
+
+        uint32_t substrLength = (uint32_t) (colon - p);
+        if (strbuf->length == substrLength && strncasecmp(strbuf->chars, p, substrLength) == 0) {
+            return true;
+        }
+
+        p = colon + 1;
+    }
+
+    return false;
+}
+
+int ffStrbufAppendUtf32CodePoint(FFstrbuf* strbuf, uint32_t codepoint) {
+    if (codepoint <= 0x7F) {
+        ffStrbufAppendC(strbuf, (char) codepoint);
+        return 1;
+    } else if (codepoint <= 0x7FF) {
+        ffStrbufAppendNS(strbuf, 2, (char[]) { (char) (0xC0 | (codepoint >> 6)), (char) (0x80 | (codepoint & 0x3F)) });
+        return 2;
+    } else if (codepoint <= 0xFFFF) {
+        ffStrbufAppendNS(strbuf, 3, (char[]) { (char) (0xE0 | (codepoint >> 12)), (char) (0x80 | ((codepoint >> 6) & 0x3F)), (char) (0x80 | (codepoint & 0x3F)) });
+        return 3;
+    } else if (codepoint <= 0x10FFFF) {
+        ffStrbufAppendNS(strbuf, 4, (char[]) { (char) (0xF0 | (codepoint >> 18)), (char) (0x80 | ((codepoint >> 12) & 0x3F)), (char) (0x80 | ((codepoint >> 6) & 0x3F)), (char) (0x80 | (codepoint & 0x3F)) });
+        return 4;
+    }
+
+    ffStrbufAppendS(strbuf, "�"); // U+FFFD REPLACEMENT CHARACTER
+    return 1;
+}
+
+/// @brief Check if a separated string (strbuf) contains a substring (comp).
+/// @param strbuf The separated to check.
+/// @param compLength The length of the separated string to check.
+/// @param comp The substring to check.
+/// @param separator The separator character.
+bool ffStrbufSeparatedContainNS(const FFstrbuf* strbuf, uint32_t compLength, const char* comp, char separator) {
+    uint32_t startIndex = 0;
+    while (startIndex < strbuf->length) {
+        uint32_t colonIndex = ffStrbufNextIndexC(strbuf, startIndex, separator);
+
+        uint32_t folderLength = colonIndex - startIndex;
+        if (folderLength == compLength && memcmp(strbuf->chars + startIndex, comp, compLength) == 0) {
+            return true;
+        }
+
+        startIndex = colonIndex + 1;
+    }
+
+    return false;
+}
+
+bool ffStrbufSeparatedContainIgnCaseNS(const FFstrbuf* strbuf, uint32_t compLength, const char* comp, char separator) {
+    uint32_t startIndex = 0;
+    while (startIndex < strbuf->length) {
+        uint32_t colonIndex = ffStrbufNextIndexC(strbuf, startIndex, separator);
+
+        uint32_t folderLength = colonIndex - startIndex;
+        if (folderLength == compLength && strncasecmp(strbuf->chars + startIndex, comp, compLength) == 0) {
+            return true;
+        }
+
+        startIndex = colonIndex + 1;
+    }
+
+    return false;
+}
+
+bool ffStrbufDecodeHexEscapeSequences(FFstrbuf* strbuf) {
+    assert(strbuf);
+
+    if (strbuf->length < 4) {
+        return false;
+    }
+
+    // Static string must be converted first.
+    assert(strbuf->allocated > 0);
+
+    bool changed = false;
+    uint32_t read = 0;
+    uint32_t write = 0;
+
+    while (read < strbuf->length) {
+        if (
+            read + 3 < strbuf->length &&
+            strbuf->chars[read] == '\\' &&
+            strbuf->chars[read + 1] == 'x') {
+            int8_t hi = ffHexCharToInt(strbuf->chars[read + 2]);
+            int8_t lo = ffHexCharToInt(strbuf->chars[read + 3]);
+            if (hi >= 0 && lo >= 0) {
+                strbuf->chars[write++] = (char) ((hi << 4) | lo);
+                read += 4;
+                changed = true;
+                continue;
+            }
+        }
+
+        strbuf->chars[write++] = strbuf->chars[read++];
+    }
+
+    strbuf->length = write;
+    strbuf->chars[write] = '\0';
+    return changed;
+}
@@ -1,14 +1,12 @@
-#include "base64.h"
+#include "common/base64.h"

 // https://github.com/kostya/benchmarks/blob/master/base64/test-nolib.c#L145
-void ffBase64EncodeRaw(uint32_t size, const char *str, uint32_t *out_size, char *output)
-{
+void ffBase64EncodeRaw(uint32_t size, const char* str, uint32_t* out_size, char* output) {
    static const char chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    char *out = output;
-    const char *ends = str + (size - size % 3);
-    while (str != ends)
-    {
-        uint32_t n = __builtin_bswap32(*(uint32_t *)str);
+    char* out = output;
+    const char* ends = str + (size - size % 3);
+    while (str != ends) {
+        uint32_t n = __builtin_bswap32(*(uint32_t*) str);
        *out++ = chars[(n >> 26) & 63];
        *out++ = chars[(n >> 20) & 63];
        *out++ = chars[(n >> 14) & 63];
@@ -16,94 +14,94 @@ void ffBase64EncodeRaw(uint32_t size, const char *str, uint32_t *out_size, char
        str += 3;
    }

-    if (size % 3 == 1)
-    {
-        uint64_t n = (uint64_t)*str << 16;
+    if (size % 3 == 1) {
+        uint64_t n = (uint64_t) *str << 16;
        *out++ = chars[(n >> 18) & 63];
        *out++ = chars[(n >> 12) & 63];
        *out++ = '=';
        *out++ = '=';
-    }
-    else if (size % 3 == 2)
-    {
-        uint64_t n = (uint64_t)*str++ << 16;
-        n |= (uint64_t)*str << 8;
+    } else if (size % 3 == 2) {
+        uint64_t n = (uint64_t) *str++ << 16;
+        n |= (uint64_t) *str << 8;
        *out++ = chars[(n >> 18) & 63];
        *out++ = chars[(n >> 12) & 63];
        *out++ = chars[(n >> 6) & 63];
        *out++ = '=';
    }
    *out = '\0';
-    *out_size = (uint32_t)(out - output);
+    *out_size = (uint32_t) (out - output);
 }

 static uint8_t decode_table[256];

-void init_decode_table()
-{
+void init_decode_table() {
    uint8_t ch = 0;
-    do
-    {
+    do {
        int32_t code = -1;
-        if (ch >= 'A' && ch <= 'Z')
+        if (ch >= 'A' && ch <= 'Z') {
            code = ch - 0x41;
-        if (ch >= 'a' && ch <= 'z')
+        }
+        if (ch >= 'a' && ch <= 'z') {
            code = ch - 0x47;
-        if (ch >= '0' && ch <= '9')
+        }
+        if (ch >= '0' && ch <= '9') {
            code = ch + 0x04;
-        if (ch == '+' || ch == '-')
+        }
+        if (ch == '+' || ch == '-') {
            code = 0x3E;
-        if (ch == '/' || ch == '_')
+        }
+        if (ch == '/' || ch == '_') {
            code = 0x3F;
+        }
        decode_table[ch] = (uint8_t) code;
    } while (ch++ < 0xFF);
 }

 #define next_char(x) uint8_t x = decode_table[(uint8_t) *str++];

-bool ffBase64DecodeRaw(uint32_t size, const char *str, uint32_t *out_size, char *output)
-{
-    if (*(uint64_t*) decode_table == 0)
+bool ffBase64DecodeRaw(uint32_t size, const char* str, uint32_t* out_size, char* output) {
+    if (*(uint64_t*) decode_table == 0) {
        init_decode_table();
+    }

-    char *out = output;
-    while (size > 0 && (str[size - 1] == '\n' || str[size - 1] == '\r' || str[size - 1] == '='))
+    char* out = output;
+    while (size > 0 && (str[size - 1] == '\n' || str[size - 1] == '\r' || str[size - 1] == '=')) {
        size--;
+    }

-    const char *ends = str + size - 4;
-    while (true)
-    {
-        if (str > ends)
+    const char* ends = str + size - 4;
+    while (true) {
+        if (str > ends) {
            break;
-        while (*str == '\n' || *str == '\r')
+        }
+        while (*str == '\n' || *str == '\r') {
            str++;
+        }

-        if (str > ends)
+        if (str > ends) {
            break;
+        }
        next_char(a);
        next_char(b);
        next_char(c);
        next_char(d);

-        *out++ = (char)(a << 2 | b >> 4);
-        *out++ = (char)(b << 4 | c >> 2);
-        *out++ = (char)(c << 6 | d >> 0);
+        *out++ = (char) (a << 2 | b >> 4);
+        *out++ = (char) (b << 4 | c >> 2);
+        *out++ = (char) (c << 6 | d >> 0);
    }

    uint8_t mod = (uint8_t) (ends - str + 4) % 4;
-    if (mod == 2)
-    {
+    if (mod == 2) {
        next_char(a);
        next_char(b);
-        *out++ = (char)(a << 2 | b >> 4);
-    }
-    else if (mod == 3)
-    {
+        *out++ = (char) (a << 2 | b >> 4);
+    } else if (mod == 3) {
        next_char(a);
        next_char(b);
        next_char(c);
-        *out++ = (char)(a << 2 | b >> 4);
-        *out++ = (char)(b << 4 | c >> 2);
+        *out++ = (char) (a << 2 | b >> 4);
+        *out++ = (char) (b << 4 | c >> 2);
    }

    *out = '\0';
@@ -0,0 +1,304 @@
+#include "common/binary.h"
+#include "common/io.h"
+#include "common/stringUtils.h"
+
+#include <string.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <mach-o/loader.h>
+#include <mach-o/swap.h>
+#include <mach-o/fat.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations" // swap_fat_arch
+
+// Ref: https://github.com/AlexDenisov/segment_dumper/blob/master/main.c
+
+typedef struct {
+    const uint8_t* data;
+    size_t length;
+} FFMemoryMapping;
+
+static inline void wrapMunmap(FFMemoryMapping* mapping) {
+    assert(mapping);
+    if (mapping->data == NULL || mapping->data == MAP_FAILED) {
+        return;
+    }
+    munmap((void*) mapping->data, mapping->length);
+}
+
+/**
+ * Helper function to access data from a memory-mapped file at a specific offset
+ */
+static inline const void* readData(const FFMemoryMapping* mapping, size_t size, off_t offset) {
+    if (offset < 0) {
+        return NULL;
+    }
+
+    size_t start = (size_t) offset;
+    if (start > mapping->length || size > mapping->length - start) {
+        return NULL;
+    }
+
+    return mapping->data + start;
+}
+
+/**
+ * Handles a Mach-O section by extracting strings from the __cstring section
+ *
+ * @param mapping Memory mapping of the Mach-O object file
+ * @param name Section name to check
+ * @param offset Offset of the section in the file
+ * @param size Size of the section
+ * @param cb Callback function to process strings
+ * @param userdata User data for the callback
+ * @param minLength Minimum string length to extract
+ *
+ * @return true to continue processing, false to stop
+ */
+static bool handleMachSection(const FFMemoryMapping* mapping, const char* name, off_t offset, size_t size, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength) {
+    if (!ffStrEquals(name, "__cstring")) {
+        return true;
+    }
+
+    const char* data = readData(mapping, size, offset);
+    if (!data) {
+        return true;
+    }
+
+    for (size_t off = 0; off < size; ++off) {
+        const char* p = data + off;
+        if (*p == '\0') {
+            continue;
+        }
+        uint32_t len = (uint32_t) strnlen(p, size - off);
+        if (len < minLength) {
+            continue;
+        }
+        if (*p >= ' ' && *p <= '~') { // Ignore control characters
+            if (!cb(p, len, userdata)) {
+                return false;
+            }
+        }
+        off += len;
+    }
+    return true;
+}
+
+/**
+ * Processes a Mach-O header (32-bit or 64-bit)
+ *
+ * This function parses the load commands in a Mach-O header, looking for
+ * LC_SEGMENT or LC_SEGMENT_64 commands that contain the __TEXT segment.
+ * It then processes the sections within that segment to extract strings.
+ *
+ * @param mapping Memory mapping of the Mach-O object file
+ * @param offset Offset of the Mach header in the file
+ * @param is_64 Whether this is a 64-bit Mach-O header
+ * @param cb Callback function to process strings
+ * @param userdata User data for the callback
+ * @param minLength Minimum string length to extract
+ *
+ * @return NULL on success, error message on failure
+ */
+static const char* dumpMachHeader(const FFMemoryMapping* mapping, off_t offset, bool is_64, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength) {
+    uint32_t ncmds;
+    off_t loadCommandsOffset = offset;
+
+    if (is_64) {
+        const struct mach_header_64* header = readData(mapping, sizeof(struct mach_header_64), offset);
+        if (!header) {
+            return "read mach header failed";
+        }
+
+        ncmds = header->ncmds;
+        loadCommandsOffset += sizeof(*header);
+    } else {
+        const struct mach_header* header = readData(mapping, sizeof(struct mach_header), offset);
+        if (!header) {
+            return "read mach header failed";
+        }
+
+        ncmds = header->ncmds;
+        loadCommandsOffset += sizeof(*header);
+    }
+
+    off_t commandOffset = loadCommandsOffset;
+    const struct load_command* cmd = NULL;
+    for (uint32_t i = 0U; i < ncmds; i++, commandOffset += cmd->cmdsize) {
+        cmd = readData(mapping, sizeof(*cmd), commandOffset);
+        if (!cmd) {
+            break;
+        }
+
+        if (cmd->cmdsize < sizeof(*cmd)) {
+            break;
+        }
+
+        if (cmd->cmd == LC_SEGMENT_64) {
+            const struct segment_command_64* segment = readData(mapping, sizeof(struct segment_command_64), commandOffset);
+            if (!segment) {
+                continue;
+            }
+
+            if (!ffStrEquals(segment->segname, "__TEXT")) {
+                continue;
+            }
+
+            for (uint32_t j = 0U; j < segment->nsects; j++) {
+                off_t sectionOffset = commandOffset + (off_t) sizeof(*segment) + (off_t) (j * sizeof(struct section_64));
+                const struct section_64* section = readData(mapping, sizeof(struct section_64), sectionOffset);
+                if (!section) {
+                    continue;
+                }
+
+                if (!handleMachSection(mapping, section->sectname, (off_t) section->offset, (size_t) section->size, cb, userdata, minLength)) {
+                    return NULL;
+                }
+            }
+        } else if (cmd->cmd == LC_SEGMENT) {
+            const struct segment_command* segment = readData(mapping, sizeof(struct segment_command), commandOffset);
+            if (!segment) {
+                continue;
+            }
+
+            if (!ffStrEquals(segment->segname, "__TEXT")) {
+                continue;
+            }
+
+            for (uint32_t j = 0; j < segment->nsects; j++) {
+                off_t sectionOffset = commandOffset + (off_t) sizeof(*segment) + (off_t) (j * sizeof(struct section));
+                const struct section* section = readData(mapping, sizeof(struct section), sectionOffset);
+                if (!section) {
+                    continue;
+                }
+
+                if (!handleMachSection(mapping, section->sectname, (off_t) section->offset, (size_t) section->size, cb, userdata, minLength)) {
+                    return NULL;
+                }
+            }
+        }
+
+        return NULL;
+    }
+
+    return NULL;
+}
+
+/**
+ * Processes a Fat binary header (Universal binary)
+ *
+ * This function handles the fat header of a universal binary, which can contain
+ * multiple Mach-O binaries for different architectures. It extracts and processes
+ * each embedded Mach-O file.
+ *
+ * @param mapping Memory mapping of the universal binary
+ * @param cb Callback function to process strings
+ * @param userdata User data for the callback
+ * @param minLength Minimum string length to extract
+ *
+ * @return NULL on success, error message on failure
+ */
+static const char* dumpFatHeader(const FFMemoryMapping* mapping, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength) {
+    const struct fat_header* headerRaw = readData(mapping, sizeof(struct fat_header), 0);
+    if (!headerRaw) {
+        return "read fat header failed";
+    }
+
+    struct fat_header header = *headerRaw;
+
+    bool needSwap = header.magic == FAT_CIGAM || header.magic == FAT_CIGAM_64;
+
+    if (needSwap) {
+        swap_fat_header(&header, NX_UnknownByteOrder);
+    }
+
+    for (uint32_t i = 0U; i < header.nfat_arch; i++) {
+        off_t machHeaderOffset = 0;
+        if (header.magic == FAT_MAGIC) {
+            off_t archOffset = (off_t) sizeof(struct fat_header) + (off_t) (i * sizeof(struct fat_arch));
+            const struct fat_arch* archRaw = readData(mapping, sizeof(struct fat_arch), archOffset);
+            if (!archRaw) {
+                continue;
+            }
+
+            struct fat_arch arch = *archRaw;
+
+            if (needSwap) {
+                swap_fat_arch(&arch, 1, NX_UnknownByteOrder);
+            }
+            machHeaderOffset = (off_t) arch.offset;
+        } else {
+            off_t archOffset = (off_t) sizeof(struct fat_header) + (off_t) (i * sizeof(struct fat_arch_64));
+            const struct fat_arch_64* archRaw = readData(mapping, sizeof(struct fat_arch_64), archOffset);
+            if (!archRaw) {
+                continue;
+            }
+
+            struct fat_arch_64 arch = *archRaw;
+
+            if (needSwap) {
+                swap_fat_arch_64(&arch, 1, NX_UnknownByteOrder);
+            }
+
+            machHeaderOffset = (off_t) arch.offset;
+        }
+
+        const uint32_t* magic = readData(mapping, sizeof(uint32_t), machHeaderOffset);
+        if (!magic) {
+            continue;
+        }
+
+        if (*magic == MH_MAGIC_64 || *magic == MH_MAGIC) {
+            return dumpMachHeader(mapping, machHeaderOffset, *magic == MH_MAGIC_64, cb, userdata, minLength);
+        }
+    }
+    return "Unsupported fat header";
+}
+
+/**
+ * Extracts string literals from a Mach-O (Apple) binary file
+ *
+ * This function supports both single-architecture Mach-O files and
+ * universal binaries (fat binaries) containing multiple architectures.
+ * It locates the __cstring section in the __TEXT segment which contains
+ * the string literals used in the program.
+ */
+const char* ffBinaryExtractStrings(const char* machoFile, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength) {
+    FF_AUTO_CLOSE_FD int fd = open(machoFile, O_RDONLY | O_CLOEXEC);
+    if (fd < 0) {
+        return "File could not be opened";
+    }
+
+    struct stat st;
+    if (fstat(fd, &st) != 0 || st.st_size <= 0) {
+        return "Failed to stat file";
+    }
+
+    FF_A_CLEANUP(wrapMunmap) FFMemoryMapping mapping = {
+        .data = mmap(NULL, (size_t) st.st_size, PROT_READ, MAP_PRIVATE, fd, 0),
+        .length = (size_t) st.st_size,
+    };
+    if (mapping.data == MAP_FAILED) {
+        return "mmap failed";
+    }
+
+    // Read the magic number to determine the type of binary
+    const uint32_t* magic = readData(&mapping, sizeof(uint32_t), 0);
+    if (!magic) {
+        return "read magic number failed";
+    }
+
+    // Check for supported formats
+    // MH_CIGAM and MH_CIGAM_64 seem to be no longer used, as `swap_mach_header` is marked as deprecated.
+    // However FAT_CIGAM and FAT_CIGAM_64 are still used (/usr/bin/vim).
+    if (*magic != MH_MAGIC && *magic != MH_MAGIC_64 && *magic != FAT_CIGAM && *magic != FAT_CIGAM_64 && *magic != FAT_MAGIC && *magic != FAT_MAGIC_64) {
+        return "Unsupported format or big endian mach-o file";
+    }
+
+    // Process either a fat binary or a regular Mach-O binary
+    if (*magic == FAT_MAGIC || *magic == FAT_MAGIC_64 || *magic == FAT_CIGAM || *magic == FAT_CIGAM_64) {
+        return dumpFatHeader(&mapping, cb, userdata, minLength);
+    } else {
+        return dumpMachHeader(&mapping, 0, *magic == MH_MAGIC_64, cb, userdata, minLength);
+    }
+}
@@ -1,13 +1,13 @@
-#include "binary.h"
+#include "common/binary.h"

 #if defined(FF_HAVE_ELF) || defined(__sun) || (defined(__FreeBSD__) && !defined(__DragonFly__)) || defined(__OpenBSD__) || defined(__NetBSD__)

-#include "common/io/io.h"
-#include "common/library.h"
-#include "util/stringUtils.h"
+    #include "common/io.h"
+    #include "common/library.h"
+    #include "common/stringUtils.h"

-#include <libelf.h> // #1254
-#include <fcntl.h>
+    #include <libelf.h> // #1254
+    #include <fcntl.h>

 /**
 * Structure to hold dynamically loaded libelf function pointers
@@ -36,15 +36,15 @@ struct FFElfData {
 *
 * The function supports both 32-bit and 64-bit ELF formats.
 */
-const char* ffBinaryExtractStrings(const char* elfFile, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength)
-{
+const char* ffBinaryExtractStrings(const char* elfFile, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength) {
    // Initialize libelf if not already done
-    if (!elfData.inited)
-    {
+    if (!elfData.inited) {
        elfData.inited = true;
-        FF_LIBRARY_LOAD(libelf, "dlopen libelf" FF_LIBRARY_EXTENSION " failed", "libelf" FF_LIBRARY_EXTENSION, 1);
+        FF_LIBRARY_LOAD_MESSAGE(libelf, "libelf" FF_LIBRARY_EXTENSION, 1);
        FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libelf, elfData, elf_version)
-        if (elfData.ffelf_version(EV_CURRENT) == EV_NONE) return "elf_version() failed";
+        if (elfData.ffelf_version(EV_CURRENT) == EV_NONE) {
+            return "elf_version() failed";
+        }

        // Load all required libelf functions
        FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libelf, elfData, elf_begin)
@@ -59,56 +59,69 @@ const char* ffBinaryExtractStrings(const char* elfFile, bool (*cb)(const char* s
        libelf = NULL;
    }

-    if (elfData.ffelf_end == NULL)
+    if (elfData.ffelf_end == NULL) {
        return "load libelf failed";
+    }

    // Open the ELF file
    FF_AUTO_CLOSE_FD int fd = open(elfFile, O_RDONLY | O_CLOEXEC);
-    if (fd < 0) return "open() failed";
+    if (fd < 0) {
+        return "open() failed";
+    }

    Elf* elf = elfData.ffelf_begin(fd, ELF_C_READ, NULL);
-    if (elf == NULL) return "elf_begin() failed";
+    if (elf == NULL) {
+        return "elf_begin() failed";
+    }

    // Get the section header string table index
    size_t shstrndx = 0;
-    if (elfData.ffelf_getshdrstrndx(elf, &shstrndx) < 0)
-    {
+    if (elfData.ffelf_getshdrstrndx(elf, &shstrndx) < 0) {
        elfData.ffelf_end(elf);
        return "elf_getshdrstrndx() failed";
    }

    // Iterate through all sections, looking for .rodata which contains string literals
    Elf_Scn* scn = NULL;
-    while ((scn = elfData.ffelf_nextscn(elf, scn)) != NULL)
-    {
+    while ((scn = elfData.ffelf_nextscn(elf, scn)) != NULL) {
        // Try 64-bit section header first, then 32-bit if that fails
        Elf64_Shdr* shdr64 = elfData.ffelf64_getshdr(scn);
        Elf32_Shdr* shdr32 = NULL;
-        if (shdr64 == NULL)
-        {
+        if (shdr64 == NULL) {
            shdr32 = elfData.ffelf32_getshdr(scn);
-            if (shdr32 == NULL) continue;
+            if (shdr32 == NULL) {
+                continue;
+            }
        }

        // Get the section name and check if it's .rodata
        const char* name = elfData.ffelf_strptr(elf, shstrndx, shdr64 ? shdr64->sh_name : shdr32->sh_name);
-        if (name == NULL || !ffStrEquals(name, ".rodata")) continue;
+        if (name == NULL || !ffStrEquals(name, ".rodata")) {
+            continue;
+        }

        // Get the section data
        Elf_Data* data = elfData.ffelf_getdata(scn, NULL);
-        if (data == NULL) continue;
+        if (data == NULL) {
+            continue;
+        }

        // Scan the section for string literals
-        for (size_t off = 0; off < data->d_size; ++off)
-        {
+        for (size_t off = 0; off < data->d_size; ++off) {
            const char* p = (const char*) data->d_buf + off;
-            if (*p == '\0') continue;
+            if (*p == '\0') {
+                continue;
+            }
            uint32_t len = (uint32_t) strlen(p);
-            if (len < minLength) continue;
+            if (len < minLength) {
+                continue;
+            }
            // Only process printable ASCII characters
            if (*p >= ' ' && *p <= '~') // Ignore control characters
            {
-                if (!cb(p, len, userdata)) break;
+                if (!cb(p, len, userdata)) {
+                    break;
+                }
            }
            off += len;
        }
@@ -125,8 +138,7 @@ const char* ffBinaryExtractStrings(const char* elfFile, bool (*cb)(const char* s
 /**
 * Fallback implementation when libelf is not available
 */
-const char* ffBinaryExtractStrings(const char* file, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength)
-{
+const char* ffBinaryExtractStrings(const char* file, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength) {
    FF_UNUSED(file, cb, userdata, minLength);
    return "Fastfetch was built without libelf support";
 }
@@ -0,0 +1,70 @@
+#include "common/binary.h"
+#include "common/io.h"
+#include "common/stringUtils.h"
+#include "common/windows/nt.h"
+
+#include <windows.h>
+#include <stdlib.h>
+#include <string.h>
+
+/**
+ * Extracts string literals from a PE (Windows) executable
+ *
+ * This function maps the PE file into memory, locates the .rdata section
+ * (which typically contains string literals), and scans it for valid strings.
+ * Each string found is passed to the callback function for processing.
+ */
+const char* ffBinaryExtractStrings(const char* peFile, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength) {
+    FF_AUTO_CLOSE_FD HANDLE hFile = CreateFileA(peFile, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+    if (hFile == INVALID_HANDLE_VALUE) {
+        return "CreateFileA() failed";
+    }
+
+    FF_AUTO_CLOSE_FD HANDLE hSection = NULL;
+    if (!NT_SUCCESS(NtCreateSection(&hSection, SECTION_MAP_READ, NULL, NULL, PAGE_READONLY, SEC_COMMIT, hFile))) {
+        return "NtCreateSection() failed";
+    }
+
+    PVOID base = NULL;
+    SIZE_T viewSize = 0;
+    if (!NT_SUCCESS(NtMapViewOfSection(hSection, NtCurrentProcess(), &base, 0, 0, NULL, &viewSize, ViewUnmap, 0, PAGE_READONLY))) {
+        return "NtMapViewOfSection() failed";
+    }
+
+    PIMAGE_NT_HEADERS ntHeaders = RtlImageNtHeader(base);
+    if (!ntHeaders) {
+        NtUnmapViewOfSection(NtCurrentProcess(), base);
+        return "RtlImageNtHeader() failed";
+    }
+
+    PIMAGE_SECTION_HEADER section = IMAGE_FIRST_SECTION(ntHeaders);
+    for (WORD i = 0; i < ntHeaders->FileHeader.NumberOfSections; ++i, ++section) {
+        // Look for initialized data sections with the name ".rdata" which typically contains string literals
+        if ((section->Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA) && ffStrEquals((const char*) section->Name, ".rdata")) {
+            uint8_t* data = (uint8_t*) base + section->PointerToRawData;
+
+            // Scan the section for string literals
+            for (size_t off = 0; off < section->SizeOfRawData; ++off) {
+                const char* p = (const char*) data + off;
+                if (*p == '\0') {
+                    continue;
+                }
+                uint32_t len = (uint32_t) strlen(p);
+                if (len < minLength) {
+                    continue;
+                }
+                // Only process printable ASCII characters
+                if (*p >= ' ' && *p <= '~') // Ignore control characters
+                {
+                    if (!cb(p, len, userdata)) {
+                        break;
+                    }
+                }
+                off += len;
+            }
+        }
+    }
+
+    NtUnmapViewOfSection(NtCurrentProcess(), base);
+    return NULL;
+}
@@ -0,0 +1,243 @@
+#include "common/commandoption.h"
+#include "common/color.h"
+#include "common/printing.h"
+#include "common/time.h"
+#include "common/jsonconfig.h"
+#include "common/stringUtils.h"
+#include "fastfetch_datatext.h"
+#include "modules/modules.h"
+
+#include <ctype.h>
+#include <inttypes.h>
+
+bool ffParseModuleOptions(const char* key, const char* value) {
+    if (!ffStrStartsWith(key, "--") || !ffCharIsEnglishAlphabet(key[2])) {
+        return false;
+    }
+    if (value && !*value) {
+        value = NULL;
+    }
+    for (FFModuleBaseInfo** modules = ffModuleInfos[toupper(key[2]) - 'A']; *modules; ++modules) {
+        FFModuleBaseInfo* baseInfo = *modules;
+        const char* subKey = ffOptionTestPrefix(key, baseInfo->name);
+        if (subKey != NULL) {
+            if (subKey[0] == '\0' || subKey[0] == '-') // Key is exactly the module name or has a leading '-'
+            {
+                fprintf(stderr, "Error: unknown module key %s\n", key);
+                exit(477);
+            }
+
+            FF_STRBUF_AUTO_DESTROY moduleName = ffStrbufCreateS(baseInfo->name);
+            ffStrbufLowerCase(&moduleName);
+
+            FF_STRBUF_AUTO_DESTROY jsonKey = ffStrbufCreate();
+            bool flag = false;
+            for (const char* p = subKey; *p; ++p) {
+                if (*p == '-') {
+                    if (flag) {
+                        fprintf(stderr, "Error: invalid double `-` in module key %s\n", key);
+                        exit(477);
+                    }
+                    flag = true;
+                } else {
+                    if (!isalpha((unsigned char) *p) && !isdigit((unsigned char) *p)) {
+                        fprintf(stderr, "Error: invalid character `%c` in module key %s\n", *p, key);
+                        exit(477);
+                    }
+
+                    if (flag) {
+                        flag = false;
+                        ffStrbufAppendC(&jsonKey, (char) toupper((unsigned char) *p));
+                    } else {
+                        ffStrbufAppendC(&jsonKey, *p);
+                    }
+                }
+            }
+            fprintf(stderr, "Error: Unsupported module option: %s\n", key);
+            fputs("       Support of module options has been removed. Please add the flag to the JSON config instead.\n", stderr);
+            fprintf(stderr, "       Example (demonstration only): `{ \"modules\": [ { \"type\": \"%s\", \"%s\": %s%s%s } ] }`\n", moduleName.chars, jsonKey.chars, value ? "\"" : "", value ?: "true", value ? "\"" : "");
+            fputs("       See <https://github.com/fastfetch-cli/fastfetch/wiki/Configuration> for more information.\n", stderr);
+            exit(477);
+        }
+    }
+    return false;
+}
+
+void ffPrepareCommandOption(FFdata* data) {
+    char* moduleType = NULL;
+    size_t moduleLen = 0;
+    while (ffStrbufGetdelim(&moduleType, &moduleLen, ':', &data->structure)) {
+#define FF_IF_MODULE_MATCH(moduleNameConstant) if (moduleLen == strlen(moduleNameConstant) && ffStrEqualsIgnCase(moduleType, moduleNameConstant) && !ffStrbufSeparatedContainIgnCaseS(&data->structureDisabled, moduleNameConstant, ':'))
+
+        switch (moduleType[0]) {
+            case 'C':
+            case 'c':
+                FF_IF_MODULE_MATCH(FF_CPUUSAGE_MODULE_NAME)
+                ffPrepareCPUUsage();
+                break;
+
+            case 'D':
+            case 'd':
+                FF_IF_MODULE_MATCH(FF_DISKIO_MODULE_NAME) {
+                    FF_A_CLEANUP(ffDestroyDiskIOOptions) FFDiskIOOptions options;
+                    ffInitDiskIOOptions(&options);
+                    ffPrepareDiskIO(&options);
+                }
+                break;
+
+            case 'N':
+            case 'n':
+                FF_IF_MODULE_MATCH(FF_NETIO_MODULE_NAME) {
+                    FF_A_CLEANUP(ffDestroyNetIOOptions) FFNetIOOptions options;
+                    ffInitNetIOOptions(&options);
+                    ffPrepareNetIO(&options);
+                }
+                break;
+
+            case 'P':
+            case 'p':
+                FF_IF_MODULE_MATCH(FF_PUBLICIP_MODULE_NAME) {
+                    FF_A_CLEANUP(ffDestroyPublicIpOptions) FFPublicIPOptions options;
+                    ffInitPublicIpOptions(&options);
+                    ffPreparePublicIp(&options);
+                }
+                break;
+
+            case 'W':
+            case 'w':
+                FF_IF_MODULE_MATCH(FF_WEATHER_MODULE_NAME) {
+                    FF_A_CLEANUP(ffDestroyWeatherOptions) FFWeatherOptions options;
+                    ffInitWeatherOptions(&options);
+                    ffPrepareWeather(&options);
+                }
+                break;
+        }
+
+#undef FF_IF_MODULE_MATCH
+    }
+}
+
+static void genJsonConfig(FFdata* data, FFModuleBaseInfo* baseInfo, void* options) {
+    yyjson_mut_doc* doc = data->resultDoc;
+
+    yyjson_mut_val* modules = yyjson_mut_obj_get(doc->root, "modules");
+    if (!modules) {
+        modules = yyjson_mut_obj_add_arr(doc, doc->root, "modules");
+    }
+
+    FF_STRBUF_AUTO_DESTROY type = ffStrbufCreateS(baseInfo->name);
+    ffStrbufLowerCase(&type);
+
+    if (data->docType == FF_RESULT_DOC_TYPE_CONFIG_FULL) {
+        yyjson_mut_val* module = yyjson_mut_obj(doc);
+        yyjson_mut_obj_add_strbuf(doc, module, "type", &type);
+
+        if (baseInfo->generateJsonConfig) {
+            baseInfo->generateJsonConfig(options, doc, module);
+        }
+
+        if (yyjson_mut_obj_size(module) > 1) {
+            yyjson_mut_arr_add_val(modules, module);
+        } else {
+            yyjson_mut_arr_add_strbuf(doc, modules, &type);
+        }
+    } else {
+        yyjson_mut_arr_add_strbuf(doc, modules, &type);
+    }
+}
+
+static void genJsonResult(FFdata* data, FFModuleBaseInfo* baseInfo, void* options) {
+    yyjson_mut_doc* doc = data->resultDoc;
+    yyjson_mut_val* module = yyjson_mut_arr_add_obj(doc, doc->root);
+    yyjson_mut_obj_add_str(doc, module, "type", baseInfo->name);
+    if (baseInfo->generateJsonResult) {
+        baseInfo->generateJsonResult(options, doc, module);
+    } else {
+        yyjson_mut_obj_add_str(doc, module, "error", "Unsupported for JSON format");
+    }
+}
+
+static void parseStructureCommand(
+    FFdata* data,
+    const char* line,
+    void (*fn)(FFdata*, FFModuleBaseInfo* baseInfo, void* options)) {
+    if (ffCharIsEnglishAlphabet(line[0])) {
+        for (FFModuleBaseInfo** modules = ffModuleInfos[toupper(line[0]) - 'A']; *modules; ++modules) {
+            FFModuleBaseInfo* baseInfo = *modules;
+            if (ffStrEqualsIgnCase(line, baseInfo->name)) {
+                uint8_t optionBuf[FF_OPTION_MAX_SIZE];
+                baseInfo->initOptions(optionBuf);
+                if (__builtin_expect(data->resultDoc != NULL, false)) {
+                    fn(data, baseInfo, optionBuf);
+                } else {
+                    baseInfo->printModule(optionBuf);
+                }
+                baseInfo->destroyOptions(optionBuf);
+                return;
+            }
+        }
+    }
+
+    ffPrintError(line, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "<no implementation provided>");
+}
+
+void ffPrintCommandOption(FFdata* data) {
+    // Parse the structure and call the modules
+    int32_t thres = instance.config.display.stat;
+
+    char* moduleType = NULL;
+    size_t moduleLen = 0;
+    while (ffStrbufGetdelim(&moduleType, &moduleLen, ':', &data->structure)) {
+        if (ffStrbufSeparatedContainIgnCaseS(&data->structureDisabled, moduleType, ':')) {
+            continue;
+        }
+
+        double ms = 0;
+        if (thres >= 0) {
+            ms = ffTimeGetTick();
+        }
+
+        parseStructureCommand(data, moduleType, genJsonResult);
+
+        if (thres >= 0) {
+            ms = ffTimeGetTick() - ms;
+
+            if (data->resultDoc) {
+                yyjson_mut_val* moduleJson = yyjson_mut_arr_get_last(data->resultDoc->root);
+                yyjson_mut_obj_add_real(data->resultDoc, moduleJson, "stat", ms);
+            } else {
+                char str[64];
+                int len = snprintf(str, sizeof str, "%.3fms", ms);
+                if (thres > 0) {
+                    snprintf(str, sizeof str, "\e[%sm%.3fms\e[m", (ms <= thres ? FF_COLOR_FG_GREEN : ms <= 2 * thres ? FF_COLOR_FG_YELLOW
+                                                                                                                     : FF_COLOR_FG_RED),
+                        ms);
+                }
+                printf("\e7\e[1A\e[9999999C\e[%dD%s\e8", len, str); // Save; Up 1; Right 9999999; Left <len>; Print <str>; Load
+            }
+        }
+
+#if defined(_WIN32)
+        if (!data->resultDoc && !instance.config.display.noBuffer) {
+            fflush(stdout);
+        }
+#endif
+    }
+}
+
+void ffMigrateCommandOptionToJsonc(FFdata* data) {
+    // If we don't have a custom structure, use the default one
+    if (data->structure.length == 0) {
+        ffStrbufAppendS(&data->structure, FASTFETCH_DATATEXT_STRUCTURE); // Cannot use `ffStrbufSetStatic` here because we will modify the string
+    }
+
+    char* moduleType = NULL;
+    size_t moduleLen = 0;
+    while (ffStrbufGetdelim(&moduleType, &moduleLen, ':', &data->structure)) {
+        if (ffStrbufSeparatedContainIgnCaseS(&data->structureDisabled, moduleType, ':')) {
+            continue;
+        }
+
+        parseStructureCommand(data, moduleType, genJsonConfig);
+    }
+}
@@ -1,12 +1,11 @@
-#include "dbus.h"
+#include "common/dbus.h"

 #ifdef FF_HAVE_DBUS

-#include "common/thread.h"
-#include "util/stringUtils.h"
+    #include "common/thread.h"
+    #include "common/stringUtils.h"

-static bool loadLibSymbols(FFDBusLibrary* lib)
-{
+static bool loadLibSymbols(FFDBusLibrary* lib) {
    FF_LIBRARY_LOAD(dbus, false, "libdbus-1" FF_LIBRARY_EXTENSION, 4);
    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_bus_get, false)
    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_new_method_call, false)
@@ -19,18 +18,17 @@ static bool loadLibSymbols(FFDBusLibrary* lib)
    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_iter_next, false)
    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_unref, false)
    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_connection_send_with_reply_and_block, false)
+    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_connection_unref, false)
    dbus = NULL; // don't auto dlclose
    return true;
 }

-static const FFDBusLibrary* loadLib(void)
-{
+static const FFDBusLibrary* loadLib(void) {
    static FFDBusLibrary lib;
    static bool loaded = false;
    static bool loadSuccess = false;

-    if(!loaded)
-    {
+    if (!loaded) {
        loaded = true;
        loadSuccess = loadLibSymbols(&lib);
    }
@@ -38,190 +36,189 @@ static const FFDBusLibrary* loadLib(void)
    return loadSuccess ? &lib : NULL;
 }

-const char* ffDBusLoadData(DBusBusType busType, FFDBusData* data)
-{
+const char* ffDBusLoadData(DBusBusType busType, FFDBusData* data) {
    data->lib = loadLib();
-    if(data->lib == NULL)
+    if (data->lib == NULL) {
        return "Failed to load DBus library";
+    }

    data->connection = data->lib->ffdbus_bus_get(busType, NULL);
-    if(data->connection == NULL)
+    if (data->connection == NULL) {
        return "Failed to connect to DBus";
+    }

    return NULL;
 }

-bool ffDBusGetString(FFDBusData* dbus, DBusMessageIter* iter, FFstrbuf* result)
-{
+void ffDBusDestroyData(FFDBusData* data) {
+    if (data->connection != NULL) {
+        data->lib->ffdbus_connection_unref(data->connection);
+        data->connection = NULL;
+    }
+}
+
+bool ffDBusGetString(FFDBusData* dbus, DBusMessageIter* iter, FFstrbuf* result) {
    int argType = dbus->lib->ffdbus_message_iter_get_arg_type(iter);

-    if(argType == DBUS_TYPE_STRING || argType == DBUS_TYPE_OBJECT_PATH)
-    {
+    if (argType == DBUS_TYPE_STRING || argType == DBUS_TYPE_OBJECT_PATH) {
        const char* value = NULL;
        dbus->lib->ffdbus_message_iter_get_basic(iter, &value);

-        if(!ffStrSet(value))
+        if (!ffStrSet(value)) {
            return false;
+        }

        ffStrbufAppendS(result, value);
        return true;
    }

-    if (argType == DBUS_TYPE_BYTE)
-    {
+    if (argType == DBUS_TYPE_BYTE) {
        uint8_t value;
        dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
        ffStrbufAppendC(result, (char) value);
        return false; // Don't append a comma
    }

-    if(argType != DBUS_TYPE_VARIANT && argType != DBUS_TYPE_ARRAY)
+    if (argType != DBUS_TYPE_VARIANT && argType != DBUS_TYPE_ARRAY) {
        return false;
+    }

    DBusMessageIter subIter;
    dbus->lib->ffdbus_message_iter_recurse(iter, &subIter);

-    if(argType == DBUS_TYPE_VARIANT)
+    if (argType == DBUS_TYPE_VARIANT) {
        return ffDBusGetString(dbus, &subIter, result);
+    }

-    //At this point we have an array
+    // At this point we have an array

    bool foundAValue = false;

-    while(true)
-    {
-        if(ffDBusGetString(dbus, &subIter, result))
-        {
+    while (true) {
+        if (ffDBusGetString(dbus, &subIter, result)) {
            foundAValue = true;
            ffStrbufAppendS(result, ", ");
        }

-        if(!dbus->lib->ffdbus_message_iter_next(&subIter))
+        if (!dbus->lib->ffdbus_message_iter_next(&subIter)) {
            break;
-        else
+        } else {
            continue;
+        }
    }

-    if(foundAValue)
+    if (foundAValue) {
        ffStrbufSubstrBefore(result, result->length - 2);
+    }

    return foundAValue;
 }

-bool ffDBusGetBool(FFDBusData* dbus, DBusMessageIter* iter, bool* result)
-{
+bool ffDBusGetBool(FFDBusData* dbus, DBusMessageIter* iter, bool* result) {
    int argType = dbus->lib->ffdbus_message_iter_get_arg_type(iter);

-    if(argType == DBUS_TYPE_BOOLEAN)
-    {
+    if (argType == DBUS_TYPE_BOOLEAN) {
        dbus_bool_t value = 0;
        dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
        *result = value != 0;
        return true;
    }

-    if(argType != DBUS_TYPE_VARIANT)
+    if (argType != DBUS_TYPE_VARIANT) {
        return false;
+    }

    DBusMessageIter subIter;
    dbus->lib->ffdbus_message_iter_recurse(iter, &subIter);
    return ffDBusGetBool(dbus, &subIter, result);
 }

-bool ffDBusGetUint(FFDBusData* dbus, DBusMessageIter* iter, uint32_t* result)
-{
+bool ffDBusGetUint(FFDBusData* dbus, DBusMessageIter* iter, uint32_t* result) {
    int argType = dbus->lib->ffdbus_message_iter_get_arg_type(iter);

-    if(argType == DBUS_TYPE_BYTE)
-    {
+    if (argType == DBUS_TYPE_BYTE) {
        uint8_t value = 0;
        dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
        *result = value;
        return true;
    }

-    if(argType == DBUS_TYPE_UINT16)
-    {
+    if (argType == DBUS_TYPE_UINT16) {
        uint16_t value = 0;
        dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
        *result = value;
        return true;
    }

-    if(argType == DBUS_TYPE_UINT32)
-    {
+    if (argType == DBUS_TYPE_UINT32) {
        dbus->lib->ffdbus_message_iter_get_basic(iter, result);
        return true;
    }

-    if(argType != DBUS_TYPE_VARIANT)
+    if (argType != DBUS_TYPE_VARIANT) {
        return false;
+    }

    DBusMessageIter subIter;
    dbus->lib->ffdbus_message_iter_recurse(iter, &subIter);
    return ffDBusGetUint(dbus, &subIter, result);
 }

-bool ffDBusGetInt(FFDBusData* dbus, DBusMessageIter* iter, int32_t* result)
-{
+bool ffDBusGetInt(FFDBusData* dbus, DBusMessageIter* iter, int32_t* result) {
    int argType = dbus->lib->ffdbus_message_iter_get_arg_type(iter);

-    if(argType == DBUS_TYPE_INT16)
-    {
+    if (argType == DBUS_TYPE_INT16) {
        int16_t value = 0;
        dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
        *result = value;
        return true;
    }

-    if(argType == DBUS_TYPE_INT32)
-    {
+    if (argType == DBUS_TYPE_INT32) {
        dbus->lib->ffdbus_message_iter_get_basic(iter, result);
        return true;
    }

-    if(argType == DBUS_TYPE_BYTE)
-    {
+    if (argType == DBUS_TYPE_BYTE) {
        uint8_t value = 0;
        dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
        *result = value;
        return true;
    }

-    if(argType == DBUS_TYPE_UINT16)
-    {
+    if (argType == DBUS_TYPE_UINT16) {
        uint16_t value = 0;
        dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
        *result = (int16_t) value;
        return true;
    }

-    if(argType == DBUS_TYPE_UINT32)
-    {
+    if (argType == DBUS_TYPE_UINT32) {
        dbus->lib->ffdbus_message_iter_get_basic(iter, result);
        return true;
    }

-    if(argType != DBUS_TYPE_VARIANT)
+    if (argType != DBUS_TYPE_VARIANT) {
        return false;
+    }

    DBusMessageIter subIter;
    dbus->lib->ffdbus_message_iter_recurse(iter, &subIter);
    return ffDBusGetInt(dbus, &subIter, result);
 }

-DBusMessage* ffDBusGetMethodReply(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* method, const char* arg1, const char* arg2)
-{
+DBusMessage* ffDBusGetMethodReply(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* method, const char* arg1, const char* arg2) {
    DBusMessage* message = dbus->lib->ffdbus_message_new_method_call(busName, objectPath, interface, method);
-    if(message == NULL)
+    if (message == NULL) {
        return NULL;
+    }

-    if (arg1)
-    {
-        if (arg2)
+    if (arg1) {
+        if (arg2) {
            dbus->lib->ffdbus_message_append_args(message, DBUS_TYPE_STRING, &arg1, DBUS_TYPE_STRING, &arg2, DBUS_TYPE_INVALID);
-        else
+        } else {
            dbus->lib->ffdbus_message_append_args(message, DBUS_TYPE_STRING, &arg1, DBUS_TYPE_INVALID);
+        }
    }

    DBusMessage* reply = dbus->lib->ffdbus_connection_send_with_reply_and_block(dbus->connection, message, instance.config.general.processingTimeout, NULL);
@@ -231,15 +228,17 @@ DBusMessage* ffDBusGetMethodReply(FFDBusData* dbus, const char* busName, const c
    return reply;
 }

-DBusMessage* ffDBusGetProperty(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property)
-{
+DBusMessage* ffDBusGetProperty(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property) {
    DBusMessage* message = dbus->lib->ffdbus_message_new_method_call(busName, objectPath, "org.freedesktop.DBus.Properties", "Get");
-    if(message == NULL)
+    if (message == NULL) {
        return NULL;
+    }

    dbus->lib->ffdbus_message_append_args(message,
-        DBUS_TYPE_STRING, &interface,
-        DBUS_TYPE_STRING, &property,
+        DBUS_TYPE_STRING,
+        &interface,
+        DBUS_TYPE_STRING,
+        &property,
        DBUS_TYPE_INVALID);

    DBusMessage* reply = dbus->lib->ffdbus_connection_send_with_reply_and_block(dbus->connection, message, instance.config.general.processingTimeout, NULL);
@@ -249,15 +248,14 @@ DBusMessage* ffDBusGetProperty(FFDBusData* dbus, const char* busName, const char
    return reply;
 }

-bool ffDBusGetPropertyString(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property, FFstrbuf* result)
-{
+bool ffDBusGetPropertyString(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property, FFstrbuf* result) {
    DBusMessage* reply = ffDBusGetProperty(dbus, busName, objectPath, interface, property);
-    if(reply == NULL)
+    if (reply == NULL) {
        return false;
+    }

    DBusMessageIter rootIterator;
-    if(!dbus->lib->ffdbus_message_iter_init(reply, &rootIterator))
-    {
+    if (!dbus->lib->ffdbus_message_iter_init(reply, &rootIterator)) {
        dbus->lib->ffdbus_message_unref(reply);
        return false;
    }
@@ -269,15 +267,14 @@ bool ffDBusGetPropertyString(FFDBusData* dbus, const char* busName, const char*
    return ret;
 }

-bool ffDBusGetPropertyUint(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property, uint32_t* result)
-{
+bool ffDBusGetPropertyUint(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property, uint32_t* result) {
    DBusMessage* reply = ffDBusGetProperty(dbus, busName, objectPath, interface, property);
-    if(reply == NULL)
+    if (reply == NULL) {
        return false;
+    }

    DBusMessageIter rootIterator;
-    if(!dbus->lib->ffdbus_message_iter_init(reply, &rootIterator))
-    {
+    if (!dbus->lib->ffdbus_message_iter_init(reply, &rootIterator)) {
        dbus->lib->ffdbus_message_unref(reply);
        return false;
    }
@@ -289,4 +286,4 @@ bool ffDBusGetPropertyUint(FFDBusData* dbus, const char* busName, const char* ob
    return ret;
 }

-#endif //FF_HAVE_DBUS
+#endif // FF_HAVE_DBUS
@@ -0,0 +1,55 @@
+#include "common/debug.h"
+#include "common/windows/nt.h"
+
+#include <windows.h>
+
+const char* ffDebugWin32Error(DWORD errorCode) {
+    static char buffer[512];
+
+    wchar_t bufferW[256];
+    ULONG len = FormatMessageW(
+        FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+        NULL,
+        (DWORD) errorCode,
+        0,
+        bufferW,
+        ARRAY_SIZE(bufferW),
+        NULL);
+
+    if (len == 0) {
+        snprintf(buffer, sizeof(buffer), "Unknown error code (%lu)", errorCode);
+    } else {
+        // Remove trailing newline
+        while (len > 0 && (bufferW[len - 1] == '\r' || bufferW[len - 1] == '\n')) {
+            --len;
+        }
+
+        if (NT_SUCCESS(RtlUnicodeToUTF8N(buffer, sizeof(buffer), &len, bufferW, len * sizeof(wchar_t)))) {
+            snprintf(buffer + len, sizeof(buffer) - len, " (%lu)", errorCode);
+        } else {
+            snprintf(buffer, sizeof(buffer), "Unknown error (%lu)", errorCode);
+        }
+    }
+
+    return buffer;
+}
+
+const char* ffDebugNtStatus(NTSTATUS status) {
+    return ffDebugWin32Error(RtlNtStatusToDosError(status));
+}
+
+static inline DWORD HRESULTToWin32Error(HRESULT hr) {
+    if (SUCCEEDED(hr)) {
+        return ERROR_SUCCESS;
+    }
+
+    if (HRESULT_FACILITY(hr) == FACILITY_WIN32) {
+        return HRESULT_CODE(hr);
+    }
+
+    return ERROR_INTERNAL_ERROR;
+}
+
+const char* ffDebugHResult(HRESULT hr) {
+    return ffDebugWin32Error(HRESULTToWin32Error(hr));
+}
@@ -1,25 +1,27 @@
-#include "duration.h"
+#include "common/duration.h"

-void ffDurationAppendNum(uint64_t totalSeconds, FFstrbuf* result)
-{
+void ffDurationAppendNum(uint64_t totalSeconds, FFstrbuf* result) {
    const FFOptionsDisplay* options = &instance.config.display;

    bool spaceBeforeUnit = options->durationSpaceBeforeUnit != FF_SPACE_BEFORE_UNIT_NEVER;

-    if (totalSeconds < 60)
-    {
+    if (totalSeconds < 60) {
        ffStrbufAppendUInt(result, totalSeconds);
-        if (spaceBeforeUnit) ffStrbufAppendC(result, ' ');
+        if (spaceBeforeUnit) {
+            ffStrbufAppendC(result, ' ');
+        }
        ffStrbufAppendS(result, options->durationAbbreviation ? "sec" : "second");
-        if (totalSeconds != 1)
+        if (totalSeconds != 1) {
            ffStrbufAppendC(result, 's');
+        }
        return;
    }

    uint32_t seconds = (uint32_t) (totalSeconds % 60);
    totalSeconds /= 60;
-    if (seconds >= 30)
+    if (seconds >= 30) {
        totalSeconds++;
+    }

    uint32_t minutes = (uint32_t) (totalSeconds % 60);
    totalSeconds /= 60;
@@ -27,56 +29,59 @@ void ffDurationAppendNum(uint64_t totalSeconds, FFstrbuf* result)
    totalSeconds /= 24;
    uint32_t days = (uint32_t) totalSeconds;

-    if (days > 0)
-    {
+    if (days > 0) {
        ffStrbufAppendUInt(result, days);
-        if (spaceBeforeUnit) ffStrbufAppendC(result, ' ');
-        if (options->durationAbbreviation)
-        {
+        if (spaceBeforeUnit) {
+            ffStrbufAppendC(result, ' ');
+        }
+        if (options->durationAbbreviation) {
            ffStrbufAppendC(result, 'd');

-            if (hours > 0 || minutes > 0)
+            if (hours > 0 || minutes > 0) {
                ffStrbufAppendC(result, ' ');
-        }
-        else
-        {
+            }
+        } else {
            ffStrbufAppendS(result, days == 1 ? "day" : "days");

-            if (days >= 100)
+            if (days >= 100) {
                ffStrbufAppendS(result, "(!)");
+            }

-            if (hours > 0 || minutes > 0)
+            if (hours > 0 || minutes > 0) {
                ffStrbufAppendS(result, ", ");
+            }
        }
    }

-    if (hours > 0)
-    {
+    if (hours > 0) {
        ffStrbufAppendUInt(result, hours);
-        if (spaceBeforeUnit) ffStrbufAppendC(result, ' ');
-        if (options->durationAbbreviation)
-        {
+        if (spaceBeforeUnit) {
+            ffStrbufAppendC(result, ' ');
+        }
+        if (options->durationAbbreviation) {
            ffStrbufAppendC(result, 'h');

-            if (minutes > 0)
+            if (minutes > 0) {
                ffStrbufAppendC(result, ' ');
-        }
-        else
-        {
+            }
+        } else {
            ffStrbufAppendS(result, hours == 1 ? "hour" : "hours");

-            if (minutes > 0)
+            if (minutes > 0) {
                ffStrbufAppendS(result, ", ");
+            }
        }
    }

-    if (minutes > 0)
-    {
+    if (minutes > 0) {
        ffStrbufAppendUInt(result, minutes);
-        if (spaceBeforeUnit) ffStrbufAppendC(result, ' ');
-        if (options->durationAbbreviation)
+        if (spaceBeforeUnit) {
+            ffStrbufAppendC(result, ' ');
+        }
+        if (options->durationAbbreviation) {
            ffStrbufAppendC(result, 'm');
-        else
+        } else {
            ffStrbufAppendS(result, minutes == 1 ? "min" : "mins");
+        }
    }
 }
@@ -0,0 +1,132 @@
+#include "common/edidHelper.h"
+
+void ffEdidGetPhysicalResolution(const uint8_t edid[128], uint32_t* width, uint32_t* height) {
+    const int dtd = 54;
+    *width = (((uint32_t) edid[dtd + 4] >> 4) << 8) | edid[dtd + 2];
+    *height = (((uint32_t) edid[dtd + 7] >> 4) << 8) | edid[dtd + 5];
+}
+
+void ffEdidGetPreferredResolutionAndRefreshRate(const uint8_t edid[128], uint32_t* width, uint32_t* height, double* refreshRate) {
+    for (uint32_t i = 0x36; i < 0x7E; i += 0x12) {    // read through descriptor blocks...
+        if (edid[i] != 0x00 && edid[i + 1] != 0x00) { // a dtd
+            uint32_t hactive = edid[i + 2] + (uint32_t) ((edid[i + 4] & 0xf0) << 4);
+            uint32_t hblank = edid[i + 3] + (uint32_t) ((edid[i + 4] & 0x0f) << 8);
+            uint32_t vactive = edid[i + 5] + (uint32_t) ((edid[i + 7] & 0xf0) << 4);
+            uint32_t vblank = edid[i + 6] + (uint32_t) ((edid[i + 7] & 0x0f) << 8);
+            uint32_t pixclk = ((uint32_t) edid[i + 1] << 8) | (edid[i]);
+            *width = hactive;
+            *height = vactive;
+            *refreshRate = (double) pixclk * 10000 / (double) (hactive + hblank) / (double) (vactive + vblank);
+            return;
+        }
+    }
+}
+
+void ffEdidGetVendorAndModel(const uint8_t edid[128], FFstrbuf* result) {
+    // https://github.com/jinksong/read_edid/blob/master/parse-edid/parse-edid.c
+    ffStrbufAppendF(result, "%c%c%c%04X", (char) (((uint32_t) edid[8] >> 2 & 0x1f) + 'A' - 1), (char) (((((uint32_t) edid[8] & 0x3) << 3) | (((uint32_t) edid[9] & 0xe0) >> 5)) + 'A' - 1), (char) (((uint32_t) edid[9] & 0x1f) + 'A' - 1), (uint32_t) (edid[10] + (uint32_t) (edid[11] << 8)));
+}
+
+bool ffEdidGetName(const uint8_t edid[128], FFstrbuf* name) {
+    // https://github.com/jinksong/read_edid/blob/master/parse-edid/parse-edid.c
+    for (uint32_t i = 0x36; i < 0x7E; i += 0x12) { // read through descriptor blocks...
+        if (edid[i] == 0x00) {                     // not a timing descriptor
+            if (edid[i + 3] == 0xfc) {             // Model Name tag
+                for (uint32_t j = 0; j < 13; j++) {
+                    if (edid[i + 5 + j] == 0x0a) {
+                        ffStrbufAppendNS(name, j, (const char*) &edid[i + 5]);
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+
+    // use manufacturer + model number as monitor name
+    ffEdidGetVendorAndModel(edid, name);
+    return false;
+}
+
+void ffEdidGetPhysicalSize(const uint8_t edid[128], uint32_t* width, uint32_t* height) {
+    // Detailed Timing Descriptors
+    uint32_t dw = (((uint32_t) edid[68] & 0xF0) << 4) + edid[66];
+    uint32_t dh = (((uint32_t) edid[68] & 0x0F) << 8) + edid[67];
+
+    // Basic Display Parameters
+    uint32_t bw = edid[21] * 10;
+    uint32_t bh = edid[22] * 10;
+
+    // Some monitors report invalid data in DTD. See #1406
+    if (abs((int) dw - (int) bw) < 10 && abs((int) dh - (int) bh) < 10) {
+        *width = dw;
+        *height = dh;
+    } else {
+        *width = bw;
+        *height = bh;
+    }
+}
+
+void ffEdidGetSerialAndManufactureDate(const uint8_t edid[128], uint32_t* serial, uint16_t* year, uint16_t* week) {
+    if (edid[17] > 0 && edid[17] < 0xFF) {
+        *year = (uint16_t) (edid[17] + 1990);
+        *week = (uint16_t) edid[16];
+        if (*week == 0xFF) {
+            *week = 0;
+        }
+    } else {
+        *year = *week = 0;
+    }
+
+    *serial = *(uint32_t*) &edid[12];
+}
+
+bool ffEdidGetHdrCompatible(const uint8_t* edid, uint32_t length) {
+    if (length <= 128) {
+        return false;
+    }
+    for (const uint8_t* cta = &edid[128]; cta < &edid[length]; cta += 128) {
+        // https://en.wikipedia.org/wiki/Extended_Display_Identification_Data#CTA_EDID_Timing_Extension_Block
+        if (cta[0] != 0x02 /* CTA EDID */) {
+            continue;
+        }
+        if (cta[1] < 0x03 /* Version 3 */) {
+            continue;
+        }
+        const uint8_t offset = cta[2];
+        if (offset <= 4) {
+            continue;
+        }
+        for (uint8_t i = 4; i < offset;) {
+            uint8_t blkLen = cta[i] & 0x1f;
+            if (blkLen > 0) {
+                uint8_t blkTag = (cta[i] & 0xe0) >> 5;
+                if (blkTag == 0x07 /* Extended Block Type Tag */) {
+                    uint8_t extendedTag = cta[i + 1];
+                    if (extendedTag == 6 /* HDR SMDB */ || extendedTag == 7 /* HDR DMDB */) {
+                        return true;
+                    }
+                }
+            }
+            i += (uint8_t) (blkLen + 1);
+        }
+    }
+    return false;
+}
+
+bool ffEdidIsValid(const uint8_t edid[128], uint32_t length) {
+    if (length < 128 || length % 128 != 0) {
+        return false;
+    }
+
+    static const uint8_t edidHeader[] = { 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00 };
+    if (memcmp(edid, edidHeader, sizeof(edidHeader)) != 0) {
+        return false;
+    }
+
+    uint8_t sum = 0;
+    for (uint32_t i = 0; i < 128; i++) {
+        sum += edid[i];
+    }
+
+    return sum == 0;
+}
@@ -0,0 +1,508 @@
+#include "fastfetch.h"
+#include "common/FFlist.h"
+#include "common/FFstrbuf.h"
+#include "common/stringUtils.h"
+#include "common/font.h"
+
+#include <string.h>
+#include <ctype.h>
+
+void ffFontInit(FFfont* font) {
+    // Ensure no memory allocates
+    ffStrbufInit(&font->pretty);
+    ffStrbufInit(&font->name);
+    ffStrbufInit(&font->size);
+    ffListInit(&font->styles);
+}
+
+static void strbufAppendNSExcludingC(FFstrbuf* strbuf, uint32_t length, const char* value, char exclude) {
+    if (value == NULL || length == 0) {
+        return;
+    }
+
+    ffStrbufEnsureFree(strbuf, length);
+
+    for (uint32_t i = 0; i < length; i++) {
+        if (value[i] != exclude) {
+            strbuf->chars[strbuf->length++] = value[i];
+        }
+    }
+
+    strbuf->chars[strbuf->length] = '\0';
+}
+
+static void fontInitPretty(FFfont* font) {
+    ffStrbufAppend(&font->pretty, &font->name);
+
+    if (font->size.length == 0 && font->styles.length == 0) {
+        return;
+    } else if (font->pretty.length == 0) {
+        ffStrbufAppendS(&font->pretty, "default");
+    }
+
+    ffStrbufAppendS(&font->pretty, " (");
+
+    if (font->size.length > 0) {
+        ffStrbufAppend(&font->pretty, &font->size);
+        if (!ffStrbufEndsWithS(&font->size, "pt") && !ffStrbufEndsWithS(&font->size, "px")) {
+            ffStrbufAppendS(&font->pretty, "pt");
+        }
+
+        if (font->styles.length > 0) {
+            ffStrbufAppendS(&font->pretty, ", ");
+        }
+    }
+
+    for (uint32_t i = 0; i < font->styles.length; i++) {
+        ffStrbufAppend(&font->pretty, FF_LIST_GET(FFstrbuf, font->styles, i));
+
+        if (i < font->styles.length - 1) {
+            ffStrbufAppendS(&font->pretty, ", ");
+        }
+    }
+
+    ffStrbufAppendC(&font->pretty, ')');
+}
+
+void ffFontInitQt(FFfont* font, const char* data) {
+    ffFontInit(font);
+
+    // See https://doc.qt.io/qt-5/qfont.html#toString
+
+    // Family
+    data = ffStrbufAppendSUntilC(&font->name, data, ',');
+    ffStrbufTrim(&font->name, ' ');
+    if (!data) {
+        goto exit;
+    }
+    data++;
+
+    // Size
+    data = ffStrbufAppendSUntilC(&font->size, data, ',');
+    ffStrbufTrim(&font->size, ' ');
+    if (!data) {
+        goto exit;
+    }
+    data++;
+
+    // Style
+    data = strrchr(data, ',');
+    if (!data) {
+        goto exit;
+    }
+    data++;
+    if (isalpha(*data)) {
+        do {
+            FFstrbuf* style = FF_LIST_ADD(FFstrbuf, font->styles);
+            ffStrbufInit(style);
+            data = ffStrbufAppendSUntilC(style, data, ' ');
+            if (data) {
+                data++;
+            }
+        } while (data);
+    }
+
+exit:
+    fontInitPretty(font);
+}
+
+static void fontPangoParseWord(const char** data, FFfont* font, FFstrbuf* alternativeBuffer) {
+    while (**data == ' ' || **data == '\t' || **data == ',') {
+        ++(*data);
+    }
+
+    const char* wordStart = *data;
+
+    while (**data != ' ' && **data != '\t' && **data != ',' && **data != '\0' && **data != '`' && **data != '\\') {
+        ++(*data);
+    }
+
+    uint32_t wordLength = (uint32_t) (*data - wordStart);
+    if (wordLength == 0) {
+        return;
+    }
+
+    if (**data == '\0' || **data == '`' || **data == '\\') {
+        ffStrbufAppendNS(&font->size, wordLength, wordStart);
+        if (ffStrbufEndsWithS(&font->size, "px")) {
+            ffStrbufSubstrBefore(&font->size, font->size.length - 2);
+        }
+
+        double dummy;
+        if (sscanf(font->size.chars, "%lf", &dummy) == 1) {
+            return;
+        }
+
+        ffStrbufClear(&font->size);
+    }
+
+    if (
+        ffStrStartsWithIgnCase(wordStart, "Ultra") ||
+        ffStrStartsWithIgnCase(wordStart, "Extra") ||
+        ffStrStartsWithIgnCase(wordStart, "Semi") ||
+        ffStrStartsWithIgnCase(wordStart, "Demi") ||
+        ffStrStartsWithIgnCase(wordStart, "Normal") ||
+        ffStrStartsWithIgnCase(wordStart, "Roman") ||
+        ffStrStartsWithIgnCase(wordStart, "Oblique") ||
+        ffStrStartsWithIgnCase(wordStart, "Italic") ||
+        ffStrStartsWithIgnCase(wordStart, "Thin") ||
+        ffStrStartsWithIgnCase(wordStart, "Light") ||
+        ffStrStartsWithIgnCase(wordStart, "Bold") ||
+        ffStrStartsWithIgnCase(wordStart, "Black") ||
+        ffStrStartsWithIgnCase(wordStart, "Condensed") ||
+        ffStrStartsWithIgnCase(wordStart, "Expanded")) {
+        if (alternativeBuffer == NULL) {
+            alternativeBuffer = FF_LIST_ADD(FFstrbuf, font->styles);
+            ffStrbufInit(alternativeBuffer);
+        }
+
+        strbufAppendNSExcludingC(alternativeBuffer, wordLength, wordStart, '-');
+
+        if (
+            ffStrStartsWithIgnCase(wordStart, "Ultra ") ||
+            ffStrStartsWithIgnCase(wordStart, "Extra ") ||
+            ffStrStartsWithIgnCase(wordStart, "Semi ") ||
+            ffStrStartsWithIgnCase(wordStart, "Demi ")) {
+            fontPangoParseWord(data, font, alternativeBuffer);
+        }
+
+        return;
+    }
+
+    if (alternativeBuffer != NULL) {
+        strbufAppendNSExcludingC(alternativeBuffer, wordLength, wordStart, '-');
+        return;
+    }
+
+    if (font->name.length > 0) {
+        ffStrbufAppendC(&font->name, ' ');
+    }
+    ffStrbufAppendNS(&font->name, wordLength, wordStart);
+}
+
+void ffFontInitPango(FFfont* font, const char* data) {
+    ffFontInit(font);
+
+    while (*data != '\0' && *data != '`' && *data != '\\') {
+        fontPangoParseWord(&data, font, NULL);
+    }
+
+    fontInitPretty(font);
+}
+
+void ffFontInitValues(FFfont* font, const char* name, const char* size) {
+    ffFontInit(font);
+
+    ffStrbufAppendS(&font->name, name);
+    ffStrbufTrim(&font->name, '"');
+    ffStrbufAppendS(&font->size, size);
+
+    fontInitPretty(font);
+}
+
+void ffFontInitXlfd(FFfont* font, const char* xlfd) {
+    assert(xlfd && *xlfd);
+
+    // https://en.wikipedia.org/wiki/X_logical_font_description
+    ffFontInit(font);
+
+    // XLFD: -foundry-family-weight-slant-setwidth-addstyle-pixelsize-pointsize-xres-yres-spacing-averagewidth-charsetregistry-charsetencoding
+    // It often starts with '-', which would create an empty first field. Skip it to align indexes.
+    if (*xlfd == '-') {
+        xlfd++;
+    }
+
+    const char* pstart = xlfd;
+
+    for (int field = 0; field < 14; field++) {
+        const char* pend = strchr(pstart, '-');
+        uint32_t length = pend ? (uint32_t) (pend - pstart) : (uint32_t) strlen(pstart);
+
+        if (length > 0) {
+            if (field == 1) // family
+            {
+                ffStrbufAppendNS(&font->name, length, pstart);
+            } else if (field == 7) // pointsize (decipoints, preferred)
+            {
+                // parse positive integer from substring
+                long deciPt = 0;
+                bool ok = true;
+                for (uint32_t i = 0; i < length; i++) {
+                    char c = pstart[i];
+                    if (c < '0' || c > '9') {
+                        ok = false;
+                        break;
+                    }
+                    deciPt = deciPt * 10 + (c - '0');
+                }
+
+                if (ok && deciPt > 0) {
+                    ffStrbufClear(&font->size);
+
+                    char tmp[32];
+                    if (deciPt % 10 == 0) {
+                        snprintf(tmp, sizeof(tmp), "%ldpt", deciPt / 10);
+                    } else {
+                        snprintf(tmp, sizeof(tmp), "%ld.%ldpt", deciPt / 10, deciPt % 10);
+                    }
+
+                    ffStrbufAppendS(&font->size, tmp);
+                }
+            } else if (field == 6) // pixelsize (fallback if pointsize missing/invalid)
+            {
+                if (font->size.length == 0) {
+                    long px = 0;
+                    bool ok = true;
+                    for (uint32_t i = 0; i < length; i++) {
+                        char c = pstart[i];
+                        if (c < '0' || c > '9') {
+                            ok = false;
+                            break;
+                        }
+                        px = px * 10 + (c - '0');
+                    }
+
+                    if (ok && px > 0) {
+                        ffStrbufAppendNS(&font->size, length, pstart);
+                        ffStrbufAppendS(&font->size, "px");
+                    }
+                }
+            } else if (field >= 2 && field <= 5) // weight/slant/setwidth/addstyle
+            {
+                // ignore "normal" (case-insensitive)
+                if (!(length == 6 && ffStrStartsWithIgnCase(pstart, "normal"))) {
+                    FFstrbuf* style = FF_LIST_ADD(FFstrbuf, font->styles);
+                    ffStrbufInitNS(style, length, pstart);
+                }
+            }
+        }
+
+        if (!pend) {
+            break;
+        }
+
+        pstart = pend + 1;
+    }
+
+    fontInitPretty(font);
+}
+
+void ffFontInitXft(FFfont* font, const char* xft) {
+    assert(xft);
+
+    // https://en.wikipedia.org/wiki/Xft
+    // Xft/Fontconfig pattern examples:
+    //   "DejaVu Sans Mono-10"
+    //   "monospace:size=10:weight=bold:slant=italic"
+    //   "Fira Code-12:style=Regular"
+    // Goal: extract family(name), size, and some common styles.
+
+    ffFontInit(font);
+
+    // 1) Parse "head" part before first ':' => usually "family[-size]" (may include commas)
+    const char* p = xft;
+
+    while (*p == ' ' || *p == '\t') {
+        ++p;
+    }
+
+    const char* headStart = p;
+    while (*p != '\0' && *p != ':') {
+        ++p;
+    }
+    const char* headEnd = p;
+
+    // trim tail spaces
+    while (headEnd > headStart && (headEnd[-1] == ' ' || headEnd[-1] == '\t')) {
+        --headEnd;
+    }
+
+    // If multiple families are listed, take the first one (up to comma)
+    for (const char* q = headStart; q < headEnd; ++q) {
+        if (*q == ',') {
+            headEnd = q;
+            while (headEnd > headStart && (headEnd[-1] == ' ' || headEnd[-1] == '\t')) {
+                --headEnd;
+            }
+            break;
+        }
+    }
+
+    // Try parse trailing "-<number>" as size, otherwise entire head is name
+    const char* dashPos = NULL;
+    const char* sizeStart = NULL;
+
+    for (const char* q = headEnd; q > headStart;) {
+        --q;
+        if (*q == '-' && (q + 1) < headEnd && ffCharIsDigit(q[1])) {
+            dashPos = q;
+            sizeStart = q + 1;
+            break;
+        }
+    }
+
+    if (dashPos) {
+        bool ok = true;
+        bool seenDigit = false;
+        for (const char* q = sizeStart; q < headEnd; ++q) {
+            if (ffCharIsDigit(*q)) {
+                seenDigit = true;
+            } else if (*q == '.') {
+                continue;
+            } else {
+                ok = false;
+                break;
+            }
+        }
+
+        if (ok && seenDigit) {
+            const char* nameEnd = dashPos;
+            while (nameEnd > headStart && (nameEnd[-1] == ' ' || nameEnd[-1] == '\t')) {
+                --nameEnd;
+            }
+
+            if (nameEnd > headStart) {
+                ffStrbufAppendNS(&font->name, (uint32_t) (nameEnd - headStart), headStart);
+            }
+
+            if (headEnd > sizeStart) {
+                ffStrbufAppendNS(&font->size, (uint32_t) (headEnd - sizeStart), sizeStart);
+            }
+        } else {
+            if (headEnd > headStart) {
+                ffStrbufAppendNS(&font->name, (uint32_t) (headEnd - headStart), headStart);
+            }
+        }
+    } else {
+        if (headEnd > headStart) {
+            ffStrbufAppendNS(&font->name, (uint32_t) (headEnd - headStart), headStart);
+        }
+    }
+
+    ffStrbufTrim(&font->name, ' ');
+    ffStrbufTrim(&font->name, '"');
+
+    // 2) Parse key=value fields after ':' (Fontconfig-like). Fields separated by ':'.
+    // Common keys: size, pixelsize, pointsize, style, weight, slant, width
+    while (*p == ':') {
+        ++p;
+
+        // key
+        const char* keyStart = p;
+        while (*p != '\0' && *p != '=' && *p != ':') {
+            ++p;
+        }
+        const char* keyEnd = p;
+
+        if (*p != '=') {
+            continue; // skip tokens without '='
+        }
+
+        ++p; // skip '='
+
+        // value (until next ':', allow backslash-escaping)
+        FF_STRBUF_AUTO_DESTROY value = ffStrbufCreate();
+
+        while (*p != '\0' && *p != ':') {
+            if (*p == '\\' && p[1] != '\0') {
+                ++p;
+                ffStrbufAppendC(&value, *p);
+                ++p;
+                continue;
+            }
+
+            ffStrbufAppendC(&value, *p);
+            ++p;
+        }
+
+        ffStrbufTrim(&value, ' ');
+        ffStrbufTrim(&value, '"');
+
+        uint32_t keyLen = (uint32_t) (keyEnd - keyStart);
+
+        // helper: set numeric size if not set yet
+        const bool sizeEmpty = (font->size.length == 0);
+        if (value.length > 0) {
+            if (
+                (keyLen == 4 && ffStrStartsWithIgnCase(keyStart, "size")) ||
+                (keyLen == 9 && ffStrStartsWithIgnCase(keyStart, "pixelsize"))) {
+                if (sizeEmpty && ffCharIsDigit(value.chars[0])) {
+                    ffStrbufAppend(&font->size, &value);
+                    ffStrbufAppendS(&font->size, keyLen == 4 ? "pt" : "px");
+                }
+            } else if (keyLen == 5 && ffStrStartsWithIgnCase(keyStart, "style")) {
+                // style may contain multiple words: "Bold Italic"
+                const char* s = value.chars;
+                while (*s != '\0') {
+                    while (*s == ' ' || *s == '\t' || *s == ',') {
+                        ++s;
+                    }
+
+                    const char* w = s;
+                    while (*s != '\0' && *s != ' ' && *s != '\t' && *s != ',') {
+                        ++s;
+                    }
+
+                    if (s > w) {
+                        FFstrbuf* style = FF_LIST_ADD(FFstrbuf, font->styles);
+                        ffStrbufInitNS(style, (uint32_t) (s - w), w);
+                    }
+                }
+            } else if (
+                (keyLen == 6 && ffStrStartsWithIgnCase(keyStart, "weight")) ||
+                (keyLen == 5 && ffStrStartsWithIgnCase(keyStart, "slant")) ||
+                (keyLen == 5 && ffStrStartsWithIgnCase(keyStart, "width"))) {
+                // normalize: remove '-' to align with other parsers ("Semi-Bold" -> "SemiBold")
+                FFstrbuf* style = FF_LIST_ADD(FFstrbuf, font->styles);
+                ffStrbufInit(style);
+                strbufAppendNSExcludingC(style, value.length, value.chars, '-');
+                ffStrbufTrim(style, ' ');
+            }
+        }
+    }
+
+    fontInitPretty(font);
+}
+
+void ffFontInitMoveValues(FFfont* font, FFstrbuf* name, FFstrbuf* size, FFstrbuf* style) {
+    ffFontInit(font);
+
+    if (name) {
+        ffStrbufInitMove(&font->name, name);
+    }
+    if (size) {
+        ffStrbufInitMove(&font->size, size);
+    }
+    if (style) {
+        FFstrbuf* styleBuf = FF_LIST_ADD(FFstrbuf, font->styles);
+        ffStrbufInitMove(styleBuf, style);
+    }
+
+    fontInitPretty(font);
+}
+
+void ffFontInitWithSpace(FFfont* font, const char* rawName) {
+    const char* pspace = strrchr(rawName, ' ');
+    if (pspace == NULL) {
+        ffFontInitCopy(font, rawName);
+        return;
+    }
+
+    ffFontInit(font);
+
+    ffStrbufAppendNS(&font->name, (uint32_t) (pspace - rawName), rawName);
+    ffStrbufAppendS(&font->size, pspace + 1);
+
+    fontInitPretty(font);
+}
+
+void ffFontDestroy(FFfont* font) {
+    ffStrbufDestroy(&font->pretty);
+    ffStrbufDestroy(&font->name);
+    ffStrbufDestroy(&font->size);
+
+    FF_LIST_FOR_EACH (FFstrbuf, str, font->styles) {
+        ffStrbufDestroy(str);
+    }
+    ffListDestroy(&font->styles);
+}
@@ -1,59 +1,63 @@
 #include "fastfetch.h"
 #include "common/format.h"
 #include "common/parsing.h"
-#include "util/textModifier.h"
-#include "util/stringUtils.h"
+#include "common/textModifier.h"
+#include "common/stringUtils.h"

 #include <inttypes.h>

-void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg)
-{
-    switch(formatarg->type)
-    {
-        case FF_FORMAT_ARG_TYPE_INT:
-            ffStrbufAppendSInt(buffer, *(int32_t*)formatarg->value);
+void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg) {
+    switch (formatarg->type) {
+        case FF_ARG_TYPE_INT:
+            ffStrbufAppendSInt(buffer, *(int32_t*) formatarg->value);
            break;
-        case FF_FORMAT_ARG_TYPE_UINT:
-            ffStrbufAppendUInt(buffer, *(uint32_t*)formatarg->value);
+        case FF_ARG_TYPE_UINT:
+            ffStrbufAppendUInt(buffer, *(uint32_t*) formatarg->value);
            break;
-        case FF_FORMAT_ARG_TYPE_UINT64:
-            ffStrbufAppendUInt(buffer, *(uint64_t*)formatarg->value);
+        case FF_ARG_TYPE_UINT64:
+            ffStrbufAppendUInt(buffer, *(uint64_t*) formatarg->value);
            break;
-        case FF_FORMAT_ARG_TYPE_UINT16:
-            ffStrbufAppendUInt(buffer, *(uint16_t*)formatarg->value);
+        case FF_ARG_TYPE_UINT16:
+            ffStrbufAppendUInt(buffer, *(uint16_t*) formatarg->value);
            break;
-        case FF_FORMAT_ARG_TYPE_UINT8:
-            ffStrbufAppendUInt(buffer, *(uint8_t*)formatarg->value);
+        case FF_ARG_TYPE_UINT8:
+            ffStrbufAppendUInt(buffer, *(uint8_t*) formatarg->value);
            break;
-        case FF_FORMAT_ARG_TYPE_STRING:
-            ffStrbufAppendS(buffer, (const char*)formatarg->value);
+        case FF_ARG_TYPE_STRING:
+            ffStrbufAppendS(buffer, (const char*) formatarg->value);
            break;
-        case FF_FORMAT_ARG_TYPE_STRBUF:
-            ffStrbufAppend(buffer, (const FFstrbuf*)formatarg->value);
+        case FF_ARG_TYPE_STRBUF:
+            ffStrbufAppend(buffer, (const FFstrbuf*) formatarg->value);
            break;
-        case FF_FORMAT_ARG_TYPE_FLOAT:
-            ffStrbufAppendDouble(buffer, *(float*)formatarg->value, instance.config.display.fractionNdigits, instance.config.display.fractionTrailingZeros != FF_FRACTION_TRAILING_ZEROS_TYPE_NEVER);
+        case FF_ARG_TYPE_FLOAT:
+            ffStrbufAppendDouble(buffer, *(float*) formatarg->value, instance.config.display.fractionNdigits, instance.config.display.fractionTrailingZeros != FF_FRACTION_TRAILING_ZEROS_TYPE_NEVER);
            break;
-        case FF_FORMAT_ARG_TYPE_DOUBLE:
-            ffStrbufAppendDouble(buffer, *(double*)formatarg->value, instance.config.display.fractionNdigits, instance.config.display.fractionTrailingZeros != FF_FRACTION_TRAILING_ZEROS_TYPE_NEVER);
+        case FF_ARG_TYPE_DOUBLE:
+            ffStrbufAppendDouble(buffer, *(double*) formatarg->value, instance.config.display.fractionNdigits, instance.config.display.fractionTrailingZeros != FF_FRACTION_TRAILING_ZEROS_TYPE_NEVER);
            break;
-        case FF_FORMAT_ARG_TYPE_BOOL:
-            ffStrbufAppendS(buffer, *(bool*)formatarg->value ? "true" : "false");
+        case FF_ARG_TYPE_BOOL:
+            ffStrbufAppendS(buffer, *(bool*) formatarg->value ? "true" : "false");
            break;
-        case FF_FORMAT_ARG_TYPE_LIST:
-        {
+        case FF_ARG_TYPE_LIST: {
            const FFlist* list = (const FFlist*) formatarg->value;
-            for(uint32_t i = 0; i < list->length; i++)
-            {
+            for (uint32_t i = 0; i < list->length; i++) {
                ffStrbufAppend(buffer, FF_LIST_GET(FFstrbuf, *list, i));
-                if(i < list->length - 1)
+                if (i < list->length - 1) {
                    ffStrbufAppendS(buffer, ", ");
+                }
            }
            break;
        }
+        case FF_ARG_TYPE_BUFFER: {
+            // Placeholder for binary data, just print the size for now
+            const FFArgBuffer* argBuffer = (const FFArgBuffer*) formatarg->value;
+            ffStrbufAppendF(buffer, "buffer(%u bytes)", argBuffer->length);
+            break;
+        }
        default:
-            if(formatarg->type != FF_FORMAT_ARG_TYPE_NULL)
+            if (formatarg->type != FF_ARG_TYPE_NULL) {
                fprintf(stderr, "Error: format string \"%s\": argument is not implemented: %i\n", buffer->chars, formatarg->type);
+            }
            break;
    }
 }
@@ -66,62 +70,48 @@ void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg)
 * @param placeholderValue the string to parse
 * @return uint32_t the parsed value
 */
-static uint32_t getArgumentIndex(const char* placeholderValue, uint32_t numArgs, const FFformatarg* arguments)
-{
+static uint32_t getArgumentIndex(const char* placeholderValue, uint32_t numArgs, const FFformatarg* arguments) {
    char firstChar = placeholderValue[0];
-    if (firstChar == '\0')
+    if (firstChar == '\0') {
        return 0; // use arg counter
+    }

-    if (firstChar >= '0' && firstChar <= '9')
-    {
+    if (firstChar >= '0' && firstChar <= '9') {
        char* pEnd = NULL;
        uint32_t result = (uint32_t) strtoul(placeholderValue, &pEnd, 10);
-        if (result > numArgs)
+        if (result > numArgs) {
            return UINT32_MAX;
-        if (*pEnd != '\0')
+        }
+        if (*pEnd != '\0') {
            return UINT32_MAX;
+        }
        return result;
-    }
-    else if (ffCharIsEnglishAlphabet(firstChar))
-    {
-        for (uint32_t i = 0; i < numArgs; ++i)
-        {
+    } else if (ffCharIsEnglishAlphabet(firstChar)) {
+        for (uint32_t i = 0; i < numArgs; ++i) {
            const FFformatarg* arg = &arguments[i];
-            if (arg->name && strcasecmp(placeholderValue, arg->name) == 0)
+            if (arg->name && ffStrEqualsIgnCase(placeholderValue, arg->name)) {
                return i + 1;
+            }
        }
    }

    return UINT32_MAX;
 }

-static inline void appendInvalidPlaceholder(FFstrbuf* buffer, const char* start, const FFstrbuf* placeholderValue, uint32_t index, uint32_t formatStringLength)
-{
+static inline void appendInvalidPlaceholder(FFstrbuf* buffer, const char* start, const FFstrbuf* placeholderValue, uint32_t index, uint32_t formatStringLength) {
    ffStrbufAppendS(buffer, start);
    ffStrbufAppend(buffer, placeholderValue);

-    if(index < formatStringLength)
+    if (index < formatStringLength) {
        ffStrbufAppendC(buffer, '}');
+    }
 }

-static inline bool formatArgSet(const FFformatarg* arg)
-{
-    return arg->value != NULL && (
-        (arg->type == FF_FORMAT_ARG_TYPE_DOUBLE && *(double*)arg->value > 0.0) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_FLOAT && *(float*)arg->value > 0.0) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_INT && *(int*)arg->value > 0) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_STRBUF && ((FFstrbuf*)arg->value)->length > 0) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_STRING && ffStrSet((char*)arg->value)) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_UINT8 && *(uint8_t*)arg->value > 0) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_UINT16 && *(uint16_t*)arg->value > 0) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_UINT && *(uint32_t*)arg->value > 0) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_BOOL && *(bool*)arg->value) ||
-        (arg->type == FF_FORMAT_ARG_TYPE_LIST && ((FFlist*)arg->value)->length > 0)
-    );
+static inline bool formatArgSet(const FFformatarg* arg) {
+    return arg->value != NULL && ((arg->type == FF_ARG_TYPE_DOUBLE && *(double*) arg->value > 0.0) || (arg->type == FF_ARG_TYPE_FLOAT && *(float*) arg->value > 0.0) || (arg->type == FF_ARG_TYPE_INT && *(int*) arg->value > 0) || (arg->type == FF_ARG_TYPE_STRBUF && ((FFstrbuf*) arg->value)->length > 0) || (arg->type == FF_ARG_TYPE_STRING && ffStrSet((char*) arg->value)) || (arg->type == FF_ARG_TYPE_UINT8 && *(uint8_t*) arg->value > 0) || (arg->type == FF_ARG_TYPE_UINT16 && *(uint16_t*) arg->value > 0) || (arg->type == FF_ARG_TYPE_UINT && *(uint32_t*) arg->value > 0) || (arg->type == FF_ARG_TYPE_BOOL && *(bool*) arg->value) || (arg->type == FF_ARG_TYPE_LIST && ((FFlist*) arg->value)->length > 0));
 }

-void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t numArgs, const FFformatarg* arguments)
-{
+void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t numArgs, const FFformatarg* arguments) {
    uint32_t argCounter = 0;

    uint32_t numOpenIfs = 0;
@@ -129,11 +119,9 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n

    FF_STRBUF_AUTO_DESTROY placeholderValue = ffStrbufCreate();

-    for(uint32_t i = 0; i < formatstr->length; ++i)
-    {
+    for (uint32_t i = 0; i < formatstr->length; ++i) {
        // if we don't have a placeholder start just copy the chars over to output buffer
-        if(formatstr->chars[i] != '{')
-        {
+        if (formatstr->chars[i] != '{') {
            ffStrbufAppendC(buffer, formatstr->chars[i]);
            continue;
        }
@@ -142,8 +130,7 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
        ++i;

        // double {{ elvaluates to a single { and doesn't count as start
-        if(formatstr->chars[i] == '{')
-        {
+        if (formatstr->chars[i] == '{') {
            ffStrbufAppendC(buffer, '{');
            continue;
        }
@@ -158,61 +145,58 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n

        char firstChar = placeholderValue.chars[0];

-        if (placeholderValue.length == 1)
-        {
+        if (placeholderValue.length == 1) {
            // test if for stop, if so break the loop
-            if (firstChar == '-')
+            if (firstChar == '-') {
                break;
+            }

            // test for end of an if, if so do nothing
-            if (firstChar == '?')
-            {
-                if(numOpenIfs == 0)
+            if (firstChar == '?') {
+                if (numOpenIfs == 0) {
                    appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
-                else
+                } else {
                    --numOpenIfs;
+                }

                continue;
            }

            // test for end of a not if, if so do nothing
-            if (firstChar == '/')
-            {
-                if(numOpenNotIfs == 0)
+            if (firstChar == '/') {
+                if (numOpenNotIfs == 0) {
                    appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
-                else
+                } else {
                    --numOpenNotIfs;
+                }

                continue;
            }

            // test for end of a color, if so do nothing
-            if (firstChar == '#')
-            {
-                if (!instance.config.display.pipe)
+            if (firstChar == '#') {
+                if (!instance.config.display.pipe) {
                    ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
+                }

                continue;
            }
        }

        // test for if, if so evaluate it
-        if (firstChar == '?')
-        {
+        if (firstChar == '?') {
            ffStrbufSubstrAfter(&placeholderValue, 0);

            uint32_t index = getArgumentIndex(placeholderValue.chars, numArgs, arguments);

            // testing for an invalid index
-            if (index > numArgs)
-            {
+            if (index > numArgs || index < 1) {
                appendInvalidPlaceholder(buffer, "{?", &placeholderValue, i, formatstr->length);
                continue;
            }

            // continue normally if an format arg is set and the value is > 0
-            if (formatArgSet(&arguments[index - 1]))
-            {
+            if (formatArgSet(&arguments[index - 1])) {
                ++numOpenIfs;
                continue;
            }
@@ -223,22 +207,19 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
        }

        // test for not if, if so evaluate it
-        if (firstChar == '/')
-        {
+        if (firstChar == '/') {
            ffStrbufSubstrAfter(&placeholderValue, 0);

            uint32_t index = getArgumentIndex(placeholderValue.chars, numArgs, arguments);

            // testing for an invalid index
-            if (index > numArgs)
-            {
+            if (index > numArgs || index < 1) {
                appendInvalidPlaceholder(buffer, "{/", &placeholderValue, i, formatstr->length);
                continue;
            }

-            //continue normally if an format arg is not set or the value is 0
-            if (!formatArgSet(&arguments[index - 1]))
-            {
+            // continue normally if an format arg is not set or the value is 0
+            if (!formatArgSet(&arguments[index - 1])) {
                ++numOpenNotIfs;
                continue;
            }
@@ -248,11 +229,9 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
            continue;
        }

-        //test for color, if so evaluate it
-        if (firstChar == '#')
-        {
-            if (!instance.config.display.pipe)
-            {
+        // test for color, if so evaluate it
+        if (firstChar == '#') {
+            if (!instance.config.display.pipe) {
                ffStrbufAppendS(buffer, "\e[");
                ffOptionParseColorNoClear(placeholderValue.chars + 1, buffer);
                ffStrbufAppendC(buffer, 'm');
@@ -260,29 +239,25 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
            continue;
        }

-        //test for constant or env var, if so evaluate it
-        if (firstChar == '$')
-        {
+        // test for constant or env var, if so evaluate it
+        if (firstChar == '$') {
            char* pend = NULL;
            int32_t indexSigned = (int32_t) strtol(placeholderValue.chars + 1, &pend, 10);
-            if (pend == placeholderValue.chars + 1)
-            {
+            if (pend == placeholderValue.chars + 1) {
                // treat placeholder as an environment variable
                char* envValue = getenv(placeholderValue.chars + 1);
-                if (envValue)
+                if (envValue) {
                    ffStrbufAppendS(buffer, envValue);
-                else
+                } else {
                    appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
-            }
-            else
-            {
+                }
+            } else {
                // treat placeholder as a constant
                uint32_t index = (uint32_t) (indexSigned < 0 ? (int32_t) instance.config.display.constants.length + indexSigned : indexSigned - 1);

-                if (*pend != '\0' || instance.config.display.constants.length <= index)
+                if (*pend != '\0' || instance.config.display.constants.length <= index) {
                    appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
-                else
-                {
+                } else {
                    FFstrbuf* item = FF_LIST_GET(FFstrbuf, instance.config.display.constants, index);
                    ffStrbufAppend(buffer, item);
                }
@@ -292,115 +267,104 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n

        char* pSep = placeholderValue.chars;
        char cSep = '\0';
-        while (*pSep && *pSep != ':' && *pSep != '<' && *pSep != '>' && *pSep != '~')
+        while (*pSep && *pSep != ':' && *pSep != '<' && *pSep != '>' && *pSep != '~') {
            ++pSep;
-        if (*pSep)
-        {
+        }
+        if (*pSep) {
            cSep = *pSep;
            *pSep = '\0';
-        }
-        else
-        {
+        } else {
            pSep = NULL;
        }

        uint32_t index = getArgumentIndex(placeholderValue.chars, numArgs, arguments);

        // test for invalid index
-        if (index == 0)
+        if (index == 0) {
            index = ++argCounter;
+        }

-        if (index > numArgs)
-        {
-            if (pSep) *pSep = cSep;
+        if (index > numArgs) {
+            if (pSep) {
+                *pSep = cSep;
+            }
            appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
            continue;
        }

-        if (!cSep)
+        if (!cSep) {
            ffFormatAppendFormatArg(buffer, &arguments[index - 1]);
-        else if (cSep == '~')
-        {
+        } else if (cSep == '~') {
            FF_STRBUF_AUTO_DESTROY tempString = ffStrbufCreate();
            ffFormatAppendFormatArg(&tempString, &arguments[index - 1]);

            char* pEnd = NULL;
            int32_t start = (int32_t) strtol(pSep + 1, &pEnd, 10);
-            if (start < 0)
+            if (start < 0) {
                start = (int32_t) tempString.length + start;
-            if (start >= 0 && (uint32_t) start < tempString.length)
-            {
-                if (*pEnd == '\0')
+            }
+            if (start >= 0 && (uint32_t) start < tempString.length) {
+                if (*pEnd == '\0') {
                    ffStrbufAppendNS(buffer, tempString.length - (uint32_t) start, &tempString.chars[start]);
-                else if (*pEnd == ',')
-                {
+                } else if (*pEnd == ',') {
                    int32_t end = (int32_t) strtol(pEnd + 1, &pEnd, 10);
-                    if (!*pEnd)
-                    {
-                        if (end < 0)
+                    if (!*pEnd) {
+                        if (end < 0) {
                            end = (int32_t) tempString.length + end;
-                        if ((uint32_t) end > tempString.length)
+                        }
+                        if ((uint32_t) end > tempString.length) {
                            end = (int32_t) tempString.length;
-                        if (end > start)
+                        }
+                        if (end > start) {
                            ffStrbufAppendNS(buffer, (uint32_t) (end - start), &tempString.chars[start]);
+                        }
                    }
                }
            }

-            if (*pEnd)
-            {
+            if (*pEnd) {
                *pSep = cSep;
                appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
                continue;
            }
-        }
-        else
-        {
+        } else {
            char* pEnd = NULL;
            int32_t truncLength = (int32_t) strtol(pSep + 1, &pEnd, 10);
-            if (*pEnd != '\0')
-            {
+            if (*pEnd != '\0') {
                *pSep = cSep;
                appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
                continue;
            }

            bool ellipsis = false;
-            if (truncLength < 0)
-            {
+            if (truncLength < 0) {
                ellipsis = true;
                truncLength = -truncLength;
            }

            FF_STRBUF_AUTO_DESTROY tempString = ffStrbufCreate();
            ffFormatAppendFormatArg(&tempString, &arguments[index - 1]);
-            if (tempString.length == (uint32_t) truncLength)
+            if (tempString.length == (uint32_t) truncLength) {
                ffStrbufAppend(buffer, &tempString);
-            else if (tempString.length > (uint32_t) truncLength)
-            {
-                if (cSep == ':')
-                {
+            } else if (tempString.length > (uint32_t) truncLength) {
+                if (cSep == ':') {
                    ffStrbufSubstrBefore(&tempString, (uint32_t) truncLength);
                    ffStrbufTrimRightSpace(&tempString);
+                } else {
+                    ffStrbufSubstrBefore(&tempString, (uint32_t) (!ellipsis ? truncLength : truncLength - 1));
                }
-                else
-                    ffStrbufSubstrBefore(&tempString, (uint32_t) (!ellipsis? truncLength : truncLength - 1));
                ffStrbufAppend(buffer, &tempString);

-                if (ellipsis)
+                if (ellipsis) {
                    ffStrbufAppendS(buffer, "…");
-            }
-            else if (cSep == ':')
+                }
+            } else if (cSep == ':') {
                ffStrbufAppend(buffer, &tempString);
-            else
-            {
-                if (cSep == '<')
-                {
+            } else {
+                if (cSep == '<') {
                    ffStrbufAppend(buffer, &tempString);
                    ffStrbufAppendNC(buffer, (uint32_t) truncLength - tempString.length, ' ');
-                }
-                else
-                {
+                } else {
                    ffStrbufAppendNC(buffer, (uint32_t) truncLength - tempString.length, ' ');
                    ffStrbufAppend(buffer, &tempString);
                }
@@ -408,6 +372,7 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
        }
    }

-    if (!instance.config.display.pipe)
+    if (!instance.config.display.pipe) {
        ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
+    }
 }
@@ -1,24 +1,25 @@
-#include "frequency.h"
+#include "common/frequency.h"

-bool ffFreqAppendNum(uint32_t mhz, FFstrbuf* result)
-{
-    if (mhz == 0)
+bool ffFreqAppendNum(uint32_t mhz, FFstrbuf* result) {
+    if (mhz == 0) {
        return false;
+    }

    const FFOptionsDisplay* options = &instance.config.display;
    bool spaceBeforeUnit = options->freqSpaceBeforeUnit != FF_SPACE_BEFORE_UNIT_NEVER;
    int8_t ndigits = options->freqNdigits;

-    if (ndigits >= 0)
-    {
+    if (ndigits >= 0) {
        ffStrbufAppendDouble(result, mhz / 1000., ndigits, true);
-        if (spaceBeforeUnit) ffStrbufAppendC(result, ' ');
+        if (spaceBeforeUnit) {
+            ffStrbufAppendC(result, ' ');
+        }
        ffStrbufAppendS(result, "GHz");
-    }
-    else
-    {
+    } else {
        ffStrbufAppendUInt(result, mhz);
-        if (spaceBeforeUnit) ffStrbufAppendC(result, ' ');
+        if (spaceBeforeUnit) {
+            ffStrbufAppendC(result, ' ');
+        }
        ffStrbufAppendS(result, "MHz");
    }
    return true;
--- a/Show More
+++ b/Show More
				`@@ -1 +0,0 @@`
				`fastfetch_2.51.0_source.buildinfo universe/utils optional`