Merge pull request #1938 from fastfetch-cli/dev

Release: v2.51.1
2026-09-12 18:06:11 +02:00 · 2025-08-29 14:05:34 +08:00 · 2025-08-29 13:55:52 +08:00 · 2025-08-29 13:45:16 +08:00 · 2025-08-29 08:56:30 +08:00 · 2025-08-29 08:43:08 +08:00
679 changed files with 26842 additions and 16010 deletions
@@ -1,5 +1,5 @@
 [codespell]
 check-filenames =
 builtin = clear,rare,usage,informal
-skip = */.git,*/cmake-build-*,*/.idea,*/completions,*/presets,*/screenshots,*/tests,*/3rdparty,*/logo/ascii
+skip = */.git,*/cmake-build-*,*/.idea,*/completions,*/presets,*/screenshots,*/tests,*/3rdparty,*/logo/ascii,./src/detection/gpu/asahi_drm.h
 ignore-words-list = iterm,compiletime,unknwn,pengwin,siduction,master,slave,sur,doas,conexant,ags,bu
@@ -4,13 +4,16 @@ on:
  - push
  - pull_request

+env:
+  CMAKE_BUILD_TYPE: ${{ vars.CMAKE_BUILD_TYPE || 'RelWithDebInfo' }}
+
 jobs:
  spellcheck:
    runs-on: ubuntu-latest

    steps:
      - name: checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: Install codespell
        shell: bash
@@ -29,7 +32,7 @@ jobs:
      contents: read
    steps:
      - name: checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: uname -a
        run: uname -a
@@ -60,7 +63,7 @@ jobs:

  linux-amd64:
    name: Linux-amd64
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    permissions:
      security-events: write
      contents: read
@@ -68,7 +71,7 @@ jobs:
      ffversion: ${{ steps.ffversion.outputs.ffversion }}
    steps:
      - name: checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: uname -a
        run: uname -a
@@ -80,12 +83,12 @@ jobs:
        run: cat /proc/cpuinfo

      - name: install required packages
-        run: sudo apt-get update && sudo apt-get install -y 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 libelf-dev directx-headers-dev
+        run: sudo apt-get update && sudo apt-get install -y 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 libelf-dev libddcutil-dev directx-headers-dev

      - 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 ddcutil --ignore-dependencies
+          /home/linuxbrew/.linuxbrew/bin/brew install imagemagick chafa --ignore-dependencies

      - name: Initialize CodeQL
        uses: github/codeql-action/init@v3
@@ -137,7 +140,7 @@ jobs:
      contents: read
    steps:
      - name: checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: uname -a
        run: uname -a
@@ -151,8 +154,13 @@ jobs:
      - name: install required packages
        run: sudo apt-get update && sudo apt-get install -y 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 libelf-dev directx-headers-dev libchafa-dev libddcutil-dev rpm

+      - 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: configure project
-        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On -DCMAKE_INSTALL_PREFIX=/usr .
+        run: PKG_CONFIG_PATH=/home/linuxbrew/.linuxbrew/lib/pkgconfig:$PKG_CONFIG_PATH cmake -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
@@ -193,7 +201,7 @@ jobs:
      contents: read
    steps:
      - name: checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: run VM
        uses: uraimo/run-on-arch-action@v3
@@ -232,7 +240,7 @@ jobs:
      contents: read
    steps:
      - name: checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: run VM
        uses: uraimo/run-on-arch-action@v3
@@ -268,7 +276,7 @@ jobs:
      contents: read
    steps:
      - name: checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: run VM
        uses: uraimo/run-on-arch-action@v3
@@ -303,7 +311,7 @@ jobs:
      contents: read
    steps:
      - name: checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: run VM
        uses: uraimo/run-on-arch-action@v3
@@ -338,7 +346,7 @@ jobs:
      contents: read
    steps:
      - name: checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: run VM
        uses: uraimo/run-on-arch-action@v3
@@ -369,7 +377,7 @@ jobs:
    name: Musl-amd64
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5

      - name: setup alpine linux
        uses: jirutka/setup-alpine@master
@@ -378,7 +386,7 @@ jobs:
        run: |
          cat /etc/alpine-release
          uname -a
-          apk add cmake samurai vulkan-loader-dev libxcb-dev wayland-dev libdrm-dev dconf-dev imagemagick-dev chafa-dev zlib-dev dbus-dev mesa-dev opencl-dev xfconf-dev sqlite-dev networkmanager-dev pulseaudio-dev ddcutil-dev elfutils-dev gcc g++
+          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 xfconf-dev sqlite-dev networkmanager-dev pulseaudio-dev ddcutil-dev elfutils-dev gcc g++
        shell: alpine.sh --root {0}

      - name: build
@@ -403,15 +411,15 @@ jobs:
          name: fastfetch-musl-amd64
          path: ./fastfetch-*.*

-  macos-universal:
-    name: macOS-universal
-    runs-on: macos-latest
+  macos-amd64:
+    name: macOS-amd64
+    runs-on: macos-13
    permissions:
      security-events: write
      contents: read
    steps:
      - name: checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: uname -a
        run: uname -a
@@ -421,7 +429,7 @@ jobs:
          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 -DCMAKE_OSX_ARCHITECTURES='arm64;x86_64' .
+        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .

      - name: build project
        run: cmake --build . --target package --verbose -j4
@@ -447,7 +455,54 @@ jobs:
      - name: upload artifacts
        uses: actions/upload-artifact@v4
        with:
-          name: fastfetch-macos-universal
+          name: fastfetch-macos-amd64
+          path: ./fastfetch-*.*
+
+  macos-aarch64:
+    name: macOS-aarch64
+    runs-on: macos-latest
+    permissions:
+      security-events: write
+      contents: read
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v5
+
+      - 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 --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: otool -L fastfetch
+
+      - name: run tests
+        run: ctest --output-on-failure
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: fastfetch-macos-aarch64
          path: ./fastfetch-*.*

  sunos-amd64:
@@ -455,7 +510,7 @@ jobs:
    name: SunOS-amd64
    steps:
      - name: checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: run VM
        uses: vmactions/omnios-vm@v1
@@ -463,8 +518,9 @@ jobs:
          usesh: true
          prepare: |
            uname -a
+            pkg install pkg:/package/pkg
            pkg update --accept
-            pkg install gcc13 cmake git pkg-config glib2 dbus sqlite-3 imagemagick
+            pkg install gcc14 cmake git pkg-config glib2 dbus sqlite-3 imagemagick

          run: |
            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .
@@ -491,7 +547,7 @@ jobs:
      contents: read
    steps:
      - name: checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: run VM
        uses: cross-platform-actions/action@master
@@ -500,7 +556,7 @@ jobs:
          architecture: x86-64
          cpu_count: 4
          shell: bash
-          version: '14.2'
+          version: '14.3'
          run: |
            uname -a
            sudo pkg update
@@ -528,7 +584,7 @@ jobs:
      contents: read
    steps:
      - name: checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: run VM
        uses: cross-platform-actions/action@master
@@ -537,7 +593,7 @@ jobs:
          architecture: x86-64
          cpu_count: 4
          shell: bash
-          version: '7.6'
+          version: '7.7'
          run: |
            uname -a
            sudo pkg_add -r cmake git pkgconf wayland vulkan-headers vulkan-loader glib2 dconf dbus sqlite3 xfconf imagemagick chafa
@@ -564,7 +620,7 @@ jobs:
      contents: read
    steps:
      - name: checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: run VM
        uses: cross-platform-actions/action@master
@@ -576,7 +632,7 @@ jobs:
          version: '10.1'
          run: |
            uname -a
-            sudo pkgin -y install cmake git pkgconf wayland vulkan-headers dconf dbus sqlite3 ImageMagick opencl-headers ocl-icd
+            sudo pkgin -y install cmake git pkgconf wayland vulkan-headers dconf dbus sqlite3 ImageMagick
            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DENABLE_EMBEDDED_PCIIDS=On -DENABLE_EMBEDDED_AMDGPUIDS=On .
            cmake --build . --target package --verbose -j4
            ./fastfetch --list-features
@@ -592,6 +648,76 @@ jobs:
          name: fastfetch-netbsd-amd64
          path: ./fastfetch-*.*

+  dragonfly-amd64:
+    name: DragonFly-amd64
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write
+      contents: read
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v5
+
+      - name: run VM
+        uses: vmactions/dragonflybsd-vm@v1
+        with:
+          usesh: yes
+          prepare: |
+            uname -a
+            pkg update
+            pkg install -y cmake git pkgconf binutils wayland vulkan-headers vulkan-loader libxcb libXrandr libX11 libdrm glib dconf dbus sqlite3-tcl xfce4-conf egl opencl ocl-icd v4l_compat chafa libelf
+
+          run: |
+            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@v4
+        with:
+          name: fastfetch-dragonfly-amd64
+          path: ./fastfetch-*.*
+
+  haiku-amd64:
+    name: Haiku-amd64
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write
+      contents: read
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v5
+
+      - name: run VM
+        uses: cross-platform-actions/action@master
+        with:
+          operating_system: haiku
+          version: 'r1beta5'
+          architecture: x86-64
+          cpu_count: 4
+          shell: bash
+          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@v4
+        with:
+          name: fastfetch-haiku-amd64
+          path: ./fastfetch-*.*
+
  windows-amd64:
    name: Windows-amd64
    runs-on: windows-latest
@@ -603,7 +729,7 @@ jobs:
        shell: msys2 {0}
    steps:
      - name: checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: setup-msys2
        uses: msys2/setup-msys2@v2
@@ -654,6 +780,68 @@ jobs:
          name: fastfetch-windows-amd64
          path: ./fastfetch-windows-amd64.*

+  windows-aarch64:
+    name: Windows-aarch64
+    runs-on: windows-11-arm
+    permissions:
+      security-events: write
+      contents: read
+    defaults:
+      run:
+        shell: msys2 {0}
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v5
+
+      - name: setup-msys2
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: CLANGARM64
+          update: true
+          install: git mingw-w64-clang-aarch64-7zip mingw-w64-clang-aarch64-cmake mingw-w64-clang-aarch64-clang mingw-w64-clang-aarch64-vulkan-loader mingw-w64-clang-aarch64-vulkan-headers mingw-w64-clang-aarch64-opencl-icd mingw-w64-clang-aarch64-opencl-headers mingw-w64-clang-aarch64-cppwinrt mingw-w64-clang-aarch64-imagemagick
+
+      - name: print msys version
+        run: uname -a
+
+      - name: configure project
+        run: env PKG_CONFIG_PATH=/clangarm64/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 /clangarm64/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
+
+      - name: create zip archive
+        run: 7z a -tzip -mx9 -bd -y fastfetch-windows-aarch64.zip LICENSE *.dll fastfetch.exe flashfetch.exe presets
+
+      - name: create 7z archive
+        run: 7z a -t7z -mx9 -bd -y fastfetch-windows-aarch64.7z LICENSE *.dll fastfetch.exe flashfetch.exe presets
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: fastfetch-windows-aarch64
+          path: ./fastfetch-windows-aarch64.*
+
  release:
    if: github.event_name == 'push' && github.ref == 'refs/heads/master' && github.repository == 'fastfetch-cli/fastfetch'
    name: Release
@@ -667,12 +855,15 @@ jobs:
      - linux-ppc64le
      - linux-s390x
      - musl-amd64
-      - macos-universal
+      - macos-amd64
+      - macos-aarch64
      - freebsd-amd64
      - openbsd-amd64
      - netbsd-amd64
      - sunos-amd64
+      - haiku-amd64
      - windows-amd64
+      - windows-aarch64
    permissions:
      contents: write
    steps:
@@ -1,3 +1,427 @@
+# 2.51.1
+
+Bugfixes:
+* Fix building on macOS 14 or older; no functional changes (CPU, macOS)
+
+# 2.51.0
+
+Changes:
+* Fastfetch now requires [yyjson 0.12](https://github.com/ibireme/yyjson/releases/tag/0.12.0) to build when using `-DENABLE_SYSTEM_YYJSON=ON`.
+* The Disk module no longer shows hyperlink mountpoints by default, which cause issues on some real consoles (Disk)
+    * Instead, the custom key for the Disk module now supports `{mountpoint-link}` and `{name-link}` to show hyperlinks for mountpoints and names. For example, `{ "type": "disk", "key": "Disk ({mountpoint-link})" }` can be used to restore the old behavior.
+
+Features:
+* Adds `succeeded` module condition to JSONC config. When set to `false`, the module will only run if the last module failed (#1908)
+    * Useful for displaying fallback placeholders when a module fails. For example:
+```jsonc
+{
+    "host",
+    // If fastfetch fails to detect host info, display "DIY PC" instead
+    {
+        "type": "custom",
+        "condition": {
+            "succeeded": false
+        },
+        "key": "Host",
+        "format": "DIY PC"
+    }
+}
+```
+* By upgrading to yyjson 0.12, fastfetch now adds [JSON5](https://json5.org/) format support for configuration files (#1907)
+    * [JSON5](https://json5.org/) is a superset of JSONC that allows unquoted keys, single quotes, multi-line strings, etc., and is fully compatible with JSONC and strict JSON.
+    * To use JSON5, simply name your config file with a `.json5` extension. The `.jsonc` extension is still supported and used as the default extension for better IDE syntax highlighting support.
+* Fastfetch has been ported to [`GNU/Hurd`](https://www.gnu.org/software/hurd/) (#1895)
+    * Thanks to the efforts of @yelninei!
+* Built-in logos now honor `logo.width` (#1905)
+    * When its value is larger than the actual logo width, the logo will be padded with spaces to the right
+* Adds Trinity DE version detection (#1917, DE, Linux)
+* Adds formatted free and available disk size fields (#1929, Disk)
+    * `{size-free}`: free size of the disk
+    * `{size-available}`: available size of the disk
+    * See [askubuntu.com](https://askubuntu.com/questions/249387/df-h-used-space-avail-free-space-is-less-than-the-total-size-of-home) for the difference between free and available size
+* Adds [x86_64 micro-architecture level](https://en.wikipedia.org/wiki/X86-64#Microarchitecture_levels) detection (#1928, CPU)
+    * Useful when installing software that requires or is optimized for specific CPU features. E.g., [CachyOS](https://wiki.cachyos.org/features/optimized_repos/)
+    * Exposed via `{march}` in custom format
+* Adds [Aarch64 micro-architecture level](https://en.wikipedia.org/wiki/AArch64#Profiles) detection (CPU)
+    * Supported on Linux (including Android), macOS and Windows
+    * This is not fully accurate because there are many optional features across different levels, and not all levels are detectable.
+    * Exposed via `{march}` in custom format.
+* Adds shepherd detection support (InitSystem, Linux)
+
+Bugfixes:
+* Refines GPU detection logic to correctly handle virtual devices (#1920, GPU, Windows)
+* Fixes possible default route detection failure when the route table is very large (#1919, LocalIP, Linux)
+* Fastfetch now correctly parses `hwdata/pci.ids` files alongside `pciids/pci.ids` on FreeBSD when detecting GPU names (#1924, GPU, FreeBSD)
+* Fixes twin WM detection (#1917, WM, Linux)
+* Various fixes for Android support
+    * Corrects WM name for Android (WM, Android)
+    * Fixes battery temperature detection when running in ADB (Battery, Android)
+    * Adds CPU and GPU temperature detection support (CPU, Android)
+
+Logos:
+* Adds AerynOS
+
+# 2.50.2
+
+Bugfixes:
+* Fixes linglong package detection V2 (#1903, Packages, Linux)
+* Fixes building with `-DENABLE_SYSTEM_YYJSON=ON` (#1904)
+* Fixes `showMac` does not honor `defaultRouteOnly` (#1902, LocalIP, Linux)
+* Fixes failing to acquire default route on Linux in certain cases (#1902, LocalIP, Linux)
+
+# 2.50.1
+
+Bugfixes:
+* Fixes percentage bar not displaying correctly in certain cases
+* Fixes linglong package detection on Debian 13 (#1899, Packages, Linux)
+
+# 2.50.0
+
+Changes:
+* Keys in JSON configuration files are now case-sensitive, as stated in v2.49.0.
+    * This is a breaking change, but it should not affect most users as long as your config file passes JSON schema validation.
+* All module config flags have been removed, as stated in v2.49.0.
+    * To configure modules via the command line, use: `echo '{"modules": [{"type":"custom","format":"Hello Fastfetch!"}]}' | fastfetch -c -`.
+* The percent bar config `display.bar.*` options have been replaced with a more organized, nested object structure.
+    * `display.bar.charElapsed` has been renamed to `display.bar.char.elapsed`.
+    * `display.bar.charTotal` has been renamed to `display.bar.char.total`.
+    * `display.bar.borderLeft` has been renamed to `display.bar.border.left`.
+    * `display.bar.borderRight` has been renamed to `display.bar.border.right`.
+* The undocumented flag `--load-config` has been removed.
+    * Use `--config` or `-c` instead.
+* Flashfetch, a simplified fastfetch variant that used a hardcoded module list with direct function calls to reduce startup overhead, has been changed to a version that aims to match neofetch's behavior as closely as possible, for demonstration purposes.
+    * Flashfetch is intended to be built from source (like [st](https://st.suckless.org/)). We do not provide prebuilt binaries in distributions.
+
+Features:
+* Added support for reading JSON config from stdin using `--config -` or `-c -`.
+* Added `display.bar.border.{leftElapsed,rightElapsed}` for using the border as part of the bar content. (#1875)
+    * `display.bar.border: null` has been added as a shorthand to disable bar borders.
+* Added `display.bar.color.{elapsed,total,border}` to customize the color of the elapsed, total, and border sections of the percent bar.
+    * `display.bar.color: null` has been added as a shorthand to disable bar colors.
+* Improved Bedrock Linux detection (#1881, OS / Disk, Linux)
+* Added the command flag `--gen-config-full`, which generates a JSON config file containing all optional module options.
+* Improved the default IP address display when `localip.showAllIPs` is not set (LocalIP)
+    * For IPv4, the preferred source address (if detected) is shown.
+    * For IPv6, the first GUA or ULA that is not deprecated or temporary is shown.
+* Added support for interface speed detection on SunOS (LocalIP, SunOS)
+* Added detection support for Xlibre (#1888, WM, Linux)
+* Improved the accuracy of color detection (Cursor, macOS)
+* Improved the proformance of `Nix` package manager detection on macOS by porting optimizations form Linux port (#1893, Packages, macOS)
+
+Bugfixes:
+* Fixed custom object inheriting a key from the previous custom object if the key is blank (#1477)
+* Fixed a possible segfault when parsing color strings in the JSON config (#1878)
+* Fixed GPU driver detection when DRM is used (GPU, FreeBSD)
+* Fixed default route detection on DragonFly BSD (LocalIP, DFBSD)
+* Fixed lliurex detection (#1882, OS, Linux)
+* Fixed compatibility with `-ffast-math` (#1894)
+* Fixed physical GPU sometimes being ignored (#1896, GPU, Windows)
+
+Logos:
+* Added ObsidianOS (#1890)
+
+# 2.49.0
+
+Deprecation Notice:
+* In fastfetch v2, the JSONC configuration format has been introduced, while command line configuration flags are kept for compatibility. Although they have the same effects, they use two different code paths, and as the number of flags grows, the codebase is becoming increasingly difficult to maintain.
+    * Removal of module config flags is planned for **v2.50.0**, which will also fix a long-standing issue #1477.
+    * Removal of most other config flags is also planned for later versions.
+* Keys of JSON configuration files will be all case-sensitive. Currently they are inconsistent. Planned for **v2.50.0**.
+
+Changes:
+* Due to more restrictive permissions in macOS Tahoe, SSID detection on macOS 26+ requires root privileges. `<redacted>` will be displayed otherwise.
+
+Features:
+* Improve `nouveau` driver support for `--gpu-driver-specific` (GPU, Linux)
+    * VRAM size detection
+    * GPU temperature detection
+    * Core count detection (when available)
+* Improve Scoop package manager detection (Packages, Windows)
+    * Support [`scoop-global`](https://github.com/ScoopInstaller/Install?tab=readme-ov-file#advanced-installation)
+    * Read Scoop's config file to find the installation path of Scoop
+* Improve ARM SoC detection (CPU, Android)
+    * Make SoC detection more lenient. Higher chance to match at the cost of accuracy.
+    * Add more Snapdragon SoC names
+* Support labwc WM version detection, used for XFCE4 on Wayland (WM, Linux)
+* Improve accuracy of GPU temperature detection for Intel dedicated GPUs on Windows (GPU, Windows)
+* Parse unicode escaped strings generated by qt5ct (#1864, Font, Linux)
+* Add `--{duration,percent,size,freq,temp}-space-before-unit [always|never]` options to add a space before the unit when printing duration, percent, size, frequency and temperature values
+* Add `--duration-abbreviation` to abbreviate duration values in custom format
+    * For example: `1 day, 2 hours, 3 mins` will be displayed as `1d 2h 3m`
+* Add `--percent-width` to pad the percent value with spaces to a fixed width
+    * For example: `--percent-width 3` will display ` 50%` instead of `50%`; useful for aligning percent values in custom format
+
+Bugfixes:
+* Improve accuracy of Flatpak count detection (#1856, Packages, Linux)
+* Remove qi package manager support (#1858, Packages, Linux)
+* Fix LocalIP module on Windows (LocalIP, Windows)
+    * Fix default route detection when multiple network interfaces are connected
+    * Fix link speed calculation
+* Fix interface status when the interface is up but not connected (Wifi, Linux)
+* Fix variable names in custom format (#1861)
+    * `full-path` to `path` (Editor)
+    * `session` to `session-name` (Users)
+    * `name` to `project-name` (Version)
+* Fix wrong /s assignment in custom format (#1871, DiskIO)
+
+Logos:
+* Add `Aeon`
+* Remove `Evolinx`
+
+# 2.48.1
+
+Features:
+* Add support for detecting Openbox WM version (WM, Linux)
+* Improve reliability of child process spawning on Windows (Windows)
+* Add a new option `--packages-combined`, which combines related package managers into single counts (#1851, Packages)
+    * For example: if you have both `flatpak-system` and `flatpak-user` packages installed, they will be combined into a single `flatpak` count with `--packages-combined` enabled.
+* Add `modules[n].condition` to conditionally enable modules on different platforms
+    * Useful when sharing configuration files across platforms
+    * For example:
+```jsonc
+{
+    "type": "custom",
+    "format": "This string will be printed on Intel macOS only",
+    "condition": {
+        "system": "macOS", // Can be an array, optional
+        "arch": "x86_64"  // Can be an array, optional too
+    }
+}
+```
+
+Bugfixes:
+* Revert the change of `posix_spawn` in v2.48.0 for Android and OpenBSD (Android / OpenBSD)
+    * Fix completion for Android 7 (Required by Termux)
+
+# 2.48.0
+
+Features:
+* Add support for detecting Fedora variants (#1830, OS, Linux)
+    * Currently supported variants: CoreOS, Kinoite, Sericea, Silverblue
+* Optimize GPU detection on Windows when `--gpu-driver-specific` is not used (GPU, Windows)
+    * Improve accuracy of GPU type detection. Previously it was guessed based on the dedicated vmem size, which causes issues on newer AMD integrated GPUs such as 9000 HX and AI 9 HX series. Supported on Windows 8.1 or later.
+    * Add support for generic frequency detection of GPU 3D engine on Windows 11 22H2 or later.
+    * Improve performance. GPU temperature detection is significantly improved when `--gpu-driver-specific` is not used.
+* Improve performance and security when spawning child processes by replacing `fork-exec` with `posix_spawn` (*nix)
+* Improve accuracy of sound device detection on macOS (Sound, macOS)
+* Trim leading and trailing whitespaces in disk serial numbers (PhysicalDisk)
+* Add `/etc/profiles/per-user` detection for Nix user packages (#1782, Packages, Linux)
+* Introduce `years` (whole years as integer), `days-of-year` (days since the last anniversary) and `years-fraction` (years as fraction, e.g. 1.5 means 1 year and 6 months) formatting placeholder to `Disk` (since disk creation), `Users` (since user login) and `Uptime` (since system boot) modules
+    * For example: `fastfetch -s disk --disk-key 'OS Installation' --disk-format '{years} years {days-of-year} days'`
+* Add `--fraction-ndigits` option to specify the number of digits after the decimal point when displaying ordinary fractional values
+    * Typically used with `{years-fraction}` above
+    * This option does not affect percentage values, sizes, etc, which are controlled by individual options.
+
+Bugfixes:
+* Fix compilation issues when not using `-DBINARY_LINK_TYPE=dlopen`
+    * Regression from v2.47.0
+    * Note: this option was added for debugging purposes only and is not recommended for production use
+* Replace `MTLDevice::hasUnifiedMemory` with `MTLDevice::location` for GPU type Detection (GPU, macOS)
+    * This should resolve the issue where discrete GPUs were detected as integrated GPUs on Intel MacBooks with multi-GPU configurations.
+* Prevent text files from being loaded as image files (#1843, Logo)
+
+Logos:
+* Add Minimal System
+* Add AxOS
+* Rename Ada to Xray OS
+
+# 2.47.0
+
+Features:
+* Various improvements for Solaris / OpenIndiana support
+    * Support BIOS (UEFI or legacy) type detection (BIOS)
+    * Support physical disk detection (PhysicalDisk)
+    * Remove leading `-` from login shells (Shell)
+    * Improve GPU detection performance (GPU)
+        * Drop `libpciaccess` dependency
+    * Use native API to detect sound devices (Sound)
+        * Drop `PulseAudio` dependency
+* Improve DietPi OS and Raspberry Pi OS detection (#1816, OS, Linux)
+* Force reporting version 26 on macOS Tahoe (OS, macOS)
+* Append version string to Ubuntu variants (OS, Linux)
+* Improve performance of media detection for macOS 15.4+ (Media, macOS)
+* Increase `PROC_FILE_BUFFSIZ` to avoid possible short reads (Linux)
+    * Fix potential bugs in `DiskIO`, `NetIO` and `CPUUsage` modules
+* Improve accuracy of CPU usage calculations by including interrupt and softirq times (CPUUsage, Linux / *BSD)
+* Ignore `init` and `systemd` processes when detecting terminals (Terminal, Linux)
+* Improve accuracy of CPU usage detection on Windows 10+ with perflib, which matches values reported by Task Manager (CPUUsage, Windows)
+
+Bugfixes:
+* Fix `pci.ids` file location (#1819, GPU, OpenBSD)
+* Fix compiling on FreeBSD when `libdrm` support is disabled (#1820, GPU, FreeBSD)
+
+Logos:
+* Improve visibility on white-background terminals for some logos by replacing white with the default foreground color
+    * According to Wikipedia, the default foreground color is implementation-defined. It's usually black for white themes and white for dark themes. However, some terminals, notably Konsole with the default theme, use a different color, which may cause issues with some logos.
+* Add Xubuntu
+
+# 2.46.0
+
+Features:
+* Support Rio terminal font detection (#1789, TerminalFont, Linux)
+* Support GPU detection by DRM on FreeBSD (GPU, FreeBSD)
+    * Enable by `--gpu-detection-method auto`
+    * Require proper DRM drivers installed and loaded
+* Support PowerPC CPU detection on NetBSD (#1802, CPU, NetBSD)
+* Support Aerospace WM detection (#1796, WM, macOS)
+* Improve Raspberry Pi OS for RPI5 detection (#1773, OS, Linux)
+* Support Linux Binary Compatibility detection on FreeBSD (#1786, Host, Linux)
+* Use `board-id` as board name if available (Board, macOS)
+    * Intel only
+* Support shared VRAM usage detection for AMD GPUs (GPU, Linux)
+* Use `perflib.h` instead of `pdh.h` for CPU temperature querying to get rid of `pdh.dll` dependency (#1787, CPU, Windows)
+* Support GPU info detection for old ATI radeon driver (#1810, GPU, Linux)
+* Add macOS 26 Tahoe support (macOS)
+    * Report macOS 26 code name (OS)
+    * Report Liquid Glass DE on macOS 26+ (DE)
+    * Detect Metal 4 support (GPU)
+
+Bugfixes:
+* Fix packages counting by ignoring hidden folders (Packages, OpenBSD)
+* Fix Hyprland version detection (WM, FreeBSD)
+* Don't show `Please insert a disk into drive D:` error dialogs (#1805, Disk, Windows)
+* Hide `/boot/firmware` by default (Disk, Linux)
+
+Logos:
+* Rename Hydra Framework to HydraPwk (#1812)
+* Add AnushOS (#1806)
+* Add HarmonyOS (#1804)
+* Add GhostFreak (#1801)
+* Add TrueNAS Scale (#1795)
+* Add Fedora2_small (#1785)
+* Add xenia_old; update colors of xenia (#1797)
+* Improve colors of bedrock_small (#1790)
+* Add Kalpa Desktop (#1807)
+
+# 2.45.0
+
+Features:
+* Support OnePlus marketing name detection (#1768, Host, Android)
+* Recognize additional GPU vendors (GPU, Linux)
+* Support CTWM, FVWM and I3 window manager version detection (WM)
+* Support KDE version detection on *BSD (DE, FreeBSD)
+* Support `"logo": { "type": "command-raw" }` to run a command and display its output as logo (#1780, Logo)
+    * Useful for displaying custom logos generated by other programs such as `pokeget`: `{ "type": "command-raw", "source": "pokeget random --hide-name" }`
+    * Supported in JSONC config file only. `pokeget random --hide-name | fastfetch --file-raw -` should be used in shell.
+* Acquire SMBIOS information on DragonFly BSD from `/dev/mem`; legacy BIOS only (PhysicalMemory, DragonFly)
+* Support swap usage detection on DragonFly BSD (Swap, DragonFly)
+* Support `--swap-separate` to display detailed swap devices on separate lines (Swap)
+
+Bugfixes
+* Fix MacBook Air model name (#1779, Host, macOS)
+* Don't ignore sshfs mountpoints (#1776, Disk, Linux / FreeBSD)
+* Fix dnf package count detection (#1777, Packages, Linux)
+
+Logos:
+* Add Starry Linux (#1771)
+* Add rhel_small (#1774)
+* Update color palette of voidlinux (#1775)
+* Add void2
+* Update Xenia Linux (#1783)
+
+# 2.44.0
+
+Features:
+* Add option `--disk-hide-folders` and `--disk-hide-fs` to hide specific mountpoints and filesystems in Disk module (Disk)
+    * `--disk-hide-folders` defaults to `/efi:/boot:/boot/efi` on Linux and *BSD. Previously these EFI-related folders were hardcoded to be hidden on Linux.
+
+Bugfixes:
+* Fix Apple Terminal compatibility with `--stat` (macOS, #1755)
+* Ignore `/usr/bin/script` when detecting shell and terminal (Terminal / Shell, #1761)
+* Fix compatibility with KDE Plasma 6.4 which is in beta currently (Display, Linux, #1765)
+
+Logos:
+* Add Kylin (#1760)
+* Add UBLinux (#1764)
+
+# 2.43.0
+
+Features:
+* Support physical core count and package count detection on Solaris (CPU, SunOS)
+* Improve physical core count detection on FreeBSD (CPU, FreeBSD)
+* Add option to hide unknown GPUs (GPU)
+* Detect VRAM type of AMD GPUs on Linux (GPU, Linux)
+* Support playing media detection on macOS 15.4 (#1737, Media, macOS)
+    * Whether it works on newer versions is unknown
+* Detect player name for Windows UMP apps (Media, Windows)
+
+Bugfixes:
+* Fix disk usage detection on 32-bit Linux (#1734, Disk, Linux)
+* Fix compiling on Asahi Linux (GPU, Linux)
+* Fix duplicated playback status (Media, Linux)
+* Don't show 255 in custom format when muted on macOS (#1750, Sound, macOS)
+* Remove shared memory detection for AMD GPUs, which doesn't work as expected (GPU, Windows)
+
+Logos:
+* new AthenaOS
+* add Hydra Framework
+
+# 2.42.0
+
+Changes:
+* Normalize the module name `Bios` to `BIOS` (#1721)
+    * No configuration file changes are required because fastfetch parses module names case-insensitively.
+
+Bugfixes:
+* Disable disk type detection for virtual disks (PhysicalDisk, Linux, #1669)
+* Fix incorrect CPU temperature reporting (CPU, OpenBSD)
+* Fix setting `logo.chafa.symbols` in JSON configuration (Logo, #1709)
+* Fix non-normalized time display (Uptime, #1720)
+* Miscellaneous minor fixes
+
+Features:
+* Add CPU temperature detection support (CPU, SunOS)
+* Improve CPU frequency detection (CPU, NetBSD)
+* Add Wi-Fi detection support (Wifi, NetBSD)
+* Add Webcam detection support (Camera, OpenBSD)
+    * Requires root privileges
+
+Logos:
+* Remove GoralixOS logo (#1699)
+* Add Aurora logo (#1700)
+* Add Codex Linux logo (#1701)
+
+# 2.41.0
+
+Changes:
+* Due to [the deprecation](https://github.com/actions/runner-images/issues/11101), Linux x86_64 binaries are now built with Ubuntu 22.04 (Glibc 2.35, Debian 12)
+    * You can always build fastfetch yourself on your own. Please don't report bugs related to this change.
+
+Features:
+* Support physical core count detection on non-x86 platforms (CPU, Linux / FreeBSD)
+* Support CPU frequency detection on PPC64 (CPU, FreeBSD)
+* Support soar packages count detection (Packages, Linux)
+* Support `~` path expanding on Windows (Logo, Windows)
+* Support retrieving full user name (Title)
+    * Exposed with `--title-format '{full-user-name}'`
+* Improve CPU (thermal zone) temperature detection on Windows (CPU, Windows)
+    * Administrator privileges are no longer needed
+* Support base Wifi info detection on OpenBSD (Wifi, OpenBSD) 
+    * To be tested
+* Support GPU temperature detection for Intel dGPU on Linux (GPU, Linux)
+    * To be tested
+* Add new ARM CPU part numbers (CPU, Linux)
+* Add base implementation of Bluetooth device detection (Bluetooth, NetBSD, #1690)
+* Some small improvements
+
+Logo:
+* Add anduinos
+* Add 2 more Alpine logos
+
+# 2.40.4
+
+Bugfixes:
+* Fix loading presets config on Windows (Windows, #1682)
+    * Regression of v2.40.0
+* Remove the prefix `v` of Hyprland version on Arch Linux (WM, Linux)
+
+# 2.40.3
+
+Bugfixes:
+* Fix loading example configs from presets directory (#1672)
+    * Regression of v2.40.2
+* Mark kitty image protocol support for warp terminal on macOS too (Logo)
+
 # 2.40.2

 Changes:
@@ -837,7 +1261,7 @@ Bugfixes:
 * Fix some presets
 * Better detection for XTerm terminal fonts (#1095, TerminalFont, Linux)
 * Remove debug output (#1097, Windows)
-* Fix command line option `--gpu-hide-type` doesn't work (#1098, GPU)
+* Fix flag `--gpu-hide-type` doesn't work (#1098, GPU)
 * Fix wrong date on Raspbian 10 (#1108, DateTime, Linux)
 * Use `brightness` instead of `actuall_brightness` when detecting current brightness level (Brightness, Linux)
    * Ref: https://bugzilla.kernel.org/show_bug.cgi?id=203905
@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.12.0) # target_link_libraries with OBJECT libs & project homepage url

 project(fastfetch
-    VERSION 2.40.2
+    VERSION 2.51.1
    LANGUAGES C
    DESCRIPTION "Fast neofetch-like system information tool"
    HOMEPAGE_URL "https://github.com/fastfetch-cli/fastfetch"
@@ -32,6 +32,8 @@ elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "SunOS")
    set(SunOS TRUE CACHE BOOL "..." FORCE)
 elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Haiku")
    set(Haiku TRUE CACHE BOOL "..." FORCE)
+elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "GNU")
+    set(GNU TRUE CACHE BOOL "..." FORCE)
 elseif(NOT APPLE AND NOT WIN32)
    message(FATAL_ERROR "Unsupported platform: ${CMAKE_SYSTEM_NAME}")
 endif()
@@ -56,33 +58,33 @@ include(CheckIncludeFile)

 include(CMakeDependentOption)

-cmake_dependent_option(ENABLE_VULKAN "Enable vulkan" ON "LINUX OR APPLE OR FreeBSD OR OpenBSD OR NetBSD OR WIN32 OR ANDROID OR SunOS OR Haiku" OFF)
-cmake_dependent_option(ENABLE_WAYLAND "Enable wayland-client" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD" OFF)
-cmake_dependent_option(ENABLE_XCB_RANDR "Enable xcb-randr" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR SunOS" OFF)
-cmake_dependent_option(ENABLE_XRANDR "Enable xrandr" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR SunOS" OFF)
-cmake_dependent_option(ENABLE_DRM "Enable libdrm" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR SunOS" OFF)
-cmake_dependent_option(ENABLE_DRM_AMDGPU "Enable libdrm_amdgpu" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_GIO "Enable gio-2.0" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR SunOS" OFF)
-cmake_dependent_option(ENABLE_DCONF "Enable dconf" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR SunOS" OFF)
-cmake_dependent_option(ENABLE_DBUS "Enable dbus-1" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR SunOS OR Haiku" OFF)
-cmake_dependent_option(ENABLE_XFCONF "Enable libxfconf-0" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR SunOS" OFF)
-cmake_dependent_option(ENABLE_SQLITE3 "Enable sqlite3" ON "LINUX OR FreeBSD OR APPLE OR OpenBSD OR NetBSD OR SunOS" OFF)
-cmake_dependent_option(ENABLE_RPM "Enable rpm" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_IMAGEMAGICK7 "Enable imagemagick 7" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR APPLE OR WIN32 OR SunOS OR Haiku" OFF)
-cmake_dependent_option(ENABLE_IMAGEMAGICK6 "Enable imagemagick 6" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR APPLE OR SunOS" OFF)
+cmake_dependent_option(ENABLE_VULKAN "Enable vulkan" ON "LINUX OR APPLE OR FreeBSD OR OpenBSD OR NetBSD OR WIN32 OR ANDROID OR SunOS OR Haiku OR GNU" OFF)
+cmake_dependent_option(ENABLE_WAYLAND "Enable wayland-client" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR GNU" OFF)
+cmake_dependent_option(ENABLE_XCB_RANDR "Enable xcb-randr" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR SunOS OR GNU" OFF)
+cmake_dependent_option(ENABLE_XRANDR "Enable xrandr" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR SunOS OR GNU" OFF)
+cmake_dependent_option(ENABLE_DRM "Enable libdrm" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR SunOS OR GNU" OFF)
+cmake_dependent_option(ENABLE_DRM_AMDGPU "Enable libdrm_amdgpu" ON "LINUX OR FreeBSD OR GNU" OFF)
+cmake_dependent_option(ENABLE_GIO "Enable gio-2.0" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR SunOS OR GNU" OFF)
+cmake_dependent_option(ENABLE_DCONF "Enable dconf" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR SunOS OR GNU" OFF)
+cmake_dependent_option(ENABLE_DBUS "Enable dbus-1" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR SunOS OR Haiku OR GNU" OFF)
+cmake_dependent_option(ENABLE_XFCONF "Enable libxfconf-0" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR SunOS OR GNU" OFF)
+cmake_dependent_option(ENABLE_SQLITE3 "Enable sqlite3" ON "LINUX OR FreeBSD OR APPLE OR OpenBSD OR NetBSD OR SunOS OR GNU" OFF)
+cmake_dependent_option(ENABLE_RPM "Enable rpm" ON "LINUX OR GNU" OFF)
+cmake_dependent_option(ENABLE_IMAGEMAGICK7 "Enable imagemagick 7" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR APPLE OR WIN32 OR SunOS OR Haiku OR GNU" OFF)
+cmake_dependent_option(ENABLE_IMAGEMAGICK6 "Enable imagemagick 6" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR APPLE OR SunOS OR GNU" OFF)
 cmake_dependent_option(ENABLE_CHAFA "Enable chafa" ON "ENABLE_IMAGEMAGICK6 OR ENABLE_IMAGEMAGICK7" OFF)
 cmake_dependent_option(ENABLE_ZLIB "Enable zlib" ON "ENABLE_IMAGEMAGICK6 OR ENABLE_IMAGEMAGICK7" OFF)
-cmake_dependent_option(ENABLE_EGL "Enable egl" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR ANDROID OR WIN32 OR SunOS OR Haiku" OFF)
-cmake_dependent_option(ENABLE_GLX "Enable glx" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR ANDROID OR SunOS" OFF)
-cmake_dependent_option(ENABLE_OPENCL "Enable opencl" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR WIN32 OR ANDROID OR SunOS OR Haiku" OFF)
+cmake_dependent_option(ENABLE_EGL "Enable egl" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR ANDROID OR WIN32 OR SunOS OR Haiku OR GNU" OFF)
+cmake_dependent_option(ENABLE_GLX "Enable glx" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR ANDROID OR SunOS OR GNU" OFF)
+cmake_dependent_option(ENABLE_OPENCL "Enable opencl" ON "LINUX OR FreeBSD OR OpenBSD OR NetBSD OR WIN32 OR ANDROID OR SunOS OR Haiku OR GNU" OFF)
 cmake_dependent_option(ENABLE_FREETYPE "Enable freetype" ON "ANDROID" OFF)
-cmake_dependent_option(ENABLE_PULSE "Enable pulse" ON "LINUX OR SunOS" OFF)
+cmake_dependent_option(ENABLE_PULSE "Enable pulse" ON "LINUX 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" 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 OR SunOS" OFF)
+cmake_dependent_option(ENABLE_PCIACCESS "Enable libpciaccess" ON "NetBSD OR OpenBSD" OFF)

 option(ENABLE_SYSTEM_YYJSON "Use system provided (instead of fastfetch embedded) yyjson library" OFF)
 option(ENABLE_ASAN "Build fastfetch with ASAN (address sanitizer)" OFF)
@@ -102,7 +104,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 SORCERY WINGET XBPS)
+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)
 foreach(package_manager ${PACKAGE_MANAGERS})
    if(package_manager STREQUAL "WINGET")
        option(PACKAGES_DISABLE_${package_manager} "Disable ${package_manager} package manager detection by default" ON)
@@ -336,13 +338,12 @@ endif()
 # Ascii image data #
 ####################

-file(GLOB LOGO_FILES "src/logo/ascii/*.txt")
+file(GLOB LOGO_FILES CONFIGURE_DEPENDS "src/logo/ascii/*.txt")
 set(LOGO_BUILTIN_H "#pragma once\n#pragma GCC diagnostic ignored \"-Wtrigraphs\"\n\n")
 foreach(file ${LOGO_FILES})
    fastfetch_load_text("${file}" content)
    get_filename_component(file "${file}" NAME_WE)
    string(TOUPPER "${file}" file)
-    string(REGEX REPLACE "\\$\\{c([0-9]+)\\}" "$\\1" content "${content}")
    set(LOGO_BUILTIN_H "${LOGO_BUILTIN_H}#define FASTFETCH_DATATEXT_LOGO_${file} ${content}\n")
 endforeach()
 file(GENERATE OUTPUT logo_builtin.h CONTENT "${LOGO_BUILTIN_H}")
@@ -352,10 +353,11 @@ file(GENERATE OUTPUT logo_builtin.h CONTENT "${LOGO_BUILTIN_H}")
 #######################

 set(LIBFASTFETCH_SRC
-    src/common/percent.c
    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
@@ -364,10 +366,13 @@ set(LIBFASTFETCH_SRC
    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/detection/bluetoothradio/bluetoothradio.c
    src/detection/bootmgr/bootmgr.c
    src/detection/chassis/chassis.c
@@ -472,7 +477,6 @@ set(LIBFASTFETCH_SRC
    src/modules/wmtheme/wmtheme.c
    src/modules/zpool/zpool.c
    src/options/display.c
-    src/options/modules.c
    src/options/logo.c
    src/options/general.c
    src/util/edidHelper.c
@@ -525,6 +529,7 @@ if(LINUX)
        src/detection/displayserver/linux/xlib.c
        src/detection/font/font_linux.c
        src/detection/gpu/gpu_linux.c
+        src/detection/gpu/gpu_drm.c
        src/detection/gpu/gpu_pci.c
        src/detection/gtk_qt/gtk.c
        src/detection/host/host_linux.c
@@ -545,6 +550,7 @@ if(LINUX)
        src/detection/opengl/opengl_linux.c
        src/detection/os/os_linux.c
        src/detection/packages/packages_linux.c
+        src/detection/packages/packages_nix.c
        src/detection/poweradapter/poweradapter_linux.c
        src/detection/processes/processes_linux.c
        src/detection/gtk_qt/qt.c
@@ -593,7 +599,7 @@ elseif(ANDROID)
        src/detection/diskio/diskio_linux.c
        src/detection/displayserver/displayserver_android.c
        src/detection/font/font_nosupport.c
-        src/detection/gpu/gpu_nosupport.c
+        src/detection/gpu/gpu_android.c
        src/detection/host/host_android.c
        src/detection/icons/icons_nosupport.c
        src/detection/initsystem/initsystem_linux.c
@@ -611,6 +617,7 @@ elseif(ANDROID)
        src/detection/opengl/opengl_linux.c
        src/detection/os/os_android.c
        src/detection/packages/packages_linux.c
+        src/detection/packages/packages_nix.c
        src/detection/poweradapter/poweradapter_nosupport.c
        src/detection/processes/processes_linux.c
        src/detection/sound/sound_nosupport.c
@@ -672,6 +679,7 @@ elseif(FreeBSD)
        src/detection/displayserver/linux/xlib.c
        src/detection/font/font_linux.c
        src/detection/gpu/gpu_bsd.c
+        src/detection/gpu/gpu_drm.c
        src/detection/gpu/gpu_pci.c
        src/detection/gtk_qt/gtk.c
        src/detection/host/host_bsd.c
@@ -705,7 +713,7 @@ elseif(FreeBSD)
        src/detection/uptime/uptime_bsd.c
        src/detection/users/users_linux.c
        src/detection/wallpaper/wallpaper_linux.c
-        src/detection/wm/wm_nosupport.c
+        src/detection/wm/wm_linux.c
        src/detection/de/de_linux.c
        src/detection/wmtheme/wmtheme_linux.c
        src/detection/camera/camera_linux.c
@@ -734,7 +742,7 @@ elseif(NetBSD)
        src/common/sysctl.c
        src/detection/battery/battery_nbsd.c
        src/detection/bios/bios_nbsd.c
-        src/detection/bluetooth/bluetooth_nosupport.c
+        src/detection/bluetooth/bluetooth_bsd.c
        src/detection/bluetoothradio/bluetoothradio_nosupport.c
        src/detection/board/board_nbsd.c
        src/detection/bootmgr/bootmgr_bsd.c
@@ -783,7 +791,7 @@ elseif(NetBSD)
        src/detection/netio/netio_bsd.c
        src/detection/opengl/opengl_linux.c
        src/detection/os/os_nbsd.c
-        src/detection/packages/packages_obsd.c
+        src/detection/packages/packages_nbsd.c
        src/detection/poweradapter/poweradapter_nosupport.c
        src/detection/processes/processes_nbsd.c
        src/detection/gtk_qt/qt.c
@@ -797,8 +805,8 @@ elseif(NetBSD)
        src/detection/uptime/uptime_bsd.c
        src/detection/users/users_linux.c
        src/detection/wallpaper/wallpaper_linux.c
-        src/detection/wifi/wifi_nosupport.c
-        src/detection/wm/wm_nosupport.c
+        src/detection/wifi/wifi_nbsd.c
+        src/detection/wm/wm_linux.c
        src/detection/de/de_linux.c
        src/detection/wmtheme/wmtheme_linux.c
        src/detection/camera/camera_linux.c
@@ -879,8 +887,8 @@ elseif(OpenBSD)
        src/detection/uptime/uptime_bsd.c
        src/detection/users/users_obsd.c
        src/detection/wallpaper/wallpaper_linux.c
-        src/detection/wifi/wifi_nosupport.c
-        src/detection/wm/wm_nosupport.c
+        src/detection/wifi/wifi_obsd.c
+        src/detection/wm/wm_linux.c
        src/detection/de/de_linux.c
        src/detection/wmtheme/wmtheme_linux.c
        src/detection/camera/camera_linux.c
@@ -892,7 +900,7 @@ elseif(OpenBSD)
 elseif(APPLE)
    list(APPEND LIBFASTFETCH_SRC
        src/common/io/io_unix.c
-        src/common/netif/netif_bsd.c
+        src/common/netif/netif_apple.c
        src/common/networking/networking_linux.c
        src/common/processing_linux.c
        src/common/sysctl.c
@@ -936,6 +944,7 @@ elseif(APPLE)
        src/detection/opengl/opengl_apple.c
        src/detection/os/os_apple.m
        src/detection/packages/packages_apple.c
+        src/detection/packages/packages_nix.c
        src/detection/poweradapter/poweradapter_apple.c
        src/detection/processes/processes_bsd.c
        src/detection/sound/sound_apple.c
@@ -977,7 +986,6 @@ elseif(WIN32)
        src/detection/btrfs/btrfs_nosupport.c
        src/detection/chassis/chassis_windows.c
        src/detection/cpu/cpu_windows.c
-        src/detection/cpu/cpu_windows.cpp
        src/detection/cpucache/cpucache_windows.c
        src/detection/cpuusage/cpuusage_windows.c
        src/detection/cursor/cursor_windows.c
@@ -1039,7 +1047,7 @@ elseif(SunOS)
    list(APPEND LIBFASTFETCH_SRC
        src/common/dbus.c
        src/common/io/io_unix.c
-        src/common/netif/netif_bsd.c
+        src/common/netif/netif_apple.c
        src/common/networking/networking_linux.c
        src/common/processing_linux.c
        src/detection/battery/battery_nosupport.c
@@ -1057,7 +1065,7 @@ elseif(SunOS)
        src/detection/bluetoothradio/bluetoothradio_nosupport.c
        src/detection/disk/disk_sunos.c
        src/detection/dns/dns_linux.c
-        src/detection/physicaldisk/physicaldisk_nosupport.c
+        src/detection/physicaldisk/physicaldisk_sunos.c
        src/detection/physicalmemory/physicalmemory_linux.c
        src/detection/diskio/diskio_sunos.c
        src/detection/displayserver/linux/displayserver_linux.c
@@ -1097,7 +1105,7 @@ elseif(SunOS)
        src/detection/poweradapter/poweradapter_nosupport.c
        src/detection/processes/processes_linux.c
        src/detection/gtk_qt/qt.c
-        src/detection/sound/sound_linux.c
+        src/detection/sound/sound_sunos.c
        src/detection/swap/swap_sunos.c
        src/detection/terminalfont/terminalfont_linux.c
        src/detection/terminalshell/terminalshell_linux.c
@@ -1186,6 +1194,84 @@ elseif(Haiku)
        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/detection/battery/battery_nosupport.c
+        src/detection/bios/bios_nosupport.c
+        src/detection/board/board_nosupport.c
+        src/detection/bootmgr/bootmgr_nosupport.c
+        src/detection/brightness/brightness_nosupport.c
+        src/detection/btrfs/btrfs_nosupport.c
+        src/detection/chassis/chassis_nosupport.c
+        src/detection/cpu/cpu_linux.c
+        src/detection/cpucache/cpucache_nosupport.c
+        src/detection/cpuusage/cpuusage_linux.c
+        src/detection/cursor/cursor_linux.c
+        src/detection/bluetooth/bluetooth_linux.c
+        src/detection/bluetoothradio/bluetoothradio_linux.c
+        src/detection/disk/disk_linux.c
+        src/detection/dns/dns_linux.c
+        src/detection/physicaldisk/physicaldisk_nosupport.c
+        src/detection/physicalmemory/physicalmemory_nosupport.c
+        src/detection/diskio/diskio_nosupport.c
+        src/detection/displayserver/linux/displayserver_linux.c
+        src/detection/displayserver/linux/drm.c
+        src/detection/displayserver/linux/wayland/wayland.c
+        src/detection/displayserver/linux/wayland/global-output.c
+        src/detection/displayserver/linux/wayland/zwlr-output.c
+        src/detection/displayserver/linux/wayland/wlr-output-management-unstable-v1-protocol.c
+        src/detection/displayserver/linux/wmde.c
+        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_pci.c
+        src/detection/gtk_qt/gtk.c
+        src/detection/host/host_nosupport.c
+        src/detection/icons/icons_linux.c
+        src/detection/initsystem/initsystem_linux.c
+        src/detection/keyboard/keyboard_nosupport.c
+        src/detection/libc/libc_linux.c
+        src/detection/lm/lm_linux.c
+        src/detection/loadavg/loadavg_linux.c
+        src/detection/locale/locale_linux.c
+        src/detection/localip/localip_linux.c
+        src/detection/gamepad/gamepad_nosupport.c
+        src/detection/media/media_linux.c
+        src/detection/memory/memory_linux.c
+        src/detection/mouse/mouse_nosupport.c
+        src/detection/netio/netio_nosupport.c
+        src/detection/opengl/opengl_linux.c
+        src/detection/os/os_linux.c
+        src/detection/packages/packages_linux.c
+        src/detection/packages/packages_nix.c
+        src/detection/poweradapter/poweradapter_nosupport.c
+        src/detection/processes/processes_linux.c
+        src/detection/gtk_qt/qt.c
+        src/detection/sound/sound_linux.c
+        src/detection/swap/swap_linux.c
+        src/detection/terminalfont/terminalfont_linux.c
+        src/detection/terminalshell/terminalshell_linux.c
+        src/detection/terminalsize/terminalsize_linux.c
+        src/detection/theme/theme_linux.c
+        src/detection/tpm/tpm_nosupport.c
+        src/detection/uptime/uptime_linux.c
+        src/detection/users/users_linux.c
+        src/detection/wallpaper/wallpaper_linux.c
+        src/detection/wifi/wifi_nosupport.c
+        src/detection/wm/wm_linux.c
+        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)
@@ -1309,6 +1395,10 @@ elseif(NetBSD)
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-rpath,/usr/X11R7/lib -Wl,-rpath,/usr/pkg/lib") # ditto
 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)
 endif()

 if(FreeBSD OR OpenBSD OR NetBSD)
@@ -1582,14 +1672,20 @@ elseif(WIN32)
        PRIVATE "ws2_32"
        PRIVATE "ntdll"
        PRIVATE "version"
-        PRIVATE "setupapi"
        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
+        target_link_libraries(libfastfetch
+            PRIVATE "mincore"
+        )
+    endif()
 elseif(FreeBSD)
    target_link_libraries(libfastfetch
        PRIVATE "m"
@@ -1613,6 +1709,7 @@ elseif(OpenBSD)
    )
 elseif(NetBSD)
    target_link_libraries(libfastfetch
+        PRIVATE "bluetooth"
        PRIVATE "m"
        PRIVATE "prop"
    )
@@ -1624,6 +1721,11 @@ elseif(SunOS)
        PRIVATE "proc"
        PRIVATE "zfs"
        PRIVATE "nvpair"
+        PRIVATE "devinfo"
+    )
+elseif(GNU)
+    target_link_libraries(libfastfetch
+        PRIVATE "m"
    )
 elseif(ANDROID)
    CHECK_LIBRARY_EXISTS(-l:libandroid-wordexp.a wordexp "" HAVE_LIBANDROID_WORDEXP_STATIC)
@@ -1826,10 +1928,26 @@ if (BUILD_TESTS)
        PRIVATE libfastfetch
    )

+    add_executable(fastfetch-test-color
+        tests/color.c
+    )
+    target_link_libraries(fastfetch-test-color
+        PRIVATE libfastfetch
+    )
+
+    add_executable(fastfetch-test-duration
+        tests/duration.c
+    )
+    target_link_libraries(fastfetch-test-duration
+        PRIVATE libfastfetch
+    )
+
    enable_testing()
    add_test(NAME test-strbuf COMMAND fastfetch-test-strbuf)
    add_test(NAME test-list COMMAND fastfetch-test-list)
    add_test(NAME test-format COMMAND fastfetch-test-format)
+    add_test(NAME test-color COMMAND fastfetch-test-color)
+    add_test(NAME test-duration COMMAND fastfetch-test-duration)
 endif()

 ##################
@@ -1897,17 +2015,17 @@ 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-universal" CPACK_PACKAGE_FILE_NAME)
-else() # We don't use this in Windows
-    if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
-        set(CMAKE_SYSTEM_PROCESSOR "amd64")
-    endif()
-    if(IS_MUSL)
-        string(TOLOWER "${CMAKE_PROJECT_NAME}-musl-${CMAKE_SYSTEM_PROCESSOR}" CPACK_PACKAGE_FILE_NAME)
-    else()
-        string(TOLOWER "${CMAKE_PROJECT_NAME}-${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}" CPACK_PACKAGE_FILE_NAME)
-    endif()
+    string(TOLOWER "${CMAKE_PROJECT_NAME}-macos-${CMAKE_SYSTEM_PROCESSOR}" CPACK_PACKAGE_FILE_NAME) # use macos instead of darwin
+elseif(IS_MUSL)
+    string(TOLOWER "${CMAKE_PROJECT_NAME}-musl-${CMAKE_SYSTEM_PROCESSOR}" CPACK_PACKAGE_FILE_NAME)
+else()
+    string(TOLOWER "${CMAKE_PROJECT_NAME}-${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}" CPACK_PACKAGE_FILE_NAME)
 endif()

 if(LINUX)
@@ -1933,12 +2051,17 @@ if(LINUX)
        endif()
    endif()

-    find_program(HAVE_RPMBUILD "rpmbuild")
-    if(HAVE_RPMBUILD)
-        set(CPACK_GENERATOR "${CPACK_GENERATOR};RPM")
+    if(NOT IS_MUSL)
+        find_program(HAVE_RPMBUILD "rpmbuild")
+        if(HAVE_RPMBUILD)
+            set(CPACK_GENERATOR "${CPACK_GENERATOR};RPM")

-        set(CPACK_RPM_PACKAGE_LICENSE "MIT")
+            set(CPACK_RPM_PACKAGE_LICENSE "MIT")
+        endif()
    endif()
+elseif(FreeBSD)
+    set(CPACK_FREEBSD_PACKAGE_LICENSE "MIT")
+    set(CPACK_GENERATOR "${CPACK_GENERATOR};FREEBSD")
 endif()

 set(CPACK_SET_DESTDIR ON)
@@ -10,6 +10,7 @@
 [![GitHub release (with filter)](https://img.shields.io/github/v/release/fastfetch-cli/fastfetch?logo=github)](https://github.com/fastfetch-cli/fastfetch/releases)
 [![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)

 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.

@@ -21,6 +22,8 @@ Fastfetch is a [neofetch](https://github.com/dylanaraps/neofetch)-like tool for
 <img src="screenshots/example3.png" width="48%" align="top" />
 <img src="screenshots/example5.png" height="15%" align="top" />

+According configuration files for examples are located [here](https://github.com/fastfetch-cli/fastfetch/tree/dev/presets/examples).
+
 There are [screenshots on different platforms](https://github.com/fastfetch-cli/fastfetch/wiki).

 ## Installation
@@ -33,7 +36,6 @@ 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>

-* Ubuntu: [`ppa:zhangsongcui3371/fastfetch`](https://launchpad.net/~zhangsongcui3371/+archive/ubuntu/fastfetch) (for Ubuntu 22.04 or newer)
 * Debian: `apt install fastfetch` (for Debian 13 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`
@@ -55,7 +57,7 @@ If fastfetch is not packaged for your distribution or an outdated version is pac

 ### macOS

-* [HomeBrew](https://formulae.brew.sh/formula/fastfetch#default): `brew install fastfetch`
+* [Homebrew](https://formulae.brew.sh/formula/fastfetch#default): `brew install fastfetch`
 * [MacPorts](https://ports.macports.org/port/fastfetch/): `sudo port install fastfetch`

 ### Windows
@@ -67,9 +69,12 @@ If fastfetch is not packaged for your distribution or an outdated version is pac

 You may also download the program directly from [the GitHub releases page](https://github.com/fastfetch-cli/fastfetch/releases/latest) in the form of an archive file.

-### FreeBSD
+### BSD systems

-* `pkg install fastfetch`
+* FreeBSD: `pkg install fastfetch`
+* NetBSD: `pkgin in fastfetch`
+* OpenBSD: `pkg_add fastfetch` (Snapshots only)
+* DragonFly BSD: `pkg install fastfetch` (Snapshots only)

 ### Android (Termux)

@@ -87,9 +92,10 @@ See the Wiki: https://github.com/fastfetch-cli/fastfetch/wiki/Building

 * Run with default configuration: `fastfetch`
 * Run with [all supported modules](https://github.com/fastfetch-cli/fastfetch/wiki/Support+Status#available-modules) to find what interests you: `fastfetch -c all.jsonc`
-* View all data that fastfetch detects: `fastfetch -s <module> --format json`
+* View all data that fastfetch detects: `fastfetch -s <module1>[:<module2>][:<module3>] --format json`
 * Display help messages: `fastfetch --help`
-* Generate a config file based on command line arguments: `fastfetch --arg1 --arg2 --gen-config`
+* Generate a minimal config file: `fastfetch [-s <module1>[:<module2>]] --gen-config [</path/to/config.jsonc>]`
+    * Use: `--gen-config-full` to generate a full config file with all optional options

 ## Customization

@@ -230,6 +236,56 @@ Set the key to a white space.
 }
 ```

+### Q: How can I display images on Windows?
+
+As of April 2025:
+
+#### mintty and Wezterm
+
+mintty (used by Bash on Windows and MSYS2) and Wezterm (nightly build only) support the iTerm image protocol on Windows.
+
+In `config.jsonc`:  
+```json
+{
+  "logo": {
+    "type": "iterm",
+    "source": "C:/path/to/image.png",
+    "width": <num-in-chars>
+  }
+}
+```
+
+#### Windows Terminal
+
+Windows Terminal supports the sixel image protocol only.
+
+* If you installed fastfetch through MSYS2:
+    1. Install imagemagick: `pacman -S mingw-w64-<subsystem>-x86_64-imagemagick`
+    2. In `config.jsonc`:  
+```jsonc
+{
+  "logo": {
+    "type": "sixel", // DO NOT USE "auto"
+    "source": "C:/path/to/image.png", // Do NOT use `~` as fastfetch is a native Windows program and doesn't apply cygwin path conversion
+    "width": <image-width-in-chars>, // Optional
+    "height": <image-height-in-chars> // Optional
+  }
+}
+```
+* If you installed fastfetch via scoop or downloaded the binary directly from the GitHub Releases page:
+    1. Convert your image manually to sixel format using [any online image conversion service](https://www.google.com/search?q=convert+image+to+sixel)
+    2. In `config.jsonc`:  
+```jsonc
+{
+  "logo": {
+    "type": "raw", // DO NOT USE "auto"
+    "source": "C:/path/to/image.sixel",
+    "width": <image-width-in-chars>, // Required
+    "height": <image-height-in-chars> // Required
+  }
+}
+```
+
 ### Q: I want feature A / B / C. Will fastfetch support it?

 Fastfetch is a system information tool. We only accept hardware or system-level software feature requests. For most personal uses, I recommend using the `Command` module to implement custom functionality, which can be used to grab output from a custom shell script:
@@ -62,11 +62,17 @@ end
 echo '
 import json, subprocess, sys

+
 def main():
    data: dict[str, list[dict]] = json.loads(subprocess.check_output(["fastfetch", "--help-raw"]))

    for key in data:
        for flag in data[key]:
+            if flag["long"] == "logo-color-[1-9]":
+                for i in range(1, 10):
+                    print(f"""complete -c fastfetch -d "{flag["desc"]}" -l "logo-color-{i}" -x -a "(__fastfetch_complete_color)" """)
+                continue
+
            if flag.get("pseudo", False):
                continue

@@ -75,7 +81,7 @@ def main():
                command_prefix += f""" -o {flag["short"]}"""

            if "arg" in flag:
-                type: str = flag["arg"]["type"];
+                type: str = flag["arg"]["type"]
                if type == "bool":
                    print(f"{command_prefix} -x -a \"(__fastfetch_complete_bool)\"")
                elif type == "color":
@@ -98,6 +104,7 @@ def main():
            else:
                print(f"{command_prefix} -f")

+
 if __name__ == "__main__":
    try:
        main()
@@ -1,3 +1,81 @@
+fastfetch (2.51.0) jammy; urgency=medium
+
+  * Update to 2.51.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Fri, 29 Aug 2025 08:55:03 +0800
+
+fastfetch (2.50.2) jammy; urgency=medium
+
+  * Update to 2.50.2
+
+ -- Carter Li <zhangsongcui@live.cn>  Thu, 21 Aug 2025 10:33:07 +0800
+
+fastfetch (2.49.0) jammy; urgency=medium
+
+  * Update to 2.49.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Thu, 31 Jul 2025 14:32:59 +0800
+
+fastfetch (2.48.0) jammy; urgency=medium
+
+  * Update to 2.48.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Thu, 17 Jul 2025 16:16:52 +0800
+
+fastfetch (2.47.0) jammy; urgency=medium
+
+  * Update to 2.47.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Thu, 03 Jul 2025 14:51:45 +0800
+
+fastfetch (2.46.0) jammy; urgency=medium
+
+  * Update to 2.46.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Fri, 20 Jun 2025 15:01:21 +0800
+
+fastfetch (2.45.0) jammy; urgency=medium
+
+  * Update to 2.45.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Thu, 05 Jun 2025 10:56:38 +0800
+
+fastfetch (2.44.0) jammy; urgency=medium
+
+  * Update to 2.44.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Mon, 26 May 2025 14:59:01 +0800
+
+fastfetch (2.43.0) jammy; urgency=medium
+
+  * Update to 2.43.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Wed, 14 May 2025 09:49:50 +0800
+
+fastfetch (2.42.0) jammy; urgency=medium
+
+  * Update to 2.42.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Wed, 30 Apr 2025 14:08:57 +0800
+
+fastfetch (2.41.0) jammy; urgency=medium
+
+  * Update to 2.41.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Wed, 16 Apr 2025 13:42:58 +0800
+
+fastfetch (2.40.4) jammy; urgency=medium
+
+  * Update to 2.40.4
+
+ -- Carter Li <zhangsongcui@live.cn>  Thu, 10 Apr 2025 15:38:21 +0800
+
+fastfetch (2.40.3) jammy; urgency=medium
+
+  * Update to 2.40.3
+
+ -- Carter Li <zhangsongcui@live.cn>  Mon, 07 Apr 2025 09:29:27 +0800
+
 fastfetch (2.40.0) jammy; urgency=medium

  * Update to 2.40.0
@@ -1 +1 @@
-fastfetch_2.40.0_source.buildinfo universe/utils optional
+fastfetch_2.51.0_source.buildinfo universe/utils optional
@@ -52,7 +52,10 @@
        },
        "memory",
        "physicalmemory",
-        "swap",
+        {
+            "type": "swap",
+            "separate": true
+        },
        "disk",
        "btrfs",
        "zpool",
@@ -54,7 +54,10 @@
        },
        "memory",
        "physicalmemory",
-        "swap",
+        {
+            "type": "swap",
+            "separate": true
+        },
        "disk",
        "btrfs",
        "zpool",
@@ -12,10 +12,11 @@
            "type": ["bar", "hide-others"]
        },
        "bar": {
-            "borderLeft": "",
-            "borderRight": "",
-            "charElapsed": "█",
-            "charTotal": "░",
+            "border": null,
+            "char": {
+                "elapsed": "█",
+                "total": "░"
+            },
            "width": 40
        },
        "constants": [
@@ -6,11 +6,13 @@
            "keys": "blue"
        },
        "separator": "",
+        // Constants are reusable strings referenced by {$1}, {$2}, etc.
+        // These contain ANSI escape codes for cursor positioning
        "constants": [
-            "──────────────────────────────────────────────",
-            "\u001b[47D",
-            "\u001b[47C",
-            "\u001b[46C"
+            "──────────────────────────────────────────────", // {$1} - horizontal line for 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
        ],
        "brightColor": false
    },
@@ -22,6 +24,24 @@
        },
        {
            "type": "os",
+            // Key format breakdown for OS module:
+            // "│  {icon}  \u001b[s{sysname}\u001b[u\u001b[10C│{$3}│{$2}"
+            //
+            // │                    - 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")
+            // \u001b[u             - ANSI escape: restore cursor to saved position (ESC[u)
+            //                        Necessary because the length of `{sysname}` differs between different platforms
+            // \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
+            // {$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}"
        },
        {
@@ -34,7 +54,7 @@
            "key": "│  {icon}  Locale    │{$3}│{$2}"
        },

-        // Hardware
+        // Hardware section with cyan color theme
        {
            "type": "custom",
            "key": "│{#cyan}┌──────────────┬{$1}┐{#keys}│\u001b[37D",
@@ -42,6 +62,11 @@
        },
        {
            "type": "chassis",
+            // Similar structure but with cyan color formatting:
+            // │{#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}"
        },
        {
@@ -76,7 +101,7 @@
            "format": ""
        },

-        // Desktop
+        // Desktop section with green color theme
        {
            "type": "custom",
            "key": "│{#green}┌──────────────┬{$1}┐{#keys}│\u001b[37D",
@@ -106,7 +131,7 @@
            "format": ""
        },

-        // Terminal
+        // Terminal section with yellow color theme
        {
            "type": "custom",
            "key": "│{#yellow}┌──────────────┬{$1}┐{#keys}│\u001b[37D",
@@ -138,7 +163,7 @@
            "format": ""
        },

-        // Development
+        // Development section with red color theme
        {
            "type": "custom",
            "key": "│{#red}┌──────────────┬{$1}┐{#keys}│\u001b[39D",
@@ -146,31 +171,44 @@
        },
        {
            "type": "command",
-            "keyIcon": "",
+            "keyIcon": "",                                   // Custom icon override
            "key": "│{#red}│ {icon}  Rust      │{$4}│{#keys}│{$2}",
-            "text": "rustc --version | cut -d' ' -f2",
-            "format": "rustc {}"
+            "text": "rustc --version",
+            "format": "rustc {~6,13}"                         // Print 6th to 13th characters (version number)
        },
        {
            "type": "command",
+            "condition": {
+                "!system": "Windows"                          // Posix version
+            },
            "keyIcon": "",
            "key": "│{#red}│ {icon}  Clang     │{$4}│{#keys}│{$2}",
            "text": "clang --version | head -1 | awk '{print $NF}'",
            "format": "clang {}"
        },
+        {
+            "type": "command",
+            "condition": {
+                "system": "Windows"                           // Windows version
+            },
+            "keyIcon": "",
+            "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}",
            "text": "node --version",
-            "format": "node {~1}"
+            "format": "node {~1}"                             // {~1} removes first character (v)
        },
        {
            "type": "command",
            "keyIcon": "",
            "key": "│{#red}│ {icon}  Go        │{$4}│{#keys}│{$2}",
            "text": "go version | cut -d' ' -f3",
-            "format": "go {~2}"
+            "format": "go {~2}"                               // {~2} removes first 2 characters (go)
        },
        {
            "type": "command",
@@ -200,7 +238,7 @@
            "format": ""
        },

-        // Uptime
+        // Uptime section with magenta color theme
        {
            "type": "custom",
            "key": "│{#magenta}┌──────────────┬{$1}┐{#keys}│\u001b[36D",
@@ -212,15 +250,28 @@
        },
        {
            "type": "users",
-            "myselfOnly": true,
+            "myselfOnly": true,                               // Only show current user
            "keyIcon": "",
            "key": "│{#magenta}│ {icon}  Login     │{$4}│{#keys}│{$2}"
        },
        {
+            "condition": {                                    // Conditional module: only show on non-macOS
+                "!system": "macOS"
+            },
            "type": "disk",
            "keyIcon": "",
            "key": "│{#magenta}│ {icon}  OS Age    │{$4}│{#keys}│{$2}",
-            "folders": "/", // On macOS, "/System/Volumes/VM" works for me
+            "folders": "/",                                   // Check root filesystem
+            "format": "{create-time:10} [{days} days]"        // Show creation time and age in days
+        },
+        {
+            "condition": {                                    // Conditional module: only show on macOS
+                "system": "macOS"
+            },
+            "type": "disk",
+            "keyIcon": "",
+            "key": "│{#magenta}│ {icon}  OS Age    │{$4}│{#keys}│{$2}",
+            "folders": "/System/Volumes/VM",                 // Work around for APFS on macOS
            "format": "{create-time:10} [{days} days]"
        },
        {
@@ -230,12 +281,35 @@
        },
        {
            "type": "custom",
-            "key": "└─────────────────{$1}┘",
+            "key": "└─────────────────{$1}┘",                // Bottom border of the entire layout
            "format": ""
        },

-        // End
-        "break",
-        "colors"
+        // End with color palette and line break
+        "break",                                             // Add a blank line
+        "colors"                                             // Display color palette
    ]
 }
+
+/*
+Key Format Structure Explanation:
+
+The key format uses a combination of:
+1. Unicode box drawing characters (│ ┌ ┐ └ ┘ ┬ ┴) for borders
+2. ANSI escape codes for cursor positioning (\u001b[...)
+3. Format variables ({icon}, {sysname}, etc.)
+4. Constant references ({$1}, {$2}, etc.)
+5. Color formatting ({#color})
+
+ANSI Escape Codes Used:
+- \u001b[s      - Save cursor position (ESC[s)
+- \u001b[u      - Restore cursor position (ESC[u)
+- \u001b[nC     - Move cursor right n columns (ESC[nC)
+- \u001b[nD     - Move cursor left n columns (ESC[nD)
+
+This creates a table-like layout with fixed column widths and proper alignment,
+regardless of the actual content length in each field.
+
+For more ANSI escape code reference, see:
+https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797#cursor-controls
+*/
@@ -0,0 +1,49 @@
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "type": "small",
+        "padding": {
+            "top": 1
+        }
+    },
+    "display": {
+        "separator": "  "
+    },
+    "modules": [
+        "break",
+        "title",
+        {
+            "type": "os",
+            "key": "os    ",
+            "keyColor": "red"
+        },
+        {
+            "type": "kernel",
+            "key": "kernel",
+            "keyColor": "green"
+        },
+        {
+            "type": "host",
+            "format": "{vendor} {family}",
+            "key": "host  ",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "packages",
+            "key": "pkgs  ",
+            "keyColor": "blue"
+        },
+        {
+            "type": "uptime",
+            "format": "{?days}{days}d {?}{hours}h {minutes}m",
+            "key": "uptime",
+            "keyColor": "magenta"
+        },
+        {
+            "type": "memory",
+            "key": "memory",
+            "keyColor": "cyan"
+        },
+        "break"
+    ]
+}
@@ -0,0 +1,63 @@
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "type": "small"
+    },
+    "display": {
+        "separator": " ",
+        "key": {
+            "type": "both"
+        },
+        "bar": {
+            "border": {
+                "left": "\uee00",
+                "leftElapsed": "\uee03",
+                "right": "\uee02",
+                "rightElapsed": "\uee05"
+            },
+            "char": {
+                "total": "\uee01",
+                "elapsed": "\uee04"
+            },
+            "color": {
+                "total": null
+            }
+        },
+        "percent": {
+            "type": [
+                "bar",
+                "bar-monochrome"
+            ]
+        }
+    },
+    "modules": [
+        "title",
+        "separator",
+        {
+            "type": "memory",
+            "key": "MEM"
+        },
+        {
+            "type": "swap",
+            "key": "SWP"
+        },
+        {
+            "type": "disk",
+            "folders": "/",
+            "key": "DSK"
+        },
+        {
+            "type": "battery",
+            "key": "BAT"
+        },
+        {
+            "type": "brightness",
+            "key": "BGT"
+        },
+        {
+            "type": "colors",
+            "paddingLeft": 6,
+            "symbol": "circle"
+        }
+    ]
+}
@@ -0,0 +1,136 @@
+// #1887
+{
+    "$schema": "file:///Users/carter/fastfetch/doc/json_schema.json",
+    "logo": null,
+    "display": {
+        "constants": [
+            "\u001b[s\u001b[33C│\u001b[u",
+            "  »  "
+        ],
+        "separator": "",
+        "percent": {
+            "type": ["num", "bar"]
+        },
+        "brightColor": false,
+        "bar": {
+            "border": {
+                "left": "[",
+                "leftElapsed": "[",
+                "right": "]",
+                "rightElapsed": "]"
+            },
+            "char": {
+                "elapsed": "─",
+                "total": "─"
+            },
+            "color": {
+                "elapsed": "default",
+                "total": "light_black"
+            },
+            "width": 16
+        },
+        "color": {
+            "separator": "default",
+            "keys": "default",
+            "output": "default"
+        }
+    },
+    "modules": [
+        "title",
+        {
+            "type": "custom",
+            "format": "┌────「 {#1}OS{#} 」────────────────────────────┐"
+        },
+        {
+            "type": "os",
+            "key": "│ {icon}{$2}{$1}"
+        },
+        {
+            "type": "disk",
+            "folders": "/",
+            "key": "│       {$1}",
+            "format": "{size-percentage-bar} {size-percentage}"
+        },
+        {
+            "type": "disk",
+            "folders": "/",
+            "key": "│       {$1}",
+            "format": "{size-used} / {size-total}"
+        },
+        {
+            "type": "custom",
+            "format": "└────────────────────────────────────────┘"
+        },
+        "break",
+        {
+            "type": "custom",
+            "format": "┌────「 {#1}UI{#} 」────────────────────────────┐"
+        },
+        {
+            "type": "wm",
+            "key": "│ {icon}{$2}{$1}"
+        },
+        {
+            "type": "wmtheme",
+            "key": "│ {icon}{$2}{$1}"
+        },
+        {
+            "type": "custom",
+            "key": "│       {$1}"
+        },
+        {
+            "type": "display",
+            "key": "│ {icon}{$2}{$1}",
+            "format": "{width}x{height} @ {refresh-rate} Hz"
+        },
+        {
+            "type": "custom",
+            "key": "│       {$1}"
+        },
+        {
+            "type": "terminal",
+            "key": "│ {icon}{$2}{$1}"
+        },
+        {
+            "type": "terminalfont",
+            "key": "│ {icon}{$2}{$1}"
+        },
+        {
+            "type": "custom",
+            "format": "└────────────────────────────────────────┘"
+        },
+        "break",
+        {
+            "type": "custom",
+            "format": "┌────「 {#1}HW{#} 」────────────────────────────┐"
+        },
+        {
+            "type": "cpu",
+            "key": "│ {icon}{$2}{$1}",
+            "format": "{name}"
+        },
+        {
+            "type": "gpu",
+            "key": "│ {icon}{$2}{$1}",
+            "format": "{name}"
+        },
+        {
+            "type": "custom",
+            "key": "│       {$1}"
+        },
+        {
+            "type": "memory",
+            "key": "│ {icon}{$2}{$1}",
+            "format": "{percentage-bar} {percentage}"
+        },
+        {
+            "type": "memory",
+            "key": "│       {$1}",
+            "format": "{used} / {total}"
+        },
+        {
+            "type": "custom",
+            "format": "└────────────────────────────────────────┘"
+        }
+    ]
+}
@@ -8,8 +8,10 @@
            "width": 11
        },
        "bar": {
-            "charElapsed": "=",
-            "charTotal": "-",
+            "char": {
+                "elapsed": "=",
+                "total": "-"
+            },
            "width": 13
        },
        "percent": {
@@ -3,7 +3,12 @@
    "display": {
        "size": {
            "maxPrefix": "MB",
-            "ndigits": 0
+            "ndigits": 0,
+            "spaceBeforeUnit": "never"
+        },
+        "freq": {
+            "ndigits": 3,
+            "spaceBeforeUnit": "never"
        }
    },
    "modules": [
@@ -16,7 +21,10 @@
            "format": "{release}"
        },
        "uptime",
-        "packages",
+        {
+            "type": "packages",
+            "combined": true
+        },
        "shell",
        {
            "type": "display",
@@ -36,11 +44,12 @@
        "cpu",
        {
            "type": "gpu",
-            "key": "GPU"
+            "key": "GPU",
+            "format": "{name}"
        },
        {
            "type": "memory",
-            "format": "{} / {}"
+            "format": "{used} / {total}"
        },
        "break",
        "colors"
@@ -1,6 +1,6 @@
 {
    "home": "https://github.com/ibireme/yyjson",
    "license": "MIT ( embed in source )",
-    "version": "0.10.0",
+    "version": "0.12.0",
    "author": "ibireme"
 }
@@ -10,21 +10,8 @@
 #include <ctype.h>
 #include <inttypes.h>

-bool ffParseModuleOptions(const char* key, const char* value)
-{
-    if (!ffStrStartsWith(key, "--") || !ffCharIsEnglishAlphabet(key[2])) return false;
-
-    for (FFModuleBaseInfo** modules = ffModuleInfos[toupper(key[2]) - 'A']; *modules; ++modules)
-    {
-        FFModuleBaseInfo* baseInfo = *modules;
-        if (baseInfo->parseCommandOptions(baseInfo, key, value)) return true;
-    }
-    return false;
-}
-
 void ffPrepareCommandOption(FFdata* data)
 {
-    FFOptionsModules* const options = &instance.config.modules;
    //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
@@ -33,54 +20,78 @@ void ffPrepareCommandOption(FFdata* data)
        ffPrepareCPUUsage();

    if(ffStrbufContainIgnCaseS(&data->structure, FF_DISKIO_MODULE_NAME))
-        ffPrepareDiskIO(&options->diskIo);
+    {
+        __attribute__((__cleanup__(ffDestroyDiskIOOptions))) FFDiskIOOptions options;
+        ffInitDiskIOOptions(&options);
+        ffPrepareDiskIO(&options);
+    }

    if(ffStrbufContainIgnCaseS(&data->structure, FF_NETIO_MODULE_NAME))
-        ffPrepareNetIO(&options->netIo);
+    {
+        __attribute__((__cleanup__(ffDestroyNetIOOptions))) FFNetIOOptions options;
+        ffInitNetIOOptions(&options);
+        ffPrepareNetIO(&options);
+    }

    if(instance.config.general.multithreading)
    {
        if(ffStrbufContainIgnCaseS(&data->structure, FF_PUBLICIP_MODULE_NAME))
-            ffPreparePublicIp(&options->publicIP);
+        {
+            __attribute__((__cleanup__(ffDestroyPublicIpOptions))) FFPublicIPOptions options;
+            ffInitPublicIpOptions(&options);
+            ffPreparePublicIp(&options);
+        }

        if(ffStrbufContainIgnCaseS(&data->structure, FF_WEATHER_MODULE_NAME))
-            ffPrepareWeather(&options->weather);
+        {
+            __attribute__((__cleanup__(ffDestroyWeatherOptions))) FFWeatherOptions options;
+            ffInitWeatherOptions(&options);
+            ffPrepareWeather(&options);
+        }
    }
 }

-static void genJsonConfig(FFModuleBaseInfo* baseInfo, yyjson_mut_doc* doc)
+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");

-    yyjson_mut_val* module = yyjson_mut_obj(doc);
    FF_STRBUF_AUTO_DESTROY type = ffStrbufCreateS(baseInfo->name);
    ffStrbufLowerCase(&type);
-    yyjson_mut_obj_add_strbuf(doc, module, "type", &type);

-    if (baseInfo->generateJsonConfig)
-        baseInfo->generateJsonConfig(baseInfo, doc, module);
+    if (instance.state.fullConfig)
+    {
+        yyjson_mut_val* module = yyjson_mut_obj(doc);
+        yyjson_mut_obj_add_strbuf(doc, module, "type", &type);

-    if (yyjson_mut_obj_size(module) > 1)
-        yyjson_mut_arr_add_val(modules, module);
+        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, yyjson_mut_doc* doc)
+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(baseInfo, doc, module);
+        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, yyjson_mut_doc* jsonDoc),
+    void (*fn)(FFModuleBaseInfo* baseInfo, void* options, yyjson_mut_doc* jsonDoc),
    yyjson_mut_doc* jsonDoc
 )
 {
@@ -91,10 +102,13 @@ static void parseStructureCommand(
            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, jsonDoc);
+                    fn(baseInfo, optionBuf, jsonDoc);
                else
-                    baseInfo->printModule(baseInfo);
+                    baseInfo->printModule(optionBuf);
+                baseInfo->destroyOptions(optionBuf);
                return;
            }
        }
@@ -134,7 +148,7 @@ void ffPrintCommandOption(FFdata* data, yyjson_mut_doc* jsonDoc)
                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("\e[s\e[1A\e[9999999C\e[%dD%s\e[u", len, str); // Save; Up 1; Right 9999999; Left <len>; Print <str>; Load
+                printf("\e7\e[1A\e[9999999C\e[%dD%s\e8", len, str); // Save; Up 1; Right 9999999; Left <len>; Print <str>; Load
            }
        }

@@ -9,7 +9,6 @@ typedef struct FFdata
    bool configLoaded;
 } FFdata;

-bool ffParseModuleOptions(const char* key, const char* value);
 void ffPrepareCommandOption(FFdata* data);
 void ffPrintCommandOption(FFdata* data, yyjson_mut_doc* jsonDoc);
 void ffMigrateCommandOptionToJsonc(FFdata* data, yyjson_mut_doc* jsonDoc);
@@ -0,0 +1,82 @@
+#include "duration.h"
+
+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)
+    {
+        ffStrbufAppendUInt(result, totalSeconds);
+        if (spaceBeforeUnit) ffStrbufAppendC(result, ' ');
+        ffStrbufAppendS(result, options->durationAbbreviation ? "sec" : "second");
+        if (totalSeconds != 1)
+            ffStrbufAppendC(result, 's');
+        return;
+    }
+
+    uint32_t seconds = (uint32_t) (totalSeconds % 60);
+    totalSeconds /= 60;
+    if (seconds >= 30)
+        totalSeconds++;
+
+    uint32_t minutes = (uint32_t) (totalSeconds % 60);
+    totalSeconds /= 60;
+    uint32_t hours = (uint32_t) (totalSeconds % 24);
+    totalSeconds /= 24;
+    uint32_t days = (uint32_t) totalSeconds;
+
+    if (days > 0)
+    {
+        ffStrbufAppendUInt(result, days);
+        if (spaceBeforeUnit) ffStrbufAppendC(result, ' ');
+        if (options->durationAbbreviation)
+        {
+            ffStrbufAppendC(result, 'd');
+
+            if (hours > 0 || minutes > 0)
+                ffStrbufAppendC(result, ' ');
+        }
+        else
+        {
+            ffStrbufAppendS(result, days == 1 ? "day" : "days");
+
+            if (days >= 100)
+                ffStrbufAppendS(result, "(!)");
+
+            if (hours > 0 || minutes > 0)
+                ffStrbufAppendS(result, ", ");
+        }
+    }
+
+    if (hours > 0)
+    {
+        ffStrbufAppendUInt(result, hours);
+        if (spaceBeforeUnit) ffStrbufAppendC(result, ' ');
+        if (options->durationAbbreviation)
+        {
+            ffStrbufAppendC(result, 'h');
+
+            if (minutes > 0)
+                ffStrbufAppendC(result, ' ');
+        }
+        else
+        {
+            ffStrbufAppendS(result, hours == 1 ? "hour" : "hours");
+
+            if (minutes > 0)
+                ffStrbufAppendS(result, ", ");
+        }
+    }
+
+    if (minutes > 0)
+    {
+        ffStrbufAppendUInt(result, minutes);
+        if (spaceBeforeUnit) ffStrbufAppendC(result, ' ');
+        if (options->durationAbbreviation)
+            ffStrbufAppendC(result, 'm');
+        else
+            ffStrbufAppendS(result, minutes == 1 ? "min" : "mins");
+    }
+}
@@ -0,0 +1,3 @@
+#include "fastfetch.h"
+
+void ffDurationAppendNum(uint64_t totalSeconds, FFstrbuf* result);
@@ -11,31 +11,31 @@ void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg)
    switch(formatarg->type)
    {
        case FF_FORMAT_ARG_TYPE_INT:
-            ffStrbufAppendF(buffer, "%" PRIi32, *(int32_t*)formatarg->value);
+            ffStrbufAppendSInt(buffer, *(int32_t*)formatarg->value);
            break;
        case FF_FORMAT_ARG_TYPE_UINT:
-            ffStrbufAppendF(buffer, "%" PRIu32, *(uint32_t*)formatarg->value);
+            ffStrbufAppendUInt(buffer, *(uint32_t*)formatarg->value);
            break;
        case FF_FORMAT_ARG_TYPE_UINT64:
-            ffStrbufAppendF(buffer, "%" PRIu64, *(uint64_t*)formatarg->value);
+            ffStrbufAppendUInt(buffer, *(uint64_t*)formatarg->value);
            break;
        case FF_FORMAT_ARG_TYPE_UINT16:
-            ffStrbufAppendF(buffer, "%" PRIu16, *(uint16_t*)formatarg->value);
+            ffStrbufAppendUInt(buffer, *(uint16_t*)formatarg->value);
            break;
        case FF_FORMAT_ARG_TYPE_UINT8:
-            ffStrbufAppendF(buffer, "%" PRIu8, *(uint8_t*)formatarg->value);
+            ffStrbufAppendUInt(buffer, *(uint8_t*)formatarg->value);
            break;
        case FF_FORMAT_ARG_TYPE_STRING:
            ffStrbufAppendS(buffer, (const char*)formatarg->value);
            break;
        case FF_FORMAT_ARG_TYPE_STRBUF:
-            ffStrbufAppend(buffer, (FFstrbuf*)formatarg->value);
+            ffStrbufAppend(buffer, (const FFstrbuf*)formatarg->value);
            break;
        case FF_FORMAT_ARG_TYPE_FLOAT:
-            ffStrbufAppendF(buffer, "%f", *(float*)formatarg->value);
+            ffStrbufAppendDouble(buffer, *(float*)formatarg->value, instance.config.display.fractionNdigits);
            break;
        case FF_FORMAT_ARG_TYPE_DOUBLE:
-            ffStrbufAppendF(buffer, "%g", *(double*)formatarg->value);
+            ffStrbufAppendDouble(buffer, *(double*)formatarg->value, instance.config.display.fractionNdigits);
            break;
        case FF_FORMAT_ARG_TYPE_BOOL:
            ffStrbufAppendS(buffer, *(bool*)formatarg->value ? "true" : "false");
@@ -107,7 +107,8 @@ static inline void appendInvalidPlaceholder(FFstrbuf* buffer, const char* start,
 static inline bool formatArgSet(const FFformatarg* arg)
 {
    return arg->value != NULL && (
-        (arg->type == FF_FORMAT_ARG_TYPE_DOUBLE && *(double*)arg->value > 0.0) || //Also is false for NaN
+        (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)) ||
@@ -0,0 +1,25 @@
+#include "frequency.h"
+
+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)
+    {
+        ffStrbufAppendDouble(result, mhz / 1000., ndigits);
+        if (spaceBeforeUnit) ffStrbufAppendC(result, ' ');
+        ffStrbufAppendS(result, "GHz");
+    }
+    else
+    {
+        ffStrbufAppendUInt(result, mhz);
+        if (spaceBeforeUnit) ffStrbufAppendC(result, ' ');
+        ffStrbufAppendS(result, "MHz");
+    }
+    return true;
+}
@@ -0,0 +1,3 @@
+#include "fastfetch.h"
+
+bool ffFreqAppendNum(uint32_t mhz, FFstrbuf* result);
@@ -1,4 +1,5 @@
 #include "fastfetch.h"
+#include "common/init.h"
 #include "common/parsing.h"
 #include "common/thread.h"
 #include "detection/displayserver/displayserver.h"
@@ -24,6 +25,7 @@ static void initState(FFstate* state)
    state->logoHeight = 0;
    state->keysHeight = 0;
    state->terminalLightTheme = false;
+    state->titleFqdn = false;

    ffPlatformInit(&state->platform);
    state->configDoc = NULL;
@@ -41,14 +43,13 @@ static void defaultConfig(void)
 {
    ffOptionsInitLogo(&instance.config.logo);
    ffOptionsInitGeneral(&instance.config.general);
-    ffOptionsInitModules(&instance.config.modules);
    ffOptionsInitDisplay(&instance.config.display);
 }

 void ffInitInstance(void)
 {
    #ifdef WIN32
-        //https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/setlocale-wsetlocale?source=recommendations&view=msvc-170#utf-8-support
+        // https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/setlocale-wsetlocale?source=recommendat>
        setlocale(LC_ALL, ".UTF8");
    #else
        // Never use `setlocale(LC_ALL, "")`
@@ -95,15 +96,11 @@ static void chldSignalHandler(FF_MAYBE_UNUSED int signal)

 void ffStart(void)
 {
-    #ifdef FF_START_DETECTION_THREADS
-        if(instance.config.general.multithreading)
-            startDetectionThreads();
-    #endif
-
    ffDisableLinewrap = instance.config.display.disableLinewrap && !instance.config.display.pipe && !instance.state.resultDoc;
    ffHideCursor = instance.config.display.hideCursor && !instance.config.display.pipe && !instance.state.resultDoc;

    #ifdef _WIN32
+    SetErrorMode(SEM_FAILCRITICALERRORS);
    if (instance.config.display.noBuffer)
        setvbuf(stdout, NULL, _IONBF, 0);
    else
@@ -148,7 +145,6 @@ static void destroyConfig(void)
 {
    ffOptionsDestroyLogo(&instance.config.logo);
    ffOptionsDestroyGeneral(&instance.config.general);
-    ffOptionsDestroyModules(&instance.config.modules);
    ffOptionsDestroyDisplay(&instance.config.display);
 }

@@ -0,0 +1,7 @@
+#pragma once
+
+void ffInitInstance(void);
+void ffStart(void);
+void ffFinish(void);
+void ffDestroyInstance(void);
+void ffListFeatures(void);
@@ -19,8 +19,7 @@
    #define FF_INVALID_FD (-1)
    // procfs's file can be changed between read calls such as /proc/meminfo and /proc/uptime.
    // one safe way to read correct data is reading the whole file in a single read syscall
-    // 8192 comes from procps-ng: https://gitlab.com/procps-ng/procps/-/blob/master/library/meminfo.c?ref_type=heads#L39
-    #define PROC_FILE_BUFFSIZ 8192
+    #define PROC_FILE_BUFFSIZ (32 * 1024)
 #endif

 static inline FFNativeFD FFUnixFD2NativeFD(int unixfd)
@@ -32,6 +31,7 @@ static inline FFNativeFD FFUnixFD2NativeFD(int unixfd)
    #endif
 }

+FF_C_NONNULL(3)
 static inline bool ffWriteFDData(FFNativeFD fd, size_t dataSize, const void* data)
 {
    #ifndef _WIN32
@@ -42,18 +42,22 @@ static inline bool ffWriteFDData(FFNativeFD fd, size_t dataSize, const void* dat
    #endif
 }

+FF_C_NONNULL(2)
 static inline bool ffWriteFDBuffer(FFNativeFD fd, const FFstrbuf* content)
 {
    return ffWriteFDData(fd, content->length, content->chars);
 }

+FF_C_NONNULL(1, 3)
 bool ffWriteFileData(const char* fileName, size_t dataSize, const void* data);

+FF_C_NONNULL(1, 2)
 static inline bool ffWriteFileBuffer(const char* fileName, const FFstrbuf* buffer)
 {
    return ffWriteFileData(fileName, buffer->length, buffer->chars);
 }

+FF_C_NONNULL(3)
 static inline ssize_t ffReadFDData(FFNativeFD fd, size_t dataSize, void* data)
 {
    #ifndef _WIN32
@@ -67,26 +71,32 @@ static inline ssize_t ffReadFDData(FFNativeFD fd, size_t dataSize, void* data)
    #endif
 }

+FF_C_NONNULL(1, 3)
 ssize_t ffReadFileData(const char* fileName, size_t dataSize, void* data);
+FF_C_NONNULL(2, 4)
 ssize_t ffReadFileDataRelative(FFNativeFD dfd, const char* fileName, size_t dataSize, void* data);

+FF_C_NONNULL(2)
 bool ffAppendFDBuffer(FFNativeFD fd, FFstrbuf* buffer);
+FF_C_NONNULL(1, 2)
 bool ffAppendFileBuffer(const char* fileName, FFstrbuf* buffer);
+FF_C_NONNULL(2, 3)
 bool ffAppendFileBufferRelative(FFNativeFD dfd, const char* fileName, FFstrbuf* buffer);

+FF_C_NONNULL(1, 2)
 static inline bool ffReadFileBuffer(const char* fileName, FFstrbuf* buffer)
 {
    ffStrbufClear(buffer);
    return ffAppendFileBuffer(fileName, buffer);
 }

+FF_C_NONNULL(2, 3)
 static inline bool ffReadFileBufferRelative(FFNativeFD dfd, const char* fileName, FFstrbuf* buffer)
 {
    ffStrbufClear(buffer);
    return ffAppendFileBufferRelative(dfd, fileName, buffer);
 }

-//Bit flags, combine with |
 typedef enum __attribute__((__packed__)) FFPathType
 {
    FF_PATHTYPE_FILE = 1 << 0,
@@ -95,6 +105,7 @@ typedef enum __attribute__((__packed__)) FFPathType
    FF_PATHTYPE_FORCE_UNSIGNED = UINT8_MAX,
 } FFPathType;

+FF_C_NONNULL(1)
 static inline bool ffPathExists(const char* path, FFPathType pathType)
 {
    #ifdef _WIN32
@@ -137,11 +148,13 @@ static inline bool ffPathExists(const char* path, FFPathType pathType)
    return false;
 }

+FF_C_NONNULL(1, 2)
 bool ffPathExpandEnv(const char* in, FFstrbuf* out);

 #define FF_IO_TERM_RESP_WAIT_MS 100 // #554

 FF_C_SCANF(3, 4)
+FF_C_NONNULL(1, 3)
 const char* ffGetTerminalResponse(const char* request, int nParams, const char* format, ...);

 // Not thread safe!
@@ -158,6 +171,7 @@ static inline void ffUnsuppressIO(bool* suppressed)

 void ffListFilesRecursively(const char* path, bool pretty);

+FF_C_NONNULL(1)
 static inline bool wrapClose(FFNativeFD* pfd)
 {
    assert(pfd);
@@ -177,6 +191,7 @@ static inline bool wrapClose(FFNativeFD* pfd)
 }
 #define FF_AUTO_CLOSE_FD __attribute__((__cleanup__(wrapClose)))

+FF_C_NONNULL(1)
 static inline bool wrapFclose(FILE** pfile)
 {
    assert(pfile);
@@ -187,6 +202,7 @@ static inline bool wrapFclose(FILE** pfile)
 }
 #define FF_AUTO_CLOSE_FILE __attribute__((__cleanup__(wrapFclose)))

+FF_C_NONNULL(1)
 #ifndef _WIN32
 static inline bool wrapClosedir(DIR** pdir)
 {
@@ -208,6 +224,7 @@ static inline bool wrapClosedir(HANDLE* pdir)
 #endif
 #define FF_AUTO_CLOSE_DIR __attribute__((__cleanup__(wrapClosedir)))

+FF_C_NONNULL(1, 2, 3)
 static inline bool ffSearchUserConfigFile(const FFlist* configDirs, const char* fileSubpath, FFstrbuf* result)
 {
    // configDirs is a list of FFstrbufs include the trailing slash
@@ -223,6 +240,8 @@ static inline bool ffSearchUserConfigFile(const FFlist* configDirs, const char*
    return false;
 }

+FFNativeFD ffGetNullFD(void);
+
 #ifdef _WIN32
 // Only O_RDONLY is supported
 HANDLE openat(HANDLE dfd, const char* fileName, bool directory);
@@ -290,7 +290,7 @@ bool ffSuppressIO(bool suppress)

 void listFilesRecursively(uint32_t baseLength, FFstrbuf* folder, uint8_t indentation, const char* folderName, bool pretty)
 {
-    FF_AUTO_CLOSE_FD int dfd = open(folder->chars, O_RDONLY);
+    FF_AUTO_CLOSE_FD int dfd = open(folder->chars, O_RDONLY | O_CLOEXEC);
    if (dfd < 0)
        return;

@@ -358,3 +358,12 @@ void ffListFilesRecursively(const char* path, bool pretty)
    ffStrbufEnsureEndsWithC(&folder, '/');
    listFilesRecursively(folder.length, &folder, 0, NULL, pretty);
 }
+
+FFNativeFD ffGetNullFD(void)
+{
+    static FFNativeFD hNullFile = -1;
+    if (hNullFile != -1)
+        return hNullFile;
+    hNullFile = open("/dev/null", O_WRONLY | O_CLOEXEC);
+    return hNullFile;
+}
@@ -147,6 +147,14 @@ ssize_t ffReadFileDataRelative(HANDLE dfd, const char* fileName, size_t dataSize

 bool ffPathExpandEnv(const char* in, FFstrbuf* out)
 {
+    if (in[0] == '~') {
+        if ((in[1] == '/' || in[1] == '\\' || in[1] == '\0') && !ffStrContainsC(in, '%')) {
+            ffStrbufSet(out, &instance.state.platform.homeDir);
+            ffStrbufAppendS(out, in + 1);
+            return true;
+        }
+    }
+
    DWORD length = ExpandEnvironmentStringsA(in, NULL, 0);
    if (length <= 1) return false;

@@ -167,7 +175,7 @@ bool ffSuppressIO(bool suppress)
    static bool init = false;
    static HANDLE hOrigOut = INVALID_HANDLE_VALUE;
    static HANDLE hOrigErr = INVALID_HANDLE_VALUE;
-    static HANDLE hNullFile = INVALID_HANDLE_VALUE;
+    HANDLE hNullFile = ffGetNullFD();
    static int fOrigOut = -1;
    static int fOrigErr = -1;
    static int fNullFile = -1;
@@ -179,7 +187,6 @@ bool ffSuppressIO(bool suppress)

        hOrigOut = GetStdHandle(STD_OUTPUT_HANDLE);
        hOrigErr = GetStdHandle(STD_ERROR_HANDLE);
-        hNullFile = CreateFileW(L"NUL", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, NULL);
        fOrigOut = _dup(STDOUT_FILENO);
        fOrigErr = _dup(STDERR_FILENO);
        fNullFile = _open_osfhandle((intptr_t) hNullFile, 0);
@@ -344,3 +351,23 @@ const char* ffGetTerminalResponse(const char* request, int nParams, const char*

    return NULL;
 }
+
+FFNativeFD ffGetNullFD(void)
+{
+    static FFNativeFD hNullFile = INVALID_HANDLE_VALUE;
+    if (hNullFile != INVALID_HANDLE_VALUE)
+        return hNullFile;
+    hNullFile = CreateFileW(
+        L"NUL",
+        GENERIC_READ | GENERIC_WRITE,
+        FILE_SHARE_WRITE,
+        0,
+        OPEN_EXISTING,
+        0,
+        &(SECURITY_ATTRIBUTES){
+            .nLength = sizeof(SECURITY_ATTRIBUTES),
+            .lpSecurityDescriptor = NULL,
+            .bInheritHandle = TRUE,
+        });
+    return hNullFile;
+}
@@ -4,6 +4,7 @@
 #include "common/printing.h"
 #include "common/io/io.h"
 #include "common/time.h"
+#include "detection/version/version.h"
 #include "modules/modules.h"
 #include "util/stringUtils.h"

@@ -11,52 +12,57 @@
 #include <ctype.h>
 #include <inttypes.h>

-bool ffJsonConfigParseModuleArgs(const char* key, yyjson_val* val, FFModuleArgs* moduleArgs)
+bool ffJsonConfigParseModuleArgs(yyjson_val* key, yyjson_val* val, FFModuleArgs* moduleArgs)
 {
-    if(ffStrEqualsIgnCase(key, "key"))
+    if (unsafe_yyjson_equals_str(key, "type") || unsafe_yyjson_equals_str(key, "condition"))
+        return true;
+
+    if (unsafe_yyjson_equals_str(key, "key"))
    {
-        ffStrbufSetNS(&moduleArgs->key, (uint32_t) yyjson_get_len(val), yyjson_get_str(val));
+        ffStrbufSetJsonVal(&moduleArgs->key, val);
        return true;
    }
-    else if(ffStrEqualsIgnCase(key, "format"))
+    else if (unsafe_yyjson_equals_str(key, "format"))
    {
-        ffStrbufSetNS(&moduleArgs->outputFormat, (uint32_t) yyjson_get_len(val), yyjson_get_str(val));
+        ffStrbufSetJsonVal(&moduleArgs->outputFormat, val);
        return true;
    }
-    else if(ffStrEqualsIgnCase(key, "outputColor"))
+    else if (unsafe_yyjson_equals_str(key, "outputColor"))
    {
        ffOptionParseColor(yyjson_get_str(val), &moduleArgs->outputColor);
        return true;
    }
-    else if(ffStrEqualsIgnCase(key, "keyColor"))
+    else if (unsafe_yyjson_equals_str(key, "keyColor"))
    {
        ffOptionParseColor(yyjson_get_str(val), &moduleArgs->keyColor);
        return true;
    }
-    else if(ffStrEqualsIgnCase(key, "keyWidth"))
+    else if (unsafe_yyjson_equals_str(key, "keyWidth"))
    {
        moduleArgs->keyWidth = (uint32_t) yyjson_get_uint(val);
        return true;
    }
-    else if(ffStrEqualsIgnCase(key, "keyIcon"))
+    else if (unsafe_yyjson_equals_str(key, "keyIcon"))
    {
-        ffStrbufSetS(&moduleArgs->keyIcon, yyjson_get_str(val));
+        ffStrbufSetJsonVal(&moduleArgs->keyIcon, val);
        return true;
    }
    return false;
 }

-void ffJsonConfigGenerateModuleArgsConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, FFModuleArgs* defaultModuleArgs, FFModuleArgs* moduleArgs)
+void ffJsonConfigGenerateModuleArgsConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, FFModuleArgs* moduleArgs)
 {
-    if (!ffStrbufEqual(&defaultModuleArgs->key, &moduleArgs->key))
+    if (moduleArgs->key.length > 0)
        yyjson_mut_obj_add_strbuf(doc, module, "key", &moduleArgs->key);
-    if (!ffStrbufEqual(&defaultModuleArgs->outputFormat, &moduleArgs->outputFormat))
+    if (moduleArgs->outputFormat.length > 0)
        yyjson_mut_obj_add_strbuf(doc, module, "format", &moduleArgs->outputFormat);
-    if (!ffStrbufEqual(&defaultModuleArgs->keyColor, &moduleArgs->keyColor))
+    if (moduleArgs->outputColor.length > 0)
+        yyjson_mut_obj_add_strbuf(doc, module, "outputColor", &moduleArgs->outputColor);
+    if (moduleArgs->keyColor.length > 0)
        yyjson_mut_obj_add_strbuf(doc, module, "keyColor", &moduleArgs->keyColor);
-    if (moduleArgs->keyWidth != defaultModuleArgs->keyWidth)
+    if (moduleArgs->keyWidth > 0)
        yyjson_mut_obj_add_uint(doc, module, "keyWidth", moduleArgs->keyWidth);
-    if (!ffStrbufEqual(&defaultModuleArgs->keyIcon, &moduleArgs->keyIcon))
+    if (moduleArgs->keyIcon.length > 0)
        yyjson_mut_obj_add_strbuf(doc, module, "keyIcon", &moduleArgs->keyIcon);
 }

@@ -95,16 +101,6 @@ const char* ffJsonConfigParseEnum(yyjson_val* val, int* result, FFKeyValuePair p
        return "Invalid enum value type; must be a string or integer";
 }

-static inline void genJsonResult(FFModuleBaseInfo* baseInfo, 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(baseInfo, doc, module);
-    else
-        yyjson_mut_obj_add_str(doc, module, "error", "Unsupported for JSON format");
-}
-
 static bool parseModuleJsonObject(const char* type, yyjson_val* jsonVal, yyjson_mut_doc* jsonDoc)
 {
    if(!ffCharIsEnglishAlphabet(type[0])) return false;
@@ -114,20 +110,47 @@ static bool parseModuleJsonObject(const char* type, yyjson_val* jsonVal, yyjson_
        FFModuleBaseInfo* baseInfo = *modules;
        if (ffStrEqualsIgnCase(type, baseInfo->name))
        {
-            if (jsonVal) baseInfo->parseJsonObject(baseInfo, jsonVal);
-            if (__builtin_expect(jsonDoc != NULL, false))
-                genJsonResult(baseInfo, jsonDoc);
+            uint8_t optionBuf[FF_OPTION_MAX_SIZE];
+            baseInfo->initOptions(optionBuf);
+            if (jsonVal) baseInfo->parseJsonObject(optionBuf, jsonVal);
+            bool succeeded;
+            if (jsonDoc)
+            {
+                yyjson_mut_val* module = yyjson_mut_arr_add_obj(jsonDoc, jsonDoc->root);
+                yyjson_mut_obj_add_str(jsonDoc, module, "type", baseInfo->name);
+                if (baseInfo->generateJsonResult)
+                    succeeded = baseInfo->generateJsonResult(optionBuf, jsonDoc, module);
+                else
+                {
+                    yyjson_mut_obj_add_str(jsonDoc, module, "error", "Unsupported for JSON format");
+                    succeeded = false;
+                }
+            }
            else
-                baseInfo->printModule(baseInfo);
-            return true;
+                succeeded = baseInfo->printModule(optionBuf);
+            baseInfo->destroyOptions(optionBuf);
+            return succeeded;
        }
    }
+
+    if (jsonDoc)
+    {
+        yyjson_mut_val* module = yyjson_mut_arr_add_obj(jsonDoc, jsonDoc->root);
+        yyjson_mut_obj_add_strcpy(jsonDoc, module, "type", type);
+        yyjson_mut_obj_add_str(jsonDoc, module, "error", "Unknown module type");
+    }
+    else
+    {
+        FFModuleArgs moduleArgs;
+        ffOptionInitModuleArg(&moduleArgs, "");
+        ffPrintError(type, 0, &moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown module type");
+        ffOptionDestroyModuleArg(&moduleArgs);
+    }
    return false;
 }

 static void prepareModuleJsonObject(const char* type, yyjson_val* module)
 {
-    FFconfig* cfg = &instance.config;
    switch (type[0])
    {
        case 'b': case 'B': {
@@ -138,38 +161,65 @@ static void prepareModuleJsonObject(const char* type, yyjson_val* module)
        case 'd': case 'D': {
            if (ffStrEqualsIgnCase(type, FF_DISKIO_MODULE_NAME))
            {
-                if (module) cfg->modules.diskIo.moduleInfo.parseJsonObject(&cfg->modules.diskIo, module);
-                ffPrepareDiskIO(&cfg->modules.diskIo);
+                __attribute__((__cleanup__(ffDestroyDiskIOOptions))) FFDiskIOOptions options;
+                ffInitDiskIOOptions(&options);
+                if (module) ffDiskIOModuleInfo.parseJsonObject(&options, module);
+                ffPrepareDiskIO(&options);
            }
            break;
        }
        case 'n': case 'N': {
            if (ffStrEqualsIgnCase(type, FF_NETIO_MODULE_NAME))
            {
-                if (module) cfg->modules.netIo.moduleInfo.parseJsonObject(&cfg->modules.netIo, module);
-                ffPrepareNetIO(&cfg->modules.netIo);
+                __attribute__((__cleanup__(ffDestroyNetIOOptions))) FFNetIOOptions options;
+                ffInitNetIOOptions(&options);
+                if (module) ffNetIOModuleInfo.parseJsonObject(&options, module);
+                ffPrepareNetIO(&options);
            }
            break;
        }
        case 'p': case 'P': {
            if (ffStrEqualsIgnCase(type, FF_PUBLICIP_MODULE_NAME))
            {
-                if (module) cfg->modules.publicIP.moduleInfo.parseJsonObject(&cfg->modules.publicIP, module);
-                ffPreparePublicIp(&cfg->modules.publicIP);
+                __attribute__((__cleanup__(ffDestroyPublicIpOptions))) FFPublicIPOptions options;
+                ffInitPublicIpOptions(&options);
+                if (module) ffPublicIPModuleInfo.parseJsonObject(&options, module);
+                ffPreparePublicIp(&options);
            }
            break;
        }
        case 'w': case 'W': {
            if (ffStrEqualsIgnCase(type, FF_WEATHER_MODULE_NAME))
            {
-                if (module) cfg->modules.weather.moduleInfo.parseJsonObject(&cfg->modules.weather, module);
-                ffPrepareWeather(&cfg->modules.weather);
+                __attribute__((__cleanup__(ffDestroyWeatherOptions))) FFWeatherOptions options;
+                ffInitWeatherOptions(&options);
+                if (module) ffWeatherModuleInfo.parseJsonObject(&options, module);
+                ffPrepareWeather(&options);
            }
            break;
        }
    }
 }

+static bool matchesJsonArray(const char* str, yyjson_val* val)
+{
+    assert(val);
+
+    if (unsafe_yyjson_is_str(val))
+        return ffStrEqualsIgnCase(str, unsafe_yyjson_get_str(val));
+
+    if (!unsafe_yyjson_is_arr(val)) return false;
+
+    size_t idx, max;
+    yyjson_val* item;
+    yyjson_arr_foreach(val, idx, max, item)
+    {
+        if (yyjson_is_str(item) && ffStrEqualsIgnCase(str, unsafe_yyjson_get_str(item)))
+            return true;
+    }
+    return false;
+}
+
 static const char* printJsonConfig(bool prepare, yyjson_mut_doc* jsonDoc)
 {
    yyjson_val* const root = yyjson_doc_get_root(instance.state.configDoc);
@@ -182,6 +232,7 @@ static const char* printJsonConfig(bool prepare, yyjson_mut_doc* jsonDoc)
    if (!modules) return NULL;
    if (!yyjson_is_arr(modules)) return "Property 'modules' must be an array of strings or objects";

+    bool succeeded = true;
    int32_t thres = instance.config.display.stat;
    yyjson_val* item;
    size_t idx, max;
@@ -197,6 +248,38 @@ static const char* printJsonConfig(bool prepare, yyjson_mut_doc* jsonDoc)
            module = NULL;
        else if (yyjson_is_obj(module))
        {
+            yyjson_val* conditions = yyjson_obj_get(module, "condition");
+            if (conditions)
+            {
+                if (!yyjson_is_obj(conditions))
+                    return "Property 'conditions' must be an object";
+
+                yyjson_val* system = yyjson_obj_get(conditions, "system");
+                if (system && !matchesJsonArray(ffVersionResult.sysName, system))
+                    continue;
+
+                system = yyjson_obj_get(conditions, "!system");
+                if (system && matchesJsonArray(ffVersionResult.sysName, system))
+                    continue;
+
+                yyjson_val* arch = yyjson_obj_get(conditions, "arch");
+                if (arch && !matchesJsonArray(ffVersionResult.architecture, arch))
+                    continue;
+
+                arch = yyjson_obj_get(conditions, "!arch");
+                if (arch && matchesJsonArray(ffVersionResult.architecture, arch))
+                    continue;
+
+                yyjson_val* previousSucceeded = yyjson_obj_get(conditions, "succeeded");
+                if (previousSucceeded && !unsafe_yyjson_is_null(previousSucceeded))
+                {
+                    if (!unsafe_yyjson_is_bool(previousSucceeded))
+                        return "Property 'succeeded' in 'condition' must be a boolean";
+                    if (succeeded != unsafe_yyjson_get_bool(previousSucceeded))
+                        continue;
+                }
+            }
+
            type = yyjson_get_str(yyjson_obj_get(module, "type"));
            if (!type) return "module object must contain a \"type\" key ( case sensitive )";
            if (yyjson_obj_size(module) == 1) // contains only Property type
@@ -207,8 +290,8 @@ static const char* printJsonConfig(bool prepare, yyjson_mut_doc* jsonDoc)

        if(prepare)
            prepareModuleJsonObject(type, module);
-        else if(!parseModuleJsonObject(type, module, jsonDoc))
-            return "Unknown module type";
+        else
+            succeeded = parseModuleJsonObject(type, module, jsonDoc);

        if(!prepare && thres >= 0)
        {
@@ -224,7 +307,7 @@ static const char* printJsonConfig(bool prepare, yyjson_mut_doc* jsonDoc)
                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("\e[s\e[1A\e[9999999C\e[%dD%s\e[u", len, str); // Save; Up 1; Right 9999999; Left <len>; Print <str>; Load
+                printf("\e7\e[1A\e[9999999C\e[%dD%s\e8", len, str); // Save; Up 1; Right 9999999; Left <len>; Print <str>; Load
            }
        }

@@ -2,10 +2,10 @@

 #include "fastfetch.h"

-bool ffJsonConfigParseModuleArgs(const char* key, yyjson_val* val, FFModuleArgs* moduleArgs);
+bool ffJsonConfigParseModuleArgs(yyjson_val* key, yyjson_val* val, FFModuleArgs* moduleArgs);
 const char* ffJsonConfigParseEnum(yyjson_val* val, int* result, FFKeyValuePair pairs[]);
 void ffPrintJsonConfig(bool prepare, yyjson_mut_doc* jsonDoc);
-void ffJsonConfigGenerateModuleArgsConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, FFModuleArgs* defaultModuleArgs, FFModuleArgs* moduleArgs);
+void ffJsonConfigGenerateModuleArgsConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, FFModuleArgs* moduleArgs);

 yyjson_api_inline yyjson_mut_val* yyjson_mut_strbuf(yyjson_mut_doc *doc, const FFstrbuf* buf) {
    return yyjson_mut_strncpy(doc, buf->chars, buf->length);
@@ -52,7 +52,7 @@ static void* libraryLoad(const char* path, int maxVersion)
    for(int i = maxVersion; i >= 0; --i)
    {
        uint32_t originalLength = pathbuf.length;
-        ffStrbufAppendF(&pathbuf, "%i", i);
+        ffStrbufAppendSInt(&pathbuf, i);

        result = dlopen(pathbuf.chars, FF_DLOPEN_FLAGS);
        if(result != NULL)
@@ -74,7 +74,7 @@ void* ffLibraryLoad(const char* path, int maxVersion, ...);
    FF_MAYBE_UNUSED void* libraryObjectName = NULL; // Placeholder

 #define FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, symbolMapping, symbolName, returnValue) \
-    symbolMapping = (__typeof__(&symbolName)) &symbolName
+    symbolMapping = (__typeof__(&symbolName)) &symbolName;

 #define FF_LIBRARY_LOAD_SYMBOL(library, symbolName, returnValue) \
    FF_MAYBE_UNUSED __typeof__(&symbolName) FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, ff ## symbolName, symbolName, returnValue);
@@ -1,69 +1,69 @@
-#include "fastfetch.h"
+#include "modules/modules.h"

 static FFModuleBaseInfo* A[] = {
    NULL,
 };

 static FFModuleBaseInfo* B[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.battery,
-    (FFModuleBaseInfo*) &instance.config.modules.bios,
-    (FFModuleBaseInfo*) &instance.config.modules.bluetooth,
-    (FFModuleBaseInfo*) &instance.config.modules.bluetoothRadio,
-    (FFModuleBaseInfo*) &instance.config.modules.board,
-    (FFModuleBaseInfo*) &instance.config.modules.bootmgr,
-    (FFModuleBaseInfo*) &instance.config.modules.break_,
-    (FFModuleBaseInfo*) &instance.config.modules.brightness,
-    (FFModuleBaseInfo*) &instance.config.modules.btrfs,
+    &ffBatteryModuleInfo,
+    &ffBiosModuleInfo,
+    &ffBluetoothModuleInfo,
+    &ffBluetoothRadioModuleInfo,
+    &ffBoardModuleInfo,
+    &ffBootmgrModuleInfo,
+    &ffBreakModuleInfo,
+    &ffBrightnessModuleInfo,
+    &ffBtrfsModuleInfo,
    NULL,
 };

 static FFModuleBaseInfo* C[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.camera,
-    (FFModuleBaseInfo*) &instance.config.modules.chassis,
-    (FFModuleBaseInfo*) &instance.config.modules.command,
-    (FFModuleBaseInfo*) &instance.config.modules.colors,
-    (FFModuleBaseInfo*) &instance.config.modules.cpu,
-    (FFModuleBaseInfo*) &instance.config.modules.cpuCache,
-    (FFModuleBaseInfo*) &instance.config.modules.cpuUsage,
-    (FFModuleBaseInfo*) &instance.config.modules.cursor,
-    (FFModuleBaseInfo*) &instance.config.modules.custom,
+    &ffCameraModuleInfo,
+    &ffChassisModuleInfo,
+    &ffCommandModuleInfo,
+    &ffColorsModuleInfo,
+    &ffCPUModuleInfo,
+    &ffCPUCacheModuleInfo,
+    &ffCPUUsageModuleInfo,
+    &ffCursorModuleInfo,
+    &ffCustomModuleInfo,
    NULL,
 };

 static FFModuleBaseInfo* D[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.dateTime,
-    (FFModuleBaseInfo*) &instance.config.modules.de,
-    (FFModuleBaseInfo*) &instance.config.modules.display,
-    (FFModuleBaseInfo*) &instance.config.modules.disk,
-    (FFModuleBaseInfo*) &instance.config.modules.diskIo,
-    (FFModuleBaseInfo*) &instance.config.modules.dns,
+    &ffDateTimeModuleInfo,
+    &ffDEModuleInfo,
+    &ffDisplayModuleInfo,
+    &ffDiskModuleInfo,
+    &ffDiskIOModuleInfo,
+    &ffDNSModuleInfo,
    NULL,
 };

 static FFModuleBaseInfo* E[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.editor,
+    &ffEditorModuleInfo,
    NULL,
 };

 static FFModuleBaseInfo* F[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.font,
+    &ffFontModuleInfo,
    NULL,
 };

 static FFModuleBaseInfo* G[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.gamepad,
-    (FFModuleBaseInfo*) &instance.config.modules.gpu,
+    &ffGamepadModuleInfo,
+    &ffGPUModuleInfo,
    NULL,
 };

 static FFModuleBaseInfo* H[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.host,
+    &ffHostModuleInfo,
    NULL,
 };

 static FFModuleBaseInfo* I[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.icons,
-    (FFModuleBaseInfo*) &instance.config.modules.initSystem,
+    &ffIconsModuleInfo,
+    &ffInitSystemModuleInfo,
    NULL,
 };

@@ -72,47 +72,47 @@ static FFModuleBaseInfo* J[] = {
 };

 static FFModuleBaseInfo* K[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.kernel,
-    (FFModuleBaseInfo*) &instance.config.modules.keyboard,
+    &ffKernelModuleInfo,
+    &ffKeyboardModuleInfo,
    NULL,
 };

 static FFModuleBaseInfo* L[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.lm,
-    (FFModuleBaseInfo*) &instance.config.modules.loadavg,
-    (FFModuleBaseInfo*) &instance.config.modules.locale,
-    (FFModuleBaseInfo*) &instance.config.modules.localIP,
+    &ffLMModuleInfo,
+    &ffLoadavgModuleInfo,
+    &ffLocaleModuleInfo,
+    &ffLocalIPModuleInfo,
    NULL,
 };

 static FFModuleBaseInfo* M[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.media,
-    (FFModuleBaseInfo*) &instance.config.modules.memory,
-    (FFModuleBaseInfo*) &instance.config.modules.monitor,
-    (FFModuleBaseInfo*) &instance.config.modules.mouse,
+    &ffMediaModuleInfo,
+    &ffMemoryModuleInfo,
+    &ffMonitorModuleInfo,
+    &ffMouseModuleInfo,
    NULL,
 };

 static FFModuleBaseInfo* N[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.netIo,
+    &ffNetIOModuleInfo,
    NULL,
 };

 static FFModuleBaseInfo* O[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.openCL,
-    (FFModuleBaseInfo*) &instance.config.modules.openGL,
-    (FFModuleBaseInfo*) &instance.config.modules.os,
+    &ffOpenCLModuleInfo,
+    &ffOpenGLModuleInfo,
+    &ffOSModuleInfo,
    NULL,
 };

 static FFModuleBaseInfo* P[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.packages,
-    (FFModuleBaseInfo*) &instance.config.modules.physicalDisk,
-    (FFModuleBaseInfo*) &instance.config.modules.physicalMemory,
-    (FFModuleBaseInfo*) &instance.config.modules.player,
-    (FFModuleBaseInfo*) &instance.config.modules.powerAdapter,
-    (FFModuleBaseInfo*) &instance.config.modules.processes,
-    (FFModuleBaseInfo*) &instance.config.modules.publicIP,
+    &ffPackagesModuleInfo,
+    &ffPhysicalDiskModuleInfo,
+    &ffPhysicalMemoryModuleInfo,
+    &ffPlayerModuleInfo,
+    &ffPowerAdapterModuleInfo,
+    &ffProcessesModuleInfo,
+    &ffPublicIPModuleInfo,
    NULL,
 };

@@ -125,42 +125,42 @@ static FFModuleBaseInfo* R[] = {
 };

 static FFModuleBaseInfo* S[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.separator,
-    (FFModuleBaseInfo*) &instance.config.modules.shell,
-    (FFModuleBaseInfo*) &instance.config.modules.sound,
-    (FFModuleBaseInfo*) &instance.config.modules.swap,
+    &ffSeparatorModuleInfo,
+    &ffShellModuleInfo,
+    &ffSoundModuleInfo,
+    &ffSwapModuleInfo,
    NULL,
 };

 static FFModuleBaseInfo* T[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.terminal,
-    (FFModuleBaseInfo*) &instance.config.modules.terminalFont,
-    (FFModuleBaseInfo*) &instance.config.modules.terminalSize,
-    (FFModuleBaseInfo*) &instance.config.modules.terminalTheme,
-    (FFModuleBaseInfo*) &instance.config.modules.title,
-    (FFModuleBaseInfo*) &instance.config.modules.theme,
-    (FFModuleBaseInfo*) &instance.config.modules.tpm,
+    &ffTerminalModuleInfo,
+    &ffTerminalFontModuleInfo,
+    &ffTerminalSizeModuleInfo,
+    &ffTerminalThemeModuleInfo,
+    &ffTitleModuleInfo,
+    &ffThemeModuleInfo,
+    &ffTPMModuleInfo,
    NULL,
 };

 static FFModuleBaseInfo* U[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.uptime,
-    (FFModuleBaseInfo*) &instance.config.modules.users,
+    &ffUptimeModuleInfo,
+    &ffUsersModuleInfo,
    NULL,
 };

 static FFModuleBaseInfo* V[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.version,
-    (FFModuleBaseInfo*) &instance.config.modules.vulkan,
+    &ffVersionModuleInfo,
+    &ffVulkanModuleInfo,
    NULL,
 };

 static FFModuleBaseInfo* W[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.wallpaper,
-    (FFModuleBaseInfo*) &instance.config.modules.weather,
-    (FFModuleBaseInfo*) &instance.config.modules.wm,
-    (FFModuleBaseInfo*) &instance.config.modules.wifi,
-    (FFModuleBaseInfo*) &instance.config.modules.wmTheme,
+    &ffWallpaperModuleInfo,
+    &ffWeatherModuleInfo,
+    &ffWMModuleInfo,
+    &ffWifiModuleInfo,
+    &ffWMThemeModuleInfo,
    NULL,
 };

@@ -173,7 +173,7 @@ static FFModuleBaseInfo* Y[] = {
 };

 static FFModuleBaseInfo* Z[] = {
-    (FFModuleBaseInfo*) &instance.config.modules.zpool,
+    &ffZpoolModuleInfo,
    NULL,
 };

@@ -2,29 +2,23 @@

 #ifndef _WIN32
    #include <net/if.h>
-#else
-    #define IF_NAMESIZE 0
+    #include <netinet/in.h>
 #endif

-bool ffNetifGetDefaultRouteImpl(char iface[IF_NAMESIZE + 1], uint32_t* ifIndex);
-enum { IF_INDEX_UNINITIALIZED = (uint32_t) -1, IF_INDEX_INVALID = (uint32_t) -2 };
-static uint32_t ifIndex = IF_INDEX_UNINITIALIZED;
-static char ifName[IF_NAMESIZE + 1];
-
-static inline void init()
+const FFNetifDefaultRouteResult* ffNetifGetDefaultRouteV4(void)
 {
-    if (ifIndex == (uint32_t) IF_INDEX_UNINITIALIZED && !ffNetifGetDefaultRouteImpl(ifName, &ifIndex))
-        ifIndex = (uint32_t) IF_INDEX_INVALID;
+    static FFNetifDefaultRouteResult result;
+    if (result.status == FF_NETIF_UNINITIALIZED) {
+        result.status = ffNetifGetDefaultRouteImplV4(&result) ? FF_NETIF_OK : FF_NETIF_INVALID;
+    }
+    return &result;
 }

-const char* ffNetifGetDefaultRouteIfName()
+const FFNetifDefaultRouteResult* ffNetifGetDefaultRouteV6(void)
 {
-    init();
-    return ifName;
-}
-
-uint32_t ffNetifGetDefaultRouteIfIndex()
-{
-    init();
-    return ifIndex;
+    static FFNetifDefaultRouteResult result;
+    if (result.status == FF_NETIF_UNINITIALIZED) {
+        result.status = ffNetifGetDefaultRouteImplV6(&result) ? FF_NETIF_OK : FF_NETIF_INVALID;
+    }
+    return &result;
 }
@@ -3,7 +3,28 @@
 #include "fastfetch.h"

 #ifndef _WIN32
-const char* ffNetifGetDefaultRouteIfName();
+    #include <net/if.h>
+    #include <netinet/in.h>
 #endif

-uint32_t ffNetifGetDefaultRouteIfIndex();
+typedef enum __attribute__((__packed__)) FFNetifDefaultRouteResultStatus {
+    FF_NETIF_UNINITIALIZED,
+    FF_NETIF_INVALID,
+    FF_NETIF_OK
+} FFNetifDefaultRouteResultStatus;
+
+typedef struct FFNetifDefaultRouteResult {
+    uint32_t ifIndex;
+
+    #ifndef _WIN32
+    char ifName[IF_NAMESIZE + 1];
+    uint32_t preferredSourceAddrV4;
+    #endif
+    enum FFNetifDefaultRouteResultStatus status;
+} FFNetifDefaultRouteResult;
+
+bool ffNetifGetDefaultRouteImplV4(FFNetifDefaultRouteResult* result);
+bool ffNetifGetDefaultRouteImplV6(FFNetifDefaultRouteResult* result);
+
+const FFNetifDefaultRouteResult* ffNetifGetDefaultRouteV4(void);
+const FFNetifDefaultRouteResult* ffNetifGetDefaultRouteV6(void);
@@ -0,0 +1,201 @@
+#include "netif.h"
+
+#include "common/io/io.h"
+#include "util/mallocHelper.h"
+
+#include <net/if.h>
+#include <net/if_dl.h>
+#include <net/route.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+
+#define ROUNDUP2(a, n)       ((a) > 0 ? (1 + (((a) - 1U) | ((n) - 1))) : (n))
+
+#if __APPLE__
+    // https://github.com/apple-oss-distributions/network_cmds/blob/8f38231438e6a4d16ef8015e97e12c2c05105644/rtsol.tproj/if.c#L243
+    #define ROUNDUP(a)           ROUNDUP2((a), sizeof(uint32_t))
+#elif __sun
+    // https://github.com/illumos/illumos-gate/blob/95b8c88950fa7b19af46bc63230137cf96b0bff7/usr/src/cmd/cmd-inet/usr.sbin/route.c#L339
+    #define ROUNDUP(a)           ROUNDUP2((a), sizeof(long))
+#else
+    #error unknown platform
+#endif
+
+static struct sockaddr *
+get_rt_address(struct rt_msghdr *rtm, int desired)
+{
+    struct sockaddr *sa = (struct sockaddr *)(rtm + 1);
+
+    for (int i = 0; i < RTAX_MAX; i++)
+    {
+        if (rtm->rtm_addrs & (1 << i))
+        {
+            if ((1 << i) == desired)
+                return sa;
+
+            #ifndef __sun
+            uint32_t salen = sa->sa_len;
+            #else
+            uint32_t salen;
+            // https://github.com/illumos/illumos-gate/blob/95b8c88950fa7b19af46bc63230137cf96b0bff7/usr/src/cmd/cmd-inet/usr.sbin/route.c#L2941
+            switch (sa->sa_family) {
+            case AF_INET:
+                salen = sizeof (struct sockaddr_in);
+                break;
+            case AF_LINK:
+                salen = sizeof (struct sockaddr_dl);
+                break;
+            case AF_INET6:
+                salen = sizeof (struct sockaddr_in6);
+                break;
+            default:
+                salen = sizeof (struct sockaddr);
+                break;
+            }
+            #endif
+            sa = (struct sockaddr *)(ROUNDUP(salen) + (char *)sa);
+        }
+    }
+    return NULL;
+}
+
+bool ffNetifGetDefaultRouteImplV4(FFNetifDefaultRouteResult* result)
+{
+    //https://github.com/hashPirate/copenheimer-masscan-fork/blob/36f1ed9f7b751a7dccd5ed27874e2e703db7d481/src/rawsock-getif.c#L104
+
+    FF_AUTO_CLOSE_FD int pfRoute = socket(PF_ROUTE, SOCK_RAW, AF_INET);
+    if (pfRoute < 0)
+        return false;
+
+    {
+        struct timeval timeout = {1, 0};
+        setsockopt(pfRoute, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
+        setsockopt(pfRoute, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, sizeof(timeout));
+    }
+
+    int pid = getpid();
+
+    struct {
+        struct rt_msghdr hdr;
+        struct sockaddr_in dst;
+        uint8_t data[512];
+    } rtmsg = {
+        .hdr = {
+            .rtm_type = RTM_GET,
+            .rtm_flags = RTF_UP | RTF_GATEWAY,
+            .rtm_version = RTM_VERSION,
+            .rtm_addrs = RTA_DST | RTA_IFP | RTA_IFA,
+            .rtm_msglen = sizeof(rtmsg.hdr) + sizeof(rtmsg.dst),
+            .rtm_pid = pid,
+            .rtm_seq = 1,
+        },
+        .dst = {
+            .sin_family = AF_INET,
+            #ifndef __sun
+            .sin_len = sizeof(rtmsg.dst),
+            #endif
+        },
+    };
+
+    if (send(pfRoute, &rtmsg, rtmsg.hdr.rtm_msglen, 0) != rtmsg.hdr.rtm_msglen)
+        return false;
+
+    while (recv(pfRoute, &rtmsg, sizeof(rtmsg), 0) > 0 && !(rtmsg.hdr.rtm_seq == 1 && rtmsg.hdr.rtm_pid == pid))
+        ;
+
+    #ifndef __sun // On Solaris, the RTF_GATEWAY flag is not set for default routes for some reason
+    if ((rtmsg.hdr.rtm_flags & (RTF_UP | RTF_GATEWAY)) == (RTF_UP | RTF_GATEWAY))
+    #endif
+    {
+        struct sockaddr_dl* sdl = (struct sockaddr_dl *)get_rt_address(&rtmsg.hdr, RTA_IFP);
+        if (sdl
+            #ifndef __sun
+            && sdl->sdl_len
+            #endif
+        )
+        {
+            assert(sdl->sdl_nlen <= IF_NAMESIZE);
+            memcpy(result->ifName, sdl->sdl_data, sdl->sdl_nlen);
+            result->ifName[sdl->sdl_nlen] = '\0';
+            result->ifIndex = sdl->sdl_index;
+
+            // Get the preferred source address
+            struct sockaddr_in* src = (struct sockaddr_in*)get_rt_address(&rtmsg.hdr, RTA_IFA);
+            if (src && src->sin_family == AF_INET)
+                result->preferredSourceAddrV4 = src->sin_addr.s_addr;
+
+            return true;
+        }
+        return false;
+    }
+
+    return false;
+}
+
+bool ffNetifGetDefaultRouteImplV6(FFNetifDefaultRouteResult* result)
+{
+    //https://github.com/hashPirate/copenheimer-masscan-fork/blob/36f1ed9f7b751a7dccd5ed27874e2e703db7d481/src/rawsock-getif.c#L104
+
+    FF_AUTO_CLOSE_FD int pfRoute = socket(PF_ROUTE, SOCK_RAW, AF_INET6);
+    if (pfRoute < 0)
+        return false;
+
+    {
+        struct timeval timeout = {1, 0};
+        setsockopt(pfRoute, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
+        setsockopt(pfRoute, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, sizeof(timeout));
+    }
+
+    int pid = getpid();
+
+    struct {
+        struct rt_msghdr hdr;
+        struct sockaddr_in6 dst;
+        uint8_t data[512];
+    } rtmsg = {
+        .hdr = {
+            .rtm_type = RTM_GET,
+            .rtm_flags = RTF_UP | RTF_GATEWAY,
+            .rtm_version = RTM_VERSION,
+            .rtm_addrs = RTA_DST | RTA_IFP,
+            .rtm_msglen = sizeof(rtmsg.hdr) + sizeof(rtmsg.dst),
+            .rtm_pid = pid,
+            .rtm_seq = 2,
+        },
+        .dst = {
+            .sin6_family = AF_INET6,
+            #ifndef __sun
+            .sin6_len = sizeof(rtmsg.dst),
+            #endif
+        },
+    };
+
+    if (send(pfRoute, &rtmsg, rtmsg.hdr.rtm_msglen, 0) != rtmsg.hdr.rtm_msglen)
+        return false;
+
+    while (recv(pfRoute, &rtmsg, sizeof(rtmsg), 0) > 0 && !(rtmsg.hdr.rtm_seq == 2 && rtmsg.hdr.rtm_pid == pid))
+        ;
+
+    #ifndef __sun // On Solaris, the RTF_GATEWAY flag is not set for default routes for some reason
+    if ((rtmsg.hdr.rtm_flags & (RTF_UP | RTF_GATEWAY)) == (RTF_UP | RTF_GATEWAY))
+    #endif
+    {
+        struct sockaddr_dl* sdl = (struct sockaddr_dl *)get_rt_address(&rtmsg.hdr, RTA_IFP);
+        if (sdl
+            #ifndef __sun
+            && sdl->sdl_len
+            #endif
+        )
+        {
+            assert(sdl->sdl_nlen <= IF_NAMESIZE);
+            memcpy(result->ifName, sdl->sdl_data, sdl->sdl_nlen);
+            result->ifName[sdl->sdl_nlen] = '\0';
+            result->ifIndex = sdl->sdl_index;
+
+            return true;
+        }
+        return false;
+    }
+
+    return false;
+}
@@ -8,25 +8,24 @@
 #include <net/route.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
-
-#if defined(__OpenBSD__) || defined(__DragonFly__)
-    #include <sys/sysctl.h>
-#endif
+#include <sys/sysctl.h>

 #define ROUNDUP2(a, n)       ((a) > 0 ? (1 + (((a) - 1U) | ((n) - 1))) : (n))

-#if defined(__APPLE__)
-# define ROUNDUP(a)           ROUNDUP2((a), sizeof(int))
-#elif defined(__NetBSD__)
-# define ROUNDUP(a)           ROUNDUP2((a), sizeof(uint64_t))
-#elif defined(__FreeBSD__) || defined(__DragonFly__)
-# define ROUNDUP(a)           ROUNDUP2((a), sizeof(int))
-#elif defined(__OpenBSD__)
-# define ROUNDUP(a)           ROUNDUP2((a), sizeof(int))
-#elif defined(__sun)
-# define ROUNDUP(a)           ROUNDUP2((a), _SS_ALIGNSIZE)
+#if __DragonFly__
+    // https://github.com/DragonFlyBSD/DragonFlyBSD/blob/cf0aa2f1e47a3f0a6055fe427563cb3f3e627064/sys/net/route.h#L315C9-L315C19
+    #define ROUNDUP(a)           ROUNDUP2((a), sizeof(long))
+#elif __FreeBSD__
+    // https://github.com/freebsd/freebsd-src/blob/e4c0ecba44b20ebb2e4d80978c2cb6d16b730cb9/sys/net/route.h#L368C9-L368C16
+    #define ROUNDUP(a)           ROUNDUP2((a), sizeof(long))
+#elif __NetBSD__
+    // https://github.com/NetBSD/src/blob/29beb637d057520c0ed37ac2cde966f7cc0cadf4/sys/net/route.h#L330
+    #define ROUNDUP(a)           ROUNDUP2((a), sizeof(uint64_t))
+#elif __OpenBSD__
+    // https://github.com/openbsd/src/blob/ca647cfa4ec3ccb8360714bc0ebc32a394f7fb6a/regress/sys/netinet/bindconnect/bindconnect.c#L250
+    #define ROUNDUP(a)           ROUNDUP2((a), sizeof(long))
 #else
-# error unknown platform
+    #error unknown platform
 #endif

 static struct sockaddr *
@@ -40,23 +39,18 @@ get_rt_address(struct rt_msghdr *rtm, int desired)
        {
            if ((1 << i) == desired)
                return sa;
-#ifdef __sun
-            sa = (struct sockaddr *)(ROUNDUP(sizeof(struct sockaddr)) + (char *)sa);
-#else
            sa = (struct sockaddr *)(ROUNDUP(sa->sa_len) + (char *)sa);
-#endif
        }
    }
    return NULL;
 }

-bool ffNetifGetDefaultRouteImpl(char iface[IF_NAMESIZE + 1], uint32_t* ifIndex)
+bool ffNetifGetDefaultRouteImplV4(FFNetifDefaultRouteResult* result)
 {
-    #if defined(__OpenBSD__) || defined(__DragonFly__)
    int mib[6] = {CTL_NET, PF_ROUTE, 0, AF_INET, NET_RT_FLAGS, RTF_GATEWAY};
    size_t needed;

-    if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
+    if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0 || needed == 0)
        return false;

    FF_AUTO_FREE char* buf = malloc(needed);
@@ -71,80 +65,62 @@ bool ffNetifGetDefaultRouteImpl(char iface[IF_NAMESIZE + 1], uint32_t* ifIndex)
        rtm = (struct rt_msghdr *)next;
        struct sockaddr* sa = (struct sockaddr *)(rtm + 1);

-        if ((rtm->rtm_flags & RTF_GATEWAY) && (sa->sa_family == AF_INET))
+        if ((rtm->rtm_flags & RTF_GATEWAY) && !(rtm->rtm_flags & RTF_REJECT) && (sa->sa_family == AF_INET))
        {
            struct sockaddr_dl* sdl = (struct sockaddr_dl *)get_rt_address(rtm, RTA_IFP);
-            if (sdl->sdl_family == AF_LINK)
+            if (sdl && sdl->sdl_family == AF_LINK)
            {
                assert(sdl->sdl_nlen <= IF_NAMESIZE);
-                memcpy(iface, sdl->sdl_data, sdl->sdl_nlen);
-                iface[sdl->sdl_nlen] = '\0';
-                *ifIndex = sdl->sdl_index;
+                memcpy(result->ifName, sdl->sdl_data, sdl->sdl_nlen);
+                result->ifName[sdl->sdl_nlen] = '\0';
+                result->ifIndex = sdl->sdl_index;
+
+                // Get the preferred source address
+                struct sockaddr_in* src = (struct sockaddr_in*)get_rt_address(rtm, RTA_IFA);
+                if (src && src->sin_family == AF_INET)
+                    result->preferredSourceAddrV4 = src->sin_addr.s_addr;
+
                return true;
            }
        }
    }
-    #else
-    //https://github.com/hashPirate/copenheimer-masscan-fork/blob/36f1ed9f7b751a7dccd5ed27874e2e703db7d481/src/rawsock-getif.c#L104
+    return false;
+}

-    FF_AUTO_CLOSE_FD int pfRoute = socket(PF_ROUTE, SOCK_RAW, AF_INET);
-    if (pfRoute < 0)
+bool ffNetifGetDefaultRouteImplV6(FFNetifDefaultRouteResult* result)
+{
+    int mib[6] = {CTL_NET, PF_ROUTE, 0, AF_INET6, NET_RT_FLAGS, RTF_GATEWAY};
+    size_t needed;
+
+    if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0 || needed == 0)
        return false;

-    {
-        struct timeval timeout = {1, 0};
-        setsockopt(pfRoute, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
-        setsockopt(pfRoute, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, sizeof(timeout));
-    }
+    FF_AUTO_FREE char* buf = malloc(needed);

-    int pid = getpid();
-
-    struct {
-        struct rt_msghdr hdr;
-        struct sockaddr_in dst;
-        uint8_t data[512];
-    } rtmsg = {
-        .hdr = {
-            .rtm_type = RTM_GET,
-            .rtm_flags = RTF_UP | RTF_GATEWAY,
-            .rtm_version = RTM_VERSION,
-            .rtm_addrs = RTA_DST | RTA_IFP,
-            .rtm_msglen = sizeof(rtmsg.hdr) + sizeof(rtmsg.dst),
-            .rtm_pid = pid,
-            .rtm_seq = 1,
-        },
-        .dst = {
-            .sin_family = AF_INET,
-            #ifndef __sun
-            .sin_len = sizeof(rtmsg.dst),
-            #endif
-        },
-    };
-
-    if (write(pfRoute, &rtmsg, rtmsg.hdr.rtm_msglen) != rtmsg.hdr.rtm_msglen)
+    if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0)
        return false;

-    while (read(pfRoute, &rtmsg, sizeof(rtmsg)) > 0)
+    char* lim = buf + needed;
+    struct rt_msghdr* rtm;
+    for (char* next = buf; next < lim; next += rtm->rtm_msglen)
    {
-        if (rtmsg.hdr.rtm_seq == 1 && rtmsg.hdr.rtm_pid == pid)
+        rtm = (struct rt_msghdr *)next;
+        struct sockaddr* sa = (struct sockaddr *)(rtm + 1);
+
+        if ((rtm->rtm_flags & RTF_GATEWAY) && !(rtm->rtm_flags & RTF_REJECT) && (sa->sa_family == AF_INET6))
        {
-            struct sockaddr_dl* sdl = (struct sockaddr_dl *)get_rt_address(&rtmsg.hdr, RTA_IFP);
-            if (sdl
-                #ifndef __sun
-                && sdl->sdl_len
-                #endif
-            )
+            struct sockaddr_dl* sdl = (struct sockaddr_dl *)get_rt_address(rtm, RTA_IFP);
+            if (sdl && sdl->sdl_family == AF_LINK)
            {
                assert(sdl->sdl_nlen <= IF_NAMESIZE);
-                memcpy(iface, sdl->sdl_data, sdl->sdl_nlen);
-                iface[sdl->sdl_nlen] = '\0';
-                *ifIndex = sdl->sdl_index;
+                memcpy(result->ifName, sdl->sdl_data, sdl->sdl_nlen);
+                result->ifName[sdl->sdl_nlen] = '\0';
+                result->ifIndex = sdl->sdl_index;
+
                return true;
            }
-            return false;
        }
    }
-    #endif

    return false;
 }
@@ -0,0 +1,35 @@
+#include "netif.h"
+#include "common/io/io.h"
+
+#include <net/if.h>
+#include <stdio.h>
+
+#define FF_STR_INDIR(x) #x
+#define FF_STR(x) FF_STR_INDIR(x)
+
+bool ffNetifGetDefaultRouteImplV4(FFNetifDefaultRouteResult* result)
+{
+    FILE* FF_AUTO_CLOSE_FILE netRoute = fopen("/proc/route", "r");
+
+    if (!netRoute) return false;
+
+    // skip first line
+    FF_UNUSED(fscanf(netRoute, "%*[^\n]\n"));
+    unsigned long long destination; //, gateway, flags, refCount, use, metric, mask, mtu, ...
+    while (fscanf(netRoute, "%" FF_STR(IF_NAMESIZE) "s%llx%*[^\n]", result->ifName, &destination) == 2)
+    {
+        if (destination != 0) continue;
+        result->ifIndex = if_nametoindex(result->ifName);
+        // TODO: Get the preferred source address
+        return true;
+    }
+    result->ifName[0] = '0';
+    return false;
+}
+
+bool ffNetifGetDefaultRouteImplV6(FFNetifDefaultRouteResult* result)
+{
+    // TODO: AF_INET6
+    FF_UNUSED(result);
+    return false;
+}
@@ -11,9 +11,8 @@

 // loosely based on Haiku's src/bin/network/route/route.cpp

-bool ffNetifGetDefaultRouteImpl(char iface[IF_NAMESIZE + 1], uint32_t* ifIndex)
+bool ffNetifGetDefaultRouteImplV4(FFNetifDefaultRouteResult* result)
 {
-    // TODO: AF_INET6
    FF_AUTO_CLOSE_FD int pfRoute = socket(AF_INET, SOCK_RAW, AF_INET);
    if (pfRoute < 0)
        return false;
@@ -42,8 +41,11 @@ bool ffNetifGetDefaultRouteImpl(char iface[IF_NAMESIZE + 1], uint32_t* ifIndex)

    while (interface < end) {
        if (interface->ifr_route.flags & RTF_DEFAULT) {
-            strlcpy(iface, interface->ifr_name, IF_NAMESIZE);
-            *ifIndex = if_nametoindex(interface->ifr_name);
+            // interface->ifr_metric?
+            strlcpy(result->ifName, interface->ifr_name, IF_NAMESIZE);
+            result->ifIndex = if_nametoindex(interface->ifr_name);
+            if (interface->ifr_route.source)
+                result->preferredSourceAddrV4 = ((struct sockaddr_in*)interface->ifr_route.source)->sin_addr.s_addr;
            return true;
        }

@@ -55,9 +57,56 @@ bool ffNetifGetDefaultRouteImpl(char iface[IF_NAMESIZE + 1], uint32_t* ifIndex)
        if (interface->ifr_route.gateway != NULL)
            addressSize += interface->ifr_route.gateway->sa_len;

-        interface = (struct ifreq*)((addr_t)interface + IF_NAMESIZE
-            + sizeof(struct route_entry) + addressSize);
+        interface = (struct ifreq*)((addr_t)interface + IF_NAMESIZE + sizeof(struct route_entry) + addressSize);
    }

    return false;
 }
+
+bool ffNetifGetDefaultRouteImplV6(FFNetifDefaultRouteResult* result)
+{
+    FF_AUTO_CLOSE_FD int pfRoute = socket(AF_INET, SOCK_RAW, AF_INET6);
+    if (pfRoute < 0)
+        return false;
+
+    struct ifconf config;
+    config.ifc_len = sizeof(config.ifc_value);
+    if (ioctl(pfRoute, SIOCGRTSIZE, &config, sizeof(struct ifconf)) < 0)
+        return false;
+
+    int size = config.ifc_value;
+    if (size <= 0)
+        return false;
+
+    FF_AUTO_FREE void *buffer = malloc((size_t) size);
+    if (buffer == NULL) {
+        return false;
+    }
+
+    config.ifc_len = size;
+    config.ifc_buf = buffer;
+    if (ioctl(pfRoute, SIOCGRTTABLE, &config, sizeof(struct ifconf)) < 0)
+        return false;
+
+    struct ifreq *interface = (struct ifreq*)buffer;
+    struct ifreq *end = (struct ifreq*)((uint8_t*)buffer + size);
+
+    while (interface < end) {
+        if (interface->ifr_route.flags & RTF_DEFAULT) {
+            strlcpy(result->ifName, interface->ifr_name, IF_NAMESIZE);
+            result->ifIndex = if_nametoindex(interface->ifr_name);
+            return true;
+        }
+
+        size_t addressSize = 0;
+        if (interface->ifr_route.destination != NULL)
+            addressSize += interface->ifr_route.destination->sa_len;
+        if (interface->ifr_route.mask != NULL)
+            addressSize += interface->ifr_route.mask->sa_len;
+        if (interface->ifr_route.gateway != NULL)
+            addressSize += interface->ifr_route.gateway->sa_len;
+
+        interface = (struct ifreq*)((addr_t)interface + IF_NAMESIZE + sizeof(struct route_entry) + addressSize);
+    }
+    return false;
+}
@@ -1,52 +1,432 @@
 #include "netif.h"
 #include "common/io/io.h"
+#include "util/mallocHelper.h"
+#include "util/debug.h"

+#include <arpa/inet.h>
+#include <linux/rtnetlink.h>
 #include <net/if.h>
-#include <stdio.h>

-#define FF_STR_INDIR(x) #x
-#define FF_STR(x) FF_STR_INDIR(x)
-
-static bool getDefaultRouteIPv4(char iface[IF_NAMESIZE + 1], uint32_t* ifIndex)
+bool ffNetifGetDefaultRouteImplV4(FFNetifDefaultRouteResult* result)
 {
-    FILE* FF_AUTO_CLOSE_FILE netRoute = fopen("/proc/net/route", "r");
-    if (!netRoute) return false;
+    FF_DEBUG("Starting IPv4 default route detection");

-    // skip first line
-    FF_UNUSED(fscanf(netRoute, "%*[^\n]\n"));
-
-    unsigned long long destination; //, gateway, flags, refCount, use, metric, mask, mtu, ...
-    while (fscanf(netRoute, "%" FF_STR(IF_NAMESIZE) "s%llx%*[^\n]", iface, &destination) == 2)
+    FF_AUTO_CLOSE_FD int sock_fd = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, NETLINK_ROUTE);
+    if (sock_fd < 0)
    {
-        if (destination != 0) continue;
-        *ifIndex = if_nametoindex(iface);
+        FF_DEBUG("Failed to create netlink socket: %s", strerror(errno));
+        return false;
+    }
+    FF_DEBUG("Created netlink socket: fd=%d", sock_fd);
+
+    unsigned pid = (unsigned) getpid();
+    FF_DEBUG("Process PID: %u", pid);
+
+    // Bind socket
+    struct sockaddr_nl addr = {
+        .nl_family = AF_NETLINK,
+        .nl_pid = 0,         // Let kernel choose PID
+        .nl_groups = 0,      // No multicast groups
+    };
+
+    if (bind(sock_fd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
+        FF_DEBUG("Failed to bind socket: %s", strerror(errno));
+        return false;
+    }
+    FF_DEBUG("Successfully bound socket");
+
+    struct __attribute__((__packed__)) {
+        struct nlmsghdr nlh;
+        struct rtmsg rtm;
+        struct rtattr rta;
+        uint32_t table;
+    } req = {
+        // Netlink message header
+        .nlh = {
+            .nlmsg_len = sizeof(req),
+            .nlmsg_type = RTM_GETROUTE,
+            .nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP,
+            .nlmsg_seq = 1,
+            .nlmsg_pid = pid,
+        },
+        // Route message
+        .rtm = {
+            .rtm_family = AF_INET,
+            .rtm_dst_len = 0,  // Match all destinations
+            .rtm_src_len = 0,  // Match all sources
+            .rtm_tos = 0,
+            .rtm_table = RT_TABLE_UNSPEC,
+            .rtm_protocol = RTPROT_UNSPEC,
+            .rtm_scope = RT_SCOPE_UNIVERSE,
+            .rtm_type = RTN_UNSPEC,
+            .rtm_flags = 0,
+        },
+        // Route attribute for main table
+        .rta = {
+            .rta_len = RTA_LENGTH(sizeof(uint32_t)),
+            .rta_type = RTA_TABLE,
+        },
+        .table = RT_TABLE_MAIN,
+    };
+
+    struct sockaddr_nl dest_addr = {
+        .nl_family = AF_NETLINK,
+        .nl_pid = 0,         // Kernel
+        .nl_groups = 0,      // No multicast groups
+    };
+
+    ssize_t sent = sendto(sock_fd, &req, sizeof(req), 0,
+        (struct sockaddr*)&dest_addr, sizeof(dest_addr));
+
+    if (sent != sizeof(req)) {
+        FF_DEBUG("Failed to send netlink request: sent=%zd, expected=%zu", sent, sizeof(req));
+        return false;
+    }
+    FF_DEBUG("Sent netlink request: %zd bytes", sent);
+
+    struct sockaddr_nl src_addr = {};
+    socklen_t src_addr_len = sizeof(src_addr);
+
+    uint8_t buffer[1024 * 16]; // 16 KB buffer should be sufficient
+    uint32_t minMetric = UINT32_MAX;
+    int routeCount = 0;
+
+    while (true)
+    {
+        ssize_t received = recvfrom(sock_fd, buffer, sizeof(buffer), 0,
+            (struct sockaddr*)&src_addr, &src_addr_len);
+
+        if (received < 0) {
+            FF_DEBUG("Failed to receive netlink response: %s", strerror(errno));
+            return false;
+        }
+
+        if (received >= (ssize_t)sizeof(buffer)) {
+            FF_DEBUG("Received truncated message: received %zd, bufsize %zu", received, sizeof(buffer));
+            return false;
+        }
+        FF_DEBUG("Received netlink response: %zd bytes", received);
+        if (received == 0) {
+            FF_DEBUG("Received zero-length netlink response, ending processing");
+            break;
+        }
+
+        struct {
+            uint32_t metric;
+            uint32_t ifindex;
+            uint32_t prefsrc;
+        } entry;
+
+        for (const struct nlmsghdr* nlh = (struct nlmsghdr*)buffer;
+            NLMSG_OK(nlh, received);
+            nlh = NLMSG_NEXT(nlh, received))
+        {
+            if (nlh->nlmsg_seq != 1 || nlh->nlmsg_pid != pid)
+                continue;
+            if (nlh->nlmsg_type == NLMSG_DONE)
+            {
+                FF_DEBUG("Received NLMSG_DONE, processed %d routes", routeCount);
+                goto exit;
+            }
+
+            if (nlh->nlmsg_type == NLMSG_ERROR) {
+                FF_DEBUG("Netlink reports error: %s", strerror(-((struct nlmsgerr*)NLMSG_DATA(nlh))->error));
+                continue;
+            }
+
+            if (nlh->nlmsg_type != RTM_NEWROUTE) {
+                FF_DEBUG("Skipping non-route message: type=%d", nlh->nlmsg_type);
+                continue;
+            }
+
+            routeCount++;
+            struct rtmsg* rtm = (struct rtmsg*)NLMSG_DATA(nlh);
+            if (rtm->rtm_family != AF_INET) {
+                FF_DEBUG("Skipping non-IPv4 route #%d (family=%d)", routeCount, rtm->rtm_family);
+                continue;
+            }
+
+            if (rtm->rtm_dst_len != 0) {
+                FF_DEBUG("Skipping non-default route #%d (dst_len=%d)", routeCount, rtm->rtm_dst_len);
+                continue;
+            }
+
+            FF_DEBUG("Processing IPv4 default route candidate #%d", routeCount);
+            entry = (__typeof__(entry)) { }; // Default to zero metric (no RTA_PRIORITY found)
+
+            // Parse route attributes
+            size_t rtm_len = RTM_PAYLOAD(nlh);
+            for (struct rtattr* rta = RTM_RTA(rtm);
+                RTA_OK(rta, rtm_len);
+                rta = RTA_NEXT(rta, rtm_len))
+            {
+                if (RTA_PAYLOAD(rta) < sizeof(uint32_t))
+                    continue; // Skip invalid attributes
+
+                uint32_t rta_data = *(uint32_t*) RTA_DATA(rta);
+                switch (rta->rta_type) {
+                    case RTA_DST:
+                        FF_DEBUG("Unexpected RTA_DST: %s (len=%u)", inet_ntoa((struct in_addr) { .s_addr = rta_data }), rtm->rtm_dst_len);
+                        goto next;
+                    case RTA_OIF:
+                        entry.ifindex = rta_data;
+                        FF_DEBUG("Found interface index: %u", entry.ifindex);
+                        break;
+                    case RTA_GATEWAY:
+                        FF_DEBUG("Found gateway: %s", inet_ntoa(*(struct in_addr*)&rta_data));
+                        if (rta_data == 0) goto next;
+                        break;
+                    case RTA_PRIORITY:
+                        FF_DEBUG("Found metric: %u", rta_data);
+                        if (rta_data >= minMetric) goto next;
+                        entry.metric = rta_data;
+                        break;
+                    case RTA_PREFSRC:
+                        entry.prefsrc = rta_data;
+                        FF_DEBUG("Found preferred source: %s", inet_ntoa(*(struct in_addr*)&rta_data));
+                        break;
+                }
+            }
+
+            if (entry.ifindex == 0 || entry.metric >= minMetric)
+            {
+            next:
+                FF_DEBUG("Skipping route: ifindex=%u, metric=%u", entry.ifindex, entry.metric);
+                continue;
+            }
+            minMetric = entry.metric;
+            result->ifIndex = entry.ifindex;
+            FF_DEBUG("Updated best route: ifindex=%u, metric=%u, prefsrc=%x", entry.ifindex, entry.metric, entry.prefsrc);
+            result->preferredSourceAddrV4 = entry.prefsrc;
+            if (minMetric == 0)
+            {
+                FF_DEBUG("Found zero metric route, stopping further processing");
+                break; // Stop processing if we found a zero metric route
+            }
+        }
+    }
+
+exit:
+    if (minMetric < UINT32_MAX)
+    {
+        if_indextoname(result->ifIndex, result->ifName);
+        FF_DEBUG("Found default IPv4 route: interface=%s, index=%u, metric=%u", result->ifName, result->ifIndex, minMetric);
        return true;
    }
-    iface[0] = '\0';
+    FF_DEBUG("No IPv4 default route found");
    return false;
 }

-static bool getDefaultRouteIPv6(char iface[IF_NAMESIZE + 1], uint32_t* ifIndex)
+bool ffNetifGetDefaultRouteImplV6(FFNetifDefaultRouteResult* result)
 {
-    FILE* FF_AUTO_CLOSE_FILE netRoute = fopen("/proc/net/ipv6_route", "r");
-    if (!netRoute) return false;
+    FF_DEBUG("Starting IPv6 default route detection");

-    uint32_t prefixLen;
-    //destination, dest_prefix_len, source, src_prefix_len, next hop, metric, ref counter, use counter, flags, iface
-    while (fscanf(netRoute, "%*s %x %*s %*s %*s %*s %*s %*s %*s %" FF_STR(IF_NAMESIZE) "s", &prefixLen, iface) == 2)
+    FF_AUTO_CLOSE_FD int sock_fd = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, NETLINK_ROUTE);
+    if (sock_fd < 0)
    {
-        if (prefixLen != 0) continue;
-        *ifIndex = if_nametoindex(iface);
+        FF_DEBUG("Failed to create netlink socket: %s", strerror(errno));
+        return false;
+    }
+    FF_DEBUG("Created netlink socket: fd=%d", sock_fd);
+
+    unsigned pid = (unsigned) getpid();
+    FF_DEBUG("Process PID: %u", pid);
+
+    // Bind socket
+    struct sockaddr_nl addr = {
+        .nl_family = AF_NETLINK,
+        .nl_pid = 0,         // Let kernel choose PID
+        .nl_groups = 0,      // No multicast groups
+    };
+
+    if (bind(sock_fd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
+        FF_DEBUG("Failed to bind socket: %s", strerror(errno));
+        return false;
+    }
+    FF_DEBUG("Successfully bound socket");
+
+    struct __attribute__((__packed__)) {
+        struct nlmsghdr nlh;
+        struct rtmsg rtm;
+        struct rtattr rta;
+        uint32_t table;
+    } req = {
+        // Netlink message header
+        .nlh = {
+            .nlmsg_len = sizeof(req),
+            .nlmsg_type = RTM_GETROUTE,
+            .nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP,
+            .nlmsg_seq = 1,
+            .nlmsg_pid = pid,
+        },
+        // Route message
+        .rtm = {
+            .rtm_family = AF_INET6,    // IPv6 instead of IPv4
+            .rtm_dst_len = 0,  // Match all destinations
+            .rtm_src_len = 0,  // Match all sources
+            .rtm_tos = 0,
+            .rtm_table = RT_TABLE_UNSPEC,
+            .rtm_protocol = RTPROT_UNSPEC,
+            .rtm_scope = RT_SCOPE_UNIVERSE,
+            .rtm_type = RTN_UNSPEC,
+            .rtm_flags = 0,
+        },
+        // Route attribute for main table
+        .rta = {
+            .rta_len = RTA_LENGTH(sizeof(uint32_t)),
+            .rta_type = RTA_TABLE,
+        },
+        .table = RT_TABLE_MAIN,
+    };
+
+    struct sockaddr_nl dest_addr = {
+        .nl_family = AF_NETLINK,
+        .nl_pid = 0,         // Kernel
+        .nl_groups = 0,      // No multicast groups
+    };
+
+    ssize_t sent = sendto(sock_fd, &req, sizeof(req), 0,
+        (struct sockaddr*)&dest_addr, sizeof(dest_addr));
+
+    if (sent != sizeof(req)) {
+        FF_DEBUG("Failed to send netlink request: sent=%zd, expected=%zu", sent, sizeof(req));
+        return false;
+    }
+    FF_DEBUG("Sent netlink request: %zd bytes", sent);
+
+    struct sockaddr_nl src_addr = {};
+    socklen_t src_addr_len = sizeof(src_addr);
+
+    uint8_t buffer[1024 * 16]; // 16 KB buffer should be sufficient
+    uint32_t minMetric = UINT32_MAX;
+    int routeCount = 0;
+
+    while (true)
+    {
+        ssize_t received = recvfrom(sock_fd, buffer, sizeof(buffer), 0,
+            (struct sockaddr*)&src_addr, &src_addr_len);
+
+        if (received < 0) {
+            FF_DEBUG("Failed to receive netlink response: %s", strerror(errno));
+            return false;
+        }
+
+        if (received >= (ssize_t)sizeof(buffer)) {
+            FF_DEBUG("Received truncated message: received %zd, bufsize %zu", received, sizeof(buffer));
+            return false;
+        }
+        FF_DEBUG("Received netlink response: %zd bytes", received);
+        if (received == 0) {
+            FF_DEBUG("Received zero-length netlink response, ending processing");
+            break;
+        }
+
+        struct {
+            uint32_t metric;
+            uint32_t ifindex;
+        } entry;
+
+        for (const struct nlmsghdr* nlh = (struct nlmsghdr*)buffer;
+            NLMSG_OK(nlh, received);
+            nlh = NLMSG_NEXT(nlh, received))
+        {
+            if (nlh->nlmsg_seq != 1 || nlh->nlmsg_pid != pid)
+                continue;
+            if (nlh->nlmsg_type == NLMSG_DONE)
+            {
+                FF_DEBUG("Received NLMSG_DONE, processed %d routes", routeCount);
+                goto exit;
+            }
+
+            if (nlh->nlmsg_type == NLMSG_ERROR) {
+                FF_DEBUG("Netlink reports error: %s", strerror(-((struct nlmsgerr*)NLMSG_DATA(nlh))->error));
+                continue;
+            }
+
+            if (nlh->nlmsg_type != RTM_NEWROUTE) {
+                FF_DEBUG("Skipping non-route message: type=%d", nlh->nlmsg_type);
+                continue;
+            }
+
+            routeCount++;
+            struct rtmsg* rtm = (struct rtmsg*)NLMSG_DATA(nlh);
+            if (rtm->rtm_family != AF_INET6) {
+                FF_DEBUG("Skipping non-IPv6 route #%d (family=%d)", routeCount, rtm->rtm_family);
+                continue;
+            }
+
+            if (rtm->rtm_dst_len != 0) {
+                FF_DEBUG("Skipping non-default route #%d (dst_len=%d)", routeCount, rtm->rtm_dst_len);
+                continue;
+            }
+
+            FF_DEBUG("Processing IPv6 default route candidate #%d", routeCount);
+            entry = (__typeof__(entry)) { }; // Default to zero metric (no RTA_PRIORITY found)
+
+            // Parse route attributes
+            size_t rtm_len = RTM_PAYLOAD(nlh);
+            for (struct rtattr* rta = RTM_RTA(rtm);
+                RTA_OK(rta, rtm_len);
+                rta = RTA_NEXT(rta, rtm_len))
+            {
+                switch (rta->rta_type) {
+                    case RTA_DST:
+                        if (RTA_PAYLOAD(rta) >= sizeof(struct in6_addr)) {
+                            FF_MAYBE_UNUSED char str[INET6_ADDRSTRLEN];
+                            FF_DEBUG("Unexpected RTA_DST: %s", inet_ntop(AF_INET6, RTA_DATA(rta), str, sizeof(str)));
+                            goto next;
+                        }
+                        break;
+                    case RTA_OIF:
+                        if (RTA_PAYLOAD(rta) >= sizeof(uint32_t)) {
+                            entry.ifindex = *(uint32_t*) RTA_DATA(rta);
+                            FF_DEBUG("Found interface index: %u", entry.ifindex);
+                        }
+                        break;
+                    case RTA_GATEWAY:
+                        if (RTA_PAYLOAD(rta) >= sizeof(struct in6_addr)) {
+                            struct in6_addr* gw = (struct in6_addr*) RTA_DATA(rta);
+                            if (IN6_IS_ADDR_UNSPECIFIED(gw)) goto next;
+                            FF_MAYBE_UNUSED char str[INET6_ADDRSTRLEN];
+                            FF_DEBUG("Found gateway: %s", inet_ntop(AF_INET6, gw, str, sizeof(str)));
+                        }
+                        break;
+                    case RTA_PRIORITY:
+                        if (RTA_PAYLOAD(rta) >= sizeof(uint32_t)) {
+                            uint32_t metric = *(uint32_t*) RTA_DATA(rta);
+                            FF_DEBUG("Found metric: %u", metric);
+                            if (metric >= minMetric) goto next;
+                            entry.metric = metric;
+                        }
+                        break;
+                }
+            }
+
+            if (entry.ifindex == 0 || entry.metric >= minMetric)
+            {
+            next:
+                FF_DEBUG("Skipping route: ifindex=%u, metric=%u", entry.ifindex, entry.metric);
+                continue;
+            }
+            minMetric = entry.metric;
+            result->ifIndex = entry.ifindex;
+            FF_DEBUG("Updated best route: ifindex=%u, metric=%u", entry.ifindex, entry.metric);
+
+            if (minMetric == 0)
+            {
+                FF_DEBUG("Found zero metric route, stopping further processing");
+                break; // Stop processing if we found a zero metric route
+            }
+        }
+    }
+
+exit:
+    if (minMetric < UINT32_MAX)
+    {
+        if_indextoname(result->ifIndex, result->ifName);
+        FF_DEBUG("Found default IPv6 route: interface=%s, index=%u, metric=%u", result->ifName, result->ifIndex, minMetric);
        return true;
    }
-    iface[0] = '\0';
+    FF_DEBUG("No IPv6 default route found");
    return false;
 }
-
-bool ffNetifGetDefaultRouteImpl(char iface[IF_NAMESIZE + 1], uint32_t* ifIndex)
-{
-    if (getDefaultRouteIPv4(iface, ifIndex))
-        return true;
-
-    return getDefaultRouteIPv6(iface, ifIndex);
-}
@@ -4,29 +4,96 @@
 #include <ws2tcpip.h> // AF_INET6, IN6_IS_ADDR_UNSPECIFIED
 #include <iphlpapi.h>

-bool ffNetifGetDefaultRouteImpl(FF_MAYBE_UNUSED char iface[IF_NAMESIZE + 1], uint32_t* ifIndex)
+bool ffNetifGetDefaultRouteImplV4(FFNetifDefaultRouteResult* result)
 {
    PMIB_IPFORWARD_TABLE2 pIpForwardTable = NULL;
-    DWORD result = GetIpForwardTable2(AF_UNSPEC, &pIpForwardTable);

-    if (result != NO_ERROR)
+    if (!NETIO_SUCCESS(GetIpForwardTable2(AF_UNSPEC, &pIpForwardTable)))
        return false;

    bool foundDefault = false;
+    uint32_t smallestMetric = UINT32_MAX;

    for (ULONG i = 0; i < pIpForwardTable->NumEntries; ++i)
    {
        MIB_IPFORWARD_ROW2* row = &pIpForwardTable->Table[i];

-        if ((row->DestinationPrefix.PrefixLength == 0) &&
-            ((row->DestinationPrefix.Prefix.Ipv4.sin_family == AF_INET &&
-              row->DestinationPrefix.Prefix.Ipv4.sin_addr.S_un.S_addr == 0) ||
-             (row->DestinationPrefix.Prefix.Ipv6.sin6_family == AF_INET6 &&
-              IN6_IS_ADDR_UNSPECIFIED(&row->DestinationPrefix.Prefix.Ipv6.sin6_addr))))
+        if (row->DestinationPrefix.PrefixLength == 0 &&
+            row->DestinationPrefix.Prefix.Ipv4.sin_family == AF_INET &&
+            row->DestinationPrefix.Prefix.Ipv4.sin_addr.S_un.S_addr == 0)
        {
-            *ifIndex = row->InterfaceIndex;
-            foundDefault = true;
-            break;
+            MIB_IF_ROW2 ifRow = {
+                .InterfaceIndex = row->InterfaceIndex,
+            };
+            if (NETIO_SUCCESS(GetIfEntry2(&ifRow)) && ifRow.OperStatus == IfOperStatusUp)
+            {
+                MIB_IPINTERFACE_ROW ipInterfaceRow = {
+                    .Family = AF_INET,
+                    .InterfaceIndex = row->InterfaceIndex,
+                };
+
+                uint32_t realMetric = row->Metric /* Metric offset */;
+
+                if (NETIO_SUCCESS(GetIpInterfaceEntry(&ipInterfaceRow)))
+                    realMetric += ipInterfaceRow.Metric /* Interface metric */;
+
+                if (realMetric < smallestMetric)
+                {
+                    smallestMetric = realMetric;
+                    result->ifIndex = row->InterfaceIndex;
+                    foundDefault = true;
+                    break;
+                }
+            }
+        }
+    }
+
+    FreeMibTable(pIpForwardTable);
+
+    return foundDefault;
+}
+
+
+bool ffNetifGetDefaultRouteImplV6(FFNetifDefaultRouteResult* result)
+{
+    PMIB_IPFORWARD_TABLE2 pIpForwardTable = NULL;
+
+    if (!NETIO_SUCCESS(GetIpForwardTable2(AF_UNSPEC, &pIpForwardTable)))
+        return false;
+
+    bool foundDefault = false;
+    uint32_t smallestMetric = UINT32_MAX;
+
+    for (ULONG i = 0; i < pIpForwardTable->NumEntries; ++i)
+    {
+        MIB_IPFORWARD_ROW2* row = &pIpForwardTable->Table[i];
+
+        if (row->DestinationPrefix.PrefixLength == 0 &&
+            row->DestinationPrefix.Prefix.Ipv6.sin6_family == AF_INET6 &&
+            IN6_IS_ADDR_UNSPECIFIED(&row->DestinationPrefix.Prefix.Ipv6.sin6_addr))
+        {
+            MIB_IF_ROW2 ifRow = {
+                .InterfaceIndex = row->InterfaceIndex,
+            };
+            if (NETIO_SUCCESS(GetIfEntry2(&ifRow)) && ifRow.OperStatus == IfOperStatusUp)
+            {
+                MIB_IPINTERFACE_ROW ipInterfaceRow = {
+                    .Family = AF_INET6,
+                    .InterfaceIndex = row->InterfaceIndex,
+                };
+
+                uint32_t realMetric = row->Metric /* Metric offset */;
+
+                if (NETIO_SUCCESS(GetIpInterfaceEntry(&ipInterfaceRow)))
+                    realMetric += ipInterfaceRow.Metric /* Interface metric */;
+
+                if (realMetric < smallestMetric)
+                {
+                    smallestMetric = realMetric;
+                    result->ifIndex = row->InterfaceIndex;
+                    foundDefault = true;
+                }
+            }
        }
    }

@@ -7,7 +7,7 @@
 #include "util/debug.h"

 #include <unistd.h>
-#include <sys/poll.h>
+#include <poll.h>
 #include <sys/time.h>
 #include <sys/socket.h>
 #include <netdb.h>
@@ -22,7 +22,7 @@ static const char* tryNonThreadingFastPath(FFNetworkingState* state)

        if (!state->tfo)
        {
-            #ifdef __linux__
+            #if __linux__ || __GNU__
            // Linux doesn't support sendto() on unconnected sockets
            FF_DEBUG("TCP Fast Open disabled, skipping");
            return "TCP Fast Open disabled";
@@ -34,7 +34,7 @@ static const char* tryNonThreadingFastPath(FFNetworkingState* state)

            #ifndef __APPLE__ // On macOS, TCP_FASTOPEN doesn't seem to be needed
            // Set TCP Fast Open
-            #ifdef __linux__
+            #if __linux__ || __GNU__
            int flag = 5; // the queue length of pending packets
            #else
            int flag = 1; // enable TCP Fast Open
@@ -50,7 +50,7 @@ static const char* tryNonThreadingFastPath(FFNetworkingState* state)
                FF_DEBUG("Failed to set TCP_FASTOPEN option: %s", strerror(errno));
                return "setsockopt(TCP_FASTOPEN) failed";
            } else {
-                #ifdef __linux__
+                #if __linux__ || __GNU__
                FF_DEBUG("Successfully set TCP_FASTOPEN option, queue length: %d", flag);
                #elif defined(__APPLE__)
                FF_DEBUG("Successfully set TCP_FASTOPEN_FORCE_ENABLE option");
@@ -346,7 +346,7 @@ const char* ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* ho
        FF_DEBUG("Multithreading mode enabled, creating connection thread");
        state->thread = ffThreadCreate(connectAndSendThreadMain, state);
        if (state->thread) {
-            FF_DEBUG("Thread creation successful: thread=%p", (void*)state->thread);
+            FF_DEBUG("Thread creation successful: thread=%p", (void*)(uintptr_t)state->thread);
            return NULL;
        }
        FF_DEBUG("Thread creation failed");
@@ -28,55 +28,6 @@ const char* ffOptionTestPrefix(const char* argumentKey, const char* moduleName)
    return subKey;
 }

-bool ffOptionParseModuleArgs(const char* argumentKey, const char* subKey, const char* value, FFModuleArgs* result)
-{
-    if(ffStrEqualsIgnCase(subKey, "key"))
-    {
-        ffOptionParseString(argumentKey, value, &result->key);
-        return true;
-    }
-    else if(ffStrEqualsIgnCase(subKey, "format"))
-    {
-        ffOptionParseString(argumentKey, value, &result->outputFormat);
-        return true;
-    }
-    else if(ffStrEqualsIgnCase(subKey, "output-color"))
-    {
-        if(value == NULL)
-        {
-            fprintf(stderr, "Error: usage: %s <str>\n", argumentKey);
-            exit(477);
-        }
-        ffOptionParseColor(value, &result->outputColor);
-        return true;
-    }
-    else if(ffStrStartsWithIgnCase(subKey, "key-"))
-    {
-        const char* subKey2 = subKey + strlen("key-");
-        if(ffStrEqualsIgnCase(subKey2, "color"))
-        {
-            if(value == NULL)
-            {
-                fprintf(stderr, "Error: usage: %s <str>\n", argumentKey);
-                exit(477);
-            }
-            ffOptionParseColor(value, &result->keyColor);
-            return true;
-        }
-        else if(ffStrEqualsIgnCase(subKey2, "width"))
-        {
-            result->keyWidth = ffOptionParseUInt32(argumentKey, value);
-            return true;
-        }
-        else if(ffStrEqualsIgnCase(subKey2, "icon"))
-        {
-            ffOptionParseString(argumentKey, value, &result->keyIcon);
-            return true;
-        }
-    }
-    return false;
-}
-
 void ffOptionParseString(const char* argumentKey, const char* value, FFstrbuf* buffer)
 {
    if(value == NULL)
@@ -157,6 +108,8 @@ bool ffOptionParseBoolean(const char* str)

 void ffOptionParseColorNoClear(const char* value, FFstrbuf* buffer)
 {
+    if (!value || value[0] == '\0') return;
+
    // If value is already an ANSI escape code, use it
    if (value[0] == '\e' && value[1] == '[')
    {
@@ -177,6 +130,7 @@ void ffOptionParseColorNoClear(const char* value, FFstrbuf* buffer)
        if (ffCharIsEnglishAlphabet(value[0]))
        {
            FF_APPEND_COLOR_CODE_COND(reset_, FF_COLOR_MODE_RESET)
+            else FF_APPEND_COLOR_CODE_COND(bold_, FF_COLOR_MODE_BOLD)
            else FF_APPEND_COLOR_CODE_COND(bright_, FF_COLOR_MODE_BOLD)
            else FF_APPEND_COLOR_CODE_COND(dim_, FF_COLOR_MODE_DIM)
            else FF_APPEND_COLOR_CODE_COND(italic_, FF_COLOR_MODE_ITALIC)
@@ -212,6 +166,35 @@ void ffOptionParseColorNoClear(const char* value, FFstrbuf* buffer)
                exit(479);
            }
        }
+        else if (value[0] == '#')
+        {
+            // RGB color
+            ++value;
+            char* pend = NULL;
+            uint32_t rgb = (uint32_t) strtoul(value, &pend, 16);
+            if (pend == value) {
+                fprintf(stderr, "Error: invalid RGB color code found: %s\n", value);
+                exit(479);
+            }
+            if (pend - value > 6) {
+                fprintf(stderr, "Error: RGB color code too long: %s\n", value);
+                exit(479);
+            }
+            else if (pend - value == 3) {
+                rgb = ((rgb & 0xF00) >> 8) * 0x110000 +
+                      ((rgb & 0x0F0) >> 4) * 0x001100 +
+                      ((rgb & 0x00F) >> 0) * 0x000011;
+            }
+            else if (pend - value != 6) {
+                fprintf(stderr, "Error: invalid RGB color code length: %s\n", value);
+                exit(479);
+            }
+
+            uint32_t r = rgb >> 16, g = (rgb >> 8) & 0xFF, b = rgb & 0xFF;
+            ffStrbufAppendF(buffer, FF_COLOR_FG_RGB "%u;%u;%u", r, g, b);
+            value = pend;
+            continue;
+        }
        ffStrbufAppendC(buffer, *value);
        ++value;

@@ -29,10 +29,12 @@ typedef struct FFModuleBaseInfo
    // This is UB, because `void*` is not compatible with `FF*Options*`.
    // However we can't do it better unless we move to C++, so that `option` becomes a `this` pointer
    // https://stackoverflow.com/questions/559581/casting-a-function-pointer-to-another-type
-    bool (*parseCommandOptions)(void* options, const char* key, const char* value);
+
+    void (*initOptions)(void* options);
+    void (*destroyOptions)(void* options);
    void (*parseJsonObject)(void* options, struct yyjson_val *module);
-    void (*printModule)(void* options);
-    void (*generateJsonResult)(void* options, struct yyjson_mut_doc* doc, struct yyjson_mut_val* module);
+    bool (*printModule)(void* options); // true on success
+    bool (*generateJsonResult)(void* options, struct yyjson_mut_doc* doc, struct yyjson_mut_val* module); // true on success
    void (*generateJsonConfig)(void* options, struct yyjson_mut_doc* doc, struct yyjson_mut_val* obj);
    FFModuleFormatArgList formatArgs;
 } FFModuleBaseInfo;
@@ -63,7 +65,6 @@ typedef struct FFKeyValuePair
 } FFKeyValuePair;

 const char* ffOptionTestPrefix(const char* argumentKey, const char* moduleName);
-bool ffOptionParseModuleArgs(const char* argumentKey, const char* pkey, const char* value, FFModuleArgs* result);
 void ffOptionParseString(const char* argumentKey, const char* value, FFstrbuf* buffer);
 FF_C_NODISCARD uint32_t ffOptionParseUInt32(const char* argumentKey, const char* value);
 FF_C_NODISCARD int32_t ffOptionParseInt32(const char* argumentKey, const char* value);
@@ -94,3 +95,5 @@ static inline void ffOptionDestroyModuleArg(FFModuleArgs* args)
    ffStrbufDestroy(&args->outputFormat);
    ffStrbufDestroy(&args->outputColor);
 }
+
+enum { FF_OPTION_MAX_SIZE = 1 << 8 }; // Maximum size of a single option value, used for static allocation
@@ -2,7 +2,6 @@
 #include "common/parsing.h"

 #include <ctype.h>
-#include <inttypes.h>

 #ifdef _WIN32
    #pragma GCC diagnostic push
@@ -51,63 +50,21 @@ int8_t ffVersionCompare(const FFVersion* version1, const FFVersion* version2)
 void ffVersionToPretty(const FFVersion* version, FFstrbuf* pretty)
 {
    if(version->major > 0 || version->minor > 0 || version->patch > 0)
-        ffStrbufAppendF(pretty, "%u", version->major);
+    {
+        ffStrbufAppendUInt(pretty, version->major);
+    }

    if(version->minor > 0 || version->patch > 0)
-        ffStrbufAppendF(pretty, ".%u", version->minor);
+    {
+        ffStrbufAppendC(pretty, '.');
+        ffStrbufAppendUInt(pretty, version->minor);
+    }

    if(version->patch > 0)
-        ffStrbufAppendF(pretty, ".%u", version->patch);
-}
-
-static void parseSize(FFstrbuf* result, uint64_t bytes, uint32_t base, const char** prefixes)
-{
-    double size = (double) bytes;
-    uint8_t counter = 0;
-
-    while(size >= base && counter < instance.config.display.sizeMaxPrefix && prefixes[counter + 1])
    {
-        size /= base;
-        counter++;
+        ffStrbufAppendC(pretty, '.');
+        ffStrbufAppendUInt(pretty, version->patch);
    }
-
-    if(counter == 0)
-        ffStrbufAppendF(result, "%" PRIu64 " %s", bytes, prefixes[0]);
-    else
-        ffStrbufAppendF(result, "%.*f %s", instance.config.display.sizeNdigits, size, prefixes[counter]);
-}
-
-void ffParseSize(uint64_t bytes, FFstrbuf* result)
-{
-    switch (instance.config.display.sizeBinaryPrefix)
-    {
-        case FF_SIZE_BINARY_PREFIX_TYPE_IEC:
-            parseSize(result, bytes, 1024, (const char*[]) {"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB", NULL});
-            break;
-        case FF_SIZE_BINARY_PREFIX_TYPE_SI:
-            parseSize(result, bytes, 1000, (const char*[]) {"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB", NULL});
-            break;
-        case FF_SIZE_BINARY_PREFIX_TYPE_JEDEC:
-            parseSize(result, bytes, 1024, (const char*[]) {"B", "KB", "MB", "GB", "TB", NULL});
-            break;
-        default:
-            parseSize(result, bytes, 1024, (const char*[]) {"B", NULL});
-            break;
-    }
-}
-
-bool ffParseFrequency(uint32_t mhz, FFstrbuf* result)
-{
-    if (mhz == 0)
-        return false;
-
-    int8_t ndigits = instance.config.display.freqNdigits;
-
-    if (ndigits >= 0)
-        ffStrbufAppendF(result, "%.*f GHz", ndigits, mhz / 1000.);
-    else
-        ffStrbufAppendF(result, "%u MHz", (unsigned) mhz);
-    return true;
 }

 void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, const FFstrbuf* gtk4)
@@ -190,54 +147,6 @@ void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, co
    }
 }

-void ffParseDuration(uint32_t days, uint32_t hours, uint32_t minutes, uint32_t seconds, FFstrbuf* result)
-{
-    if(days == 0 && hours == 0 && minutes == 0)
-    {
-        ffStrbufAppendF(result, "%u seconds", seconds);
-        return;
-    }
-
-    if(seconds >= 30)
-    {
-        minutes++;
-        seconds = 0;
-    }
-
-    if(days > 0)
-    {
-        ffStrbufAppendF(result, "%u day", days);
-
-        if(days > 1)
-            ffStrbufAppendC(result, 's');
-
-        if(days >= 100)
-            ffStrbufAppendS(result, "(!)");
-
-        if(hours > 0 || minutes > 0)
-            ffStrbufAppendS(result, ", ");
-    }
-
-    if(hours > 0)
-    {
-        ffStrbufAppendF(result, "%u hour", hours);
-
-        if(hours > 1)
-            ffStrbufAppendC(result, 's');
-
-        if(minutes > 0)
-            ffStrbufAppendS(result, ", ");
-    }
-
-    if(minutes > 0)
-    {
-        ffStrbufAppendF(result, "%u min", minutes);
-
-        if(minutes > 1)
-            ffStrbufAppendC(result, 's');
-    }
-}
-
 #ifdef _WIN32
    #pragma GCC diagnostic pop
 #endif
@@ -24,7 +24,3 @@ void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, co

 void ffVersionToPretty(const FFVersion* version, FFstrbuf* pretty);
 int8_t ffVersionCompare(const FFVersion* version1, const FFVersion* version2);
-
-void ffParseSize(uint64_t bytes, FFstrbuf* result);
-bool ffParseFrequency(uint32_t mhz, FFstrbuf* result);
-void ffParseDuration(uint32_t days, uint32_t hours, uint32_t minutes, uint32_t seconds, FFstrbuf* result);
@@ -60,23 +60,32 @@ void ffPercentAppendBar(FFstrbuf* buffer, double percent, FFPercentageModuleConf

    const FFOptionsDisplay* options = &instance.config.display;

-    uint32_t blocksPercent = (uint32_t) (percent / 100.0 * options->barWidth + 0.5);
+    const bool borderAsValue = options->barBorderLeftElapsed.length && options->barBorderRightElapsed.length;
+
+    uint8_t blocksPercent = (uint8_t) (percent / 100.0 * options->barWidth + 0.5);
    assert(blocksPercent <= options->barWidth);

-    if(options->barBorderLeft.length)
+    if(!borderAsValue && options->barBorderLeft.length)
    {
-        if(!options->pipe)
-            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m");
+        if(!options->pipe && options->barColorBorder.length > 0)
+            ffStrbufAppendF(buffer, "\e[%sm", options->barColorBorder.chars);
        ffStrbufAppend(buffer, &options->barBorderLeft);
    }

-    if (percent != percent)
+    if (percent == -DBL_MAX)
    {
-        if(!options->pipe)
+        // Use total color for simplification
+        if(!options->pipe && options->barColorTotal.length > 0)
            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_BLACK "m");

-        for (uint32_t i = 0; i < options->barWidth; ++i)
-            ffStrbufAppend(buffer, &options->barCharElapsed);
+        for (uint8_t i = 0; i < options->barWidth; ++i)
+        {
+            ffStrbufAppend(buffer, borderAsValue && i == 0
+                ? &options->barBorderLeft
+                : borderAsValue && i == options->barWidth - 1
+                    ? &options->barBorderRight
+                    : &options->barCharTotal);
+        }
    }
    else
    {
@@ -85,61 +94,72 @@ void ffPercentAppendBar(FFstrbuf* buffer, double percent, FFPercentageModuleConf
        const char* colorRed = options->percentColorRed.chars;

        FFPercentageTypeFlags percentType = config.type == 0 ? options->percentType : config.type;
-        bool monochrome = !!(percentType & FF_PERCENTAGE_TYPE_BAR_MONOCHROME_BIT);

-        for (uint32_t i = 0; i < blocksPercent; ++i)
+        bool autoColorElapsed = ffStrbufIgnCaseEqualS(&options->barColorElapsed, "auto");
+
+        bool monochrome = (percentType & FF_PERCENTAGE_TYPE_BAR_MONOCHROME_BIT) || !autoColorElapsed;
+        if (!options->pipe && options->barColorElapsed.length > 0 && monochrome)
        {
-            if(!options->pipe)
+            const char* color = NULL;
+            if (!autoColorElapsed)
+                color = options->barColorElapsed.chars;
+            else if (green <= yellow)
            {
-                if (monochrome)
-                {
-                    const char* color = NULL;
-                    if (green <= yellow)
-                    {
-                        if (percent < green) color = colorGreen;
-                        else if (percent < yellow) color = colorYellow;
-                        else color = colorRed;
-                    }
-                    else
-                    {
-                        if (percent < yellow) color = colorRed;
-                        else if (percent < green) color = colorYellow;
-                        else color = colorGreen;
-                    }
-                    ffStrbufAppendF(buffer, "\e[%sm", color);
-                }
-                else
-                {
-                    uint32_t section1Begin = (uint32_t) ((green <= yellow ? green : yellow) / 100.0 * options->barWidth + 0.5);
-                    uint32_t section2Begin = (uint32_t) ((green > yellow ? green : yellow) / 100.0 * options->barWidth + 0.5);
-                    if (i == section2Begin)
-                        ffStrbufAppendF(buffer, "\e[%sm", (green > yellow ? colorGreen : colorRed));
-                    else if (i == section1Begin)
-                        ffStrbufAppendF(buffer, "\e[%sm", colorYellow);
-                    else if (i == 0)
-                        ffStrbufAppendF(buffer, "\e[%sm", (green <= yellow ? colorGreen : colorRed));
-                }
+                if (percent < green) color = colorGreen;
+                else if (percent < yellow) color = colorYellow;
+                else color = colorRed;
            }
-            ffStrbufAppend(buffer, &options->barCharElapsed);
+            else
+            {
+                if (percent < yellow) color = colorRed;
+                else if (percent < green) color = colorYellow;
+                else color = colorGreen;
+            }
+            ffStrbufAppendF(buffer, "\e[%sm", color);
+        }
+        for (uint8_t i = 0; i < blocksPercent; ++i)
+        {
+            if (!options->pipe && options->barColorElapsed.length > 0 && !monochrome)
+            {
+                uint32_t section1Begin = (uint32_t) ((green <= yellow ? green : yellow) / 100.0 * options->barWidth + 0.5);
+                uint32_t section2Begin = (uint32_t) ((green > yellow ? green : yellow) / 100.0 * options->barWidth + 0.5);
+                if (i == section2Begin)
+                    ffStrbufAppendF(buffer, "\e[%sm", (green > yellow ? colorGreen : colorRed));
+                else if (i == section1Begin)
+                    ffStrbufAppendF(buffer, "\e[%sm", colorYellow);
+                else if (i == 0)
+                    ffStrbufAppendF(buffer, "\e[%sm", (green <= yellow ? colorGreen : colorRed));
+            }
+            ffStrbufAppend(buffer, borderAsValue && i == 0
+                ? &options->barBorderLeftElapsed
+                : borderAsValue && i == options->barWidth - 1
+                    ? &options->barBorderRightElapsed
+                    : &options->barCharElapsed);
        }

        if (blocksPercent < options->barWidth)
        {
-            if(!options->pipe)
-                ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m");
-            for (uint32_t i = blocksPercent; i < options->barWidth; ++i)
-                ffStrbufAppend(buffer, &options->barCharTotal);
+            if(!options->pipe && options->barColorTotal.length > 0)
+                ffStrbufAppendF(buffer, "\e[%sm", options->barColorTotal.chars);
+            for (uint8_t i = blocksPercent; i < options->barWidth; ++i)
+            {
+                ffStrbufAppend(buffer, borderAsValue && i == 0
+                    ? &options->barBorderLeft
+                    : borderAsValue && i == options->barWidth - 1
+                        ? &options->barBorderRight
+                        : &options->barCharTotal);
+            }
        }
    }

-    if(options->barBorderRight.length)
+    if(!borderAsValue && options->barBorderRight.length)
    {
-        if(!options->pipe)
-            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m");
+        if(!options->pipe && options->barColorBorder.length > 0)
+            ffStrbufAppendF(buffer, "\e[%sm", options->barColorBorder.chars);
        ffStrbufAppend(buffer, &options->barBorderRight);
    }

-    if(!options->pipe)
+    if(!options->pipe && (options->barColorElapsed.length > 0 || options->barColorTotal.length > 0 || options->barColorBorder.length > 0))
    {
        ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
        appendOutputColor(buffer, module);
@@ -165,7 +185,7 @@ void ffPercentAppendNum(FFstrbuf* buffer, double percent, FFPercentageModuleConf
        const char* colorYellow = options->percentColorYellow.chars;
        const char* colorRed = options->percentColorRed.chars;

-        if(percent != percent)
+        if(percent == -DBL_MAX)
            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_BLACK "m");
        else if(green <= yellow)
        {
@@ -175,7 +195,6 @@ void ffPercentAppendNum(FFstrbuf* buffer, double percent, FFPercentageModuleConf
                ffStrbufAppendF(buffer, "\e[%sm", colorYellow);
            else
                ffStrbufAppendF(buffer, "\e[%sm", colorGreen);
-
        }
        else
        {
@@ -187,7 +206,8 @@ void ffPercentAppendNum(FFstrbuf* buffer, double percent, FFPercentageModuleConf
                ffStrbufAppendF(buffer, "\e[%sm", colorGreen);
        }
    }
-    ffStrbufAppendF(buffer, "%.*f%%", options->percentNdigits, percent);
+    ffStrbufAppendF(buffer, "%*.*f%s%%", options->percentWidth, options->percentNdigits, percent,
+        options->percentSpaceBeforeUnit == FF_SPACE_BEFORE_UNIT_ALWAYS ? " " : "");

    if (colored && !options->pipe)
    {
@@ -239,14 +259,14 @@ bool ffPercentParseCommandOptions(const char* key, const char* subkey, const cha
    return false;
 }

-bool ffPercentParseJsonObject(const char* key, yyjson_val* value, FFPercentageModuleConfig* config)
+bool ffPercentParseJsonObject(yyjson_val* key, yyjson_val* value, FFPercentageModuleConfig* config)
 {
-    if (!ffStrEqualsIgnCase(key, "percent"))
+    if (!unsafe_yyjson_equals_str(key, "percent"))
        return false;

    if (!yyjson_is_obj(value))
    {
-        fprintf(stderr, "Error: usage: %s must be an object\n", key);
+        fprintf(stderr, "Error: usage: %s must be an object\n", unsafe_yyjson_get_str(key));
        exit(480);
    }

@@ -288,16 +308,10 @@ bool ffPercentParseJsonObject(const char* key, yyjson_val* value, FFPercentageMo
    return true;
 }

-void ffPercentGenerateJsonConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, FFPercentageModuleConfig defaultConfig, FFPercentageModuleConfig config)
+void ffPercentGenerateJsonConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, FFPercentageModuleConfig config)
 {
-    if (config.green == defaultConfig.green && config.yellow == defaultConfig.yellow)
-        return;
-
    yyjson_mut_val* percent = yyjson_mut_obj_add_obj(doc, module, "percent");
-    if (config.green != defaultConfig.green)
-        yyjson_mut_obj_add_uint(doc, percent, "green", config.green);
-    if (config.yellow != defaultConfig.yellow)
-        yyjson_mut_obj_add_uint(doc, percent, "yellow", config.yellow);
-    if (config.type != defaultConfig.type)
-        yyjson_mut_obj_add_uint(doc, percent, "type", config.type);
+    yyjson_mut_obj_add_uint(doc, percent, "green", config.green);
+    yyjson_mut_obj_add_uint(doc, percent, "yellow", config.yellow);
+    yyjson_mut_obj_add_uint(doc, percent, "type", config.type);
 }
@@ -11,7 +11,7 @@ typedef enum __attribute__((__packed__)) FFPercentageTypeFlags
    FF_PERCENTAGE_TYPE_BAR_BIT = 1 << 1,
    FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT = 1 << 2,
    FF_PERCENTAGE_TYPE_NUM_COLOR_BIT = 1 << 3,
-    FF_PERCENTAGE_TYPE_BAR_MONOCHROME_BIT = FF_PERCENTAGE_TYPE_NUM_COLOR_BIT,
+    FF_PERCENTAGE_TYPE_BAR_MONOCHROME_BIT = 1 << 4,
    FF_PERCENTAGE_TYPE_FORCE_UNSIGNED_ = UINT8_MAX,
 } FFPercentageTypeFlags;
 static_assert(sizeof(FFPercentageTypeFlags) == 1, "");
@@ -40,6 +40,6 @@ typedef struct yyjson_val yyjson_val;
 typedef struct yyjson_mut_doc yyjson_mut_doc;
 typedef struct yyjson_mut_val yyjson_mut_val;
 bool ffPercentParseCommandOptions(const char* key, const char* subkey, const char* value, FFPercentageModuleConfig* config);
-bool ffPercentParseJsonObject(const char* key, yyjson_val* value, FFPercentageModuleConfig* config);
-void ffPercentGenerateJsonConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, FFPercentageModuleConfig defaultConfig, FFPercentageModuleConfig config);
+bool ffPercentParseJsonObject(yyjson_val* key, yyjson_val* value, FFPercentageModuleConfig* config);
+void ffPercentGenerateJsonConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, FFPercentageModuleConfig config);
 const char* ffPercentParseTypeJsonConfig(yyjson_val* value, FFPercentageTypeFlags* result);
@@ -1,5 +1,6 @@
 #include "fastfetch.h"
 #include "common/printing.h"
+#include "logo/logo.h"
 #include "util/textModifier.h"

 void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType)
@@ -99,7 +100,7 @@ void ffPrintFormat(const char* moduleName, uint8_t moduleIndex, const FFModuleAr
    ffStrbufPutTo(&buffer, stdout);
 }

-static void printError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, const char* message, va_list arguments)
+void ffPrintError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, const char* message, ...)
 {
    if(!instance.config.display.showErrors)
        return;
@@ -109,7 +110,10 @@ static void printError(const char* moduleName, uint8_t moduleIndex, const FFModu
    if(!instance.config.display.pipe)
        fputs(FASTFETCH_TEXT_MODIFIER_ERROR, stdout);

+    va_list arguments;
+    va_start(arguments, message);
    vprintf(message, arguments);
+    va_end(arguments);

    if(!instance.config.display.pipe)
        fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
@@ -117,14 +121,6 @@ static void printError(const char* moduleName, uint8_t moduleIndex, const FFModu
    putchar('\n');
 }

-void ffPrintError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, const char* message, ...)
-{
-    va_list arguments;
-    va_start(arguments, message);
-    printError(moduleName, moduleIndex, moduleArgs, printType, message, arguments);
-    va_end(arguments);
-}
-
 void ffPrintColor(const FFstrbuf* colorValue)
 {
    //If the color is not set, this would reset in \033[m, which resets everything.
@@ -12,6 +12,10 @@
 #include <errno.h>
 #include <sys/wait.h>

+#if !(__ANDROID__ || __OpenBSD__)
+    #include <spawn.h>
+#endif
+
 #if defined(__FreeBSD__) || defined(__APPLE__)
    #include <sys/types.h>
    #include <sys/user.h>
@@ -33,6 +37,10 @@
    #include <image.h>
 #endif

+#ifndef environ
+extern char** environ;
+#endif
+
 enum { FF_PIPE_BUFSIZ = 8192 };

 static inline int ffPipe2(int* fds, int flags)
@@ -48,6 +56,8 @@ static inline int ffPipe2(int* fds, int flags)
    #endif
 }

+
+// Not thread-safe
 const char* ffProcessAppendOutput(FFstrbuf* buffer, char* const argv[], bool useStdErr)
 {
    int pipes[2];
@@ -56,7 +66,77 @@ const char* ffProcessAppendOutput(FFstrbuf* buffer, char* const argv[], bool use
    if(ffPipe2(pipes, O_CLOEXEC) == -1)
        return "pipe() failed";

-    pid_t childPid = fork();
+    pid_t childPid = -1;
+    int nullFile = ffGetNullFD();
+
+    #if !(__ANDROID__ || __OpenBSD__)
+
+    // NetBSD / Darwin: native syscall
+    // Linux (glibc): clone3-execve
+    // FreeBSD: vfork-execve
+    // illumos: vforkx-execve
+    // OpenBSD / Android (bionic): fork-execve
+
+    posix_spawn_file_actions_t file_actions;
+    posix_spawn_file_actions_init(&file_actions);
+    posix_spawn_file_actions_adddup2(&file_actions, pipes[1], useStdErr ? STDERR_FILENO : STDOUT_FILENO);
+    posix_spawn_file_actions_adddup2(&file_actions, nullFile, useStdErr ? STDOUT_FILENO : STDERR_FILENO);
+
+    static char* oldLang = NULL;
+    static int langIndex = -1;
+
+    if (langIndex >= 0)
+    {
+        // Found before
+        if (oldLang) // oldLang was set only if it needed to be changed
+        {
+            if (environ[langIndex] != oldLang)
+            {
+                // environ is changed outside of this function
+                langIndex = -1;
+            }
+            else
+                environ[langIndex] = (char*) "LANG=C.UTF-8";
+        }
+    }
+    if (langIndex < 0)
+    {
+        for (int i = 0; environ[i] != NULL; i++)
+        {
+            if (ffStrStartsWith(environ[i], "LANG="))
+            {
+                langIndex = i;
+                const char* langValue = environ[i] + 5; // Skip "LANG="
+                if (ffStrEqualsIgnCase(langValue, "C") ||
+                    ffStrStartsWithIgnCase(environ[i], "C.") ||
+                    ffStrEqualsIgnCase(langValue, "en_US") ||
+                    ffStrStartsWithIgnCase(langValue, "en_US."))
+                    break; // No need to change LANG
+                oldLang = environ[i];
+                environ[i] = (char*) "LANG=C.UTF-8"; // Set LANG to C.UTF-8 for consistent output
+                break;
+            }
+        }
+    }
+
+    int ret = posix_spawnp(&childPid, argv[0], &file_actions, NULL, argv, environ);
+
+    if (oldLang)
+        environ[langIndex] = oldLang;
+
+    posix_spawn_file_actions_destroy(&file_actions);
+
+    if (ret != 0)
+    {
+        close(pipes[0]);
+        close(pipes[1]);
+        return "posix_spawnp() failed";
+    }
+
+    #else
+
+    // https://github.com/termux/termux-packages/issues/25369
+    childPid = fork();
    if(childPid == -1)
    {
        close(pipes[0]);
@@ -64,18 +144,18 @@ const char* ffProcessAppendOutput(FFstrbuf* buffer, char* const argv[], bool use
        return "fork() failed";
    }

-    //Child
    if(childPid == 0)
    {
-        int nullFile = open("/dev/null", O_WRONLY | O_CLOEXEC);
+        //Child
        dup2(pipes[1], useStdErr ? STDERR_FILENO : STDOUT_FILENO);
        dup2(nullFile, useStdErr ? STDOUT_FILENO : STDERR_FILENO);
-        setenv("LANG", "C", 1);
+        putenv("LANG=C.UTF-8");
        execvp(argv[0], argv);
        _exit(127);
    }

-    //Parent
+    #endif
+
    close(pipes[1]);

    int FF_AUTO_CLOSE_FD childPipeFd = pipes[0];
@@ -86,20 +166,30 @@ const char* ffProcessAppendOutput(FFstrbuf* buffer, char* const argv[], bool use
        if (timeout >= 0)
        {
            struct pollfd pollfd = { childPipeFd, POLLIN, 0 };
-            if (poll(&pollfd, 1, timeout) == 0)
+            int pollret = poll(&pollfd, 1, timeout);
+            if (pollret == 0)
            {
                kill(childPid, SIGTERM);
                waitpid(childPid, NULL, 0);
                return "poll(&pollfd, 1, timeout) timeout (try increasing --processing-timeout)";
            }
-            else if (errno == EINTR)
+            else if (pollret < 0)
            {
-                // The child process has been terminated. See `chldSignalHandler` in `common/init.c`
-                if (waitpid(childPid, NULL, WNOHANG) == childPid)
+                if (errno == EINTR)
                {
-                    // Read remaining data from the pipe
-                    fcntl(childPipeFd, F_SETFL, O_CLOEXEC | O_NONBLOCK);
-                    childPid = -1;
+                    // The child process has been terminated. See `chldSignalHandler` in `common/init.c`
+                    if (waitpid(childPid, NULL, WNOHANG) == childPid)
+                    {
+                        // Read remaining data from the pipe
+                        fcntl(childPipeFd, F_SETFL, O_CLOEXEC | O_NONBLOCK);
+                        childPid = -1;
+                    }
+                }
+                else
+                {
+                    kill(childPid, SIGTERM);
+                    waitpid(childPid, NULL, 0);
+                    return "poll(&pollfd, 1, timeout) error";
                }
            }
            else if (pollfd.revents & POLLERR)
@@ -144,15 +234,42 @@ void ffProcessGetInfoLinux(pid_t pid, FFstrbuf* processName, FFstrbuf* exe, cons
    assert(processName->length > 0);
    ffStrbufClear(exe);

-    #ifdef __linux__
+    #if defined(__linux__) || defined(__GNU__)

    char filePath[64];
    snprintf(filePath, sizeof(filePath), "/proc/%d/cmdline", (int)pid);

    if(ffReadFileBuffer(filePath, exe))
    {
-        ffStrbufRecalculateLength(exe); //Trim the arguments
-        ffStrbufTrimRightSpace(exe);
+        const char* p = exe->chars;
+        uint32_t len = (uint32_t) strlen(p);
+
+        if (len + 1 < exe->length)
+        {
+            const char* name = memrchr(p, '/', len);
+            if (name) name++; else name = p;
+
+            // For interpreters, try to find the real script path in the arguments
+            if (ffStrStartsWith(name, "python")
+                #ifndef __ANDROID__
+                || ffStrEquals(name, "guile") // for shepherd
+                #endif
+            )
+            {
+                // `cmdline` always ends with a trailing '\0', and ffReadFileBuffer appends another \0
+                // So `exe->chars` is always double '\0' terminated
+                for (p = p + len + 1; *p && *p == '-'; p += strlen(p) + 1) // Skip arguments
+                    assert(p - exe->chars < exe->allocated);
+                if (*p)
+                {
+                    len = (uint32_t) strlen(p);
+                    memmove(exe->chars, p, len + 1);
+                }
+            }
+        }
+
+        assert(len < exe->allocated);
+        exe->length = len;
        ffStrbufTrimLeft(exe, '-'); //Login shells start with a dash
    }

@@ -279,8 +396,10 @@ void ffProcessGetInfoLinux(pid_t pid, FFstrbuf* processName, FFstrbuf* exe, cons
    psinfo_t proc;
    if (ffReadFileData(filePath, sizeof(proc), &proc) == sizeof(proc))
    {
-        ffStrbufSetS(exe, proc.pr_psargs);
-        ffStrbufSubstrBeforeFirstC(exe, ' ');
+        const char* args = proc.pr_psargs;
+        if (args[0] == '-') ++args;
+        const char* end = strchr(args, ' ');
+        ffStrbufSetNS(exe, end ? (uint32_t) (end - args) : (uint32_t) strlen(args), args);
    }

    if (exePath)
@@ -344,33 +463,53 @@ const char* ffProcessGetBasicInfoLinux(pid_t pid, FFstrbuf* name, pid_t* ppid, i
    if (pid <= 0)
        return "Invalid pid";

-    #ifdef __linux__
+    #if defined(__linux__) || defined(__GNU__)

    char procFilePath[64];
-    if (ppid)
+    #if __linux__
+    if (ppid || tty)
+    #endif
    {
        snprintf(procFilePath, sizeof(procFilePath), "/proc/%d/stat", (int)pid);
        char buf[PROC_FILE_BUFFSIZ];
        ssize_t nRead = ffReadFileData(procFilePath, sizeof(buf) - 1, buf);
        if(nRead <= 8)
            return "ffReadFileData(/proc/pid/stat, PROC_FILE_BUFFSIZ-1, buf) failed";
-        buf[nRead] = '\0';
+        buf[nRead] = '\0'; // pid (comm) state ppid pgrp session tty

-        *ppid = 0;
-        static_assert(sizeof(*ppid) == sizeof(int), "");
+        const char* pState = NULL;

-        ffStrbufEnsureFixedLengthFree(name, 255);
-        int tty_;
-        if(
-            sscanf(buf, "%*s (%255[^)]) %*c %d %*d %*d %d", name->chars, ppid, &tty_) < 2 || //stat (comm) state ppid pgrp session tty
-            name->chars[0] == '\0'
-        )
-            return "sscanf(stat) failed";
+        {
+            // comm in `/proc/pid/stat` is not encoded, and may contain ' ', ')' or even `\n`
+            const char* start = memchr(buf, '(', (size_t) nRead);
+            if (!start)
+                return "memchr(stat, '(') failed";
+            start++;
+            const char* end = memrchr(start, ')', (size_t) nRead - (size_t) (start - buf));
+            if (!end)
+                return "memrchr(stat, ')') failed";
+            ffStrbufSetNS(name, (uint32_t) (end - start), start);
+            ffStrbufTrimRightSpace(name);
+            if (name->chars[0] == '\0')
+                return "process name is empty";
+            pState = end + 2; // skip ") "
+        }

-        ffStrbufRecalculateLength(name);
-        if (tty)
-            *tty = tty_ & 0xFF;
+        #if !__linux__
+        if (ppid || tty)
+        #endif
+        {
+            int ppid_, tty_;
+            if(sscanf(pState + 2, "%d %*d %*d %d", &ppid_, &tty_) < 2)
+                return "sscanf(stat) failed";
+
+            if (ppid)
+                *ppid = (pid_t) ppid_;
+            if (tty)
+                *tty = tty_ & 0xFF;
+        }
    }
+    #if __linux__
    else
    {
        snprintf(procFilePath, sizeof(procFilePath), "/proc/%d/comm", (int)pid);
@@ -379,6 +518,7 @@ const char* ffProcessGetBasicInfoLinux(pid_t pid, FFstrbuf* name, pid_t* ppid, i
            return "ffReadFileBuffer(/proc/pid/comm, name) failed";
        ffStrbufTrimRightSpace(name);
    }
+    #endif

    #elif defined(__APPLE__)

@@ -81,7 +81,7 @@ const char* ffProcessAppendOutput(FFstrbuf* buffer, char* const argv[], bool use
    if (hChildPipeWrite == INVALID_HANDLE_VALUE)
        return "CreateFileW(L\"\\\\.\\pipe\\FASTFETCH-$(PID)\") failed";

-    PROCESS_INFORMATION piProcInfo = {0};
+    PROCESS_INFORMATION piProcInfo = {};

    BOOL success;

@@ -91,9 +91,15 @@ const char* ffProcessAppendOutput(FFstrbuf* buffer, char* const argv[], bool use
            .dwFlags = STARTF_USESTDHANDLES,
        };
        if (useStdErr)
+        {
+            siStartInfo.hStdOutput = ffGetNullFD();
            siStartInfo.hStdError = hChildPipeWrite;
+        }
        else
+        {
            siStartInfo.hStdOutput = hChildPipeWrite;
+            siStartInfo.hStdError = ffGetNullFD();
+        }

        FF_STRBUF_AUTO_DESTROY cmdline = ffStrbufCreate();
        argvToCmdline(argv, &cmdline);
@@ -130,7 +136,11 @@ const char* ffProcessAppendOutput(FFstrbuf* buffer, char* const argv[], bool use
            switch (GetLastError())
            {
            case ERROR_IO_PENDING:
-                if (!timeout || WaitForSingleObject(hChildPipeRead, (DWORD) timeout) != WAIT_OBJECT_0)
+                #if __aarch64__
+                if (!GetOverlappedResultEx(hChildPipeRead, &overlapped, &nRead, timeout < 0 ? INFINITE : (DWORD) timeout, FALSE))
+                #else
+                // To support Windows 7
+                if (timeout >= 0 && WaitForSingleObject(hChildPipeRead, (DWORD) timeout) != WAIT_OBJECT_0)
                {
                    CancelIo(hChildPipeRead);
                    TerminateProcess(hProcess, 1);
@@ -138,13 +148,18 @@ const char* ffProcessAppendOutput(FFstrbuf* buffer, char* const argv[], bool use
                }

                if (!GetOverlappedResult(hChildPipeRead, &overlapped, &nRead, FALSE))
+                #endif
                {
                    if (GetLastError() == ERROR_BROKEN_PIPE)
                        return NULL;

                    CancelIo(hChildPipeRead);
                    TerminateProcess(hProcess, 1);
-                    return "GetOverlappedResult(hChildPipeRead) failed";
+                    return "GetOverlappedResult"
+                        #if __aarch64__
+                        "Ex"
+                        #endif
+                        "(hChildPipeRead) failed";
                }
                break;

@@ -0,0 +1,44 @@
+#include "size.h"
+
+#include <inttypes.h>
+
+static void appendNum(FFstrbuf* result, uint64_t bytes, uint32_t base, const char** prefixes)
+{
+    const FFOptionsDisplay* options = &instance.config.display;
+    double size = (double) bytes;
+    uint8_t counter = 0;
+
+    while(size >= base && counter < options->sizeMaxPrefix && prefixes[counter + 1])
+    {
+        size /= base;
+        counter++;
+    }
+
+    if (counter == 0)
+        ffStrbufAppendUInt(result, bytes);
+    else
+        ffStrbufAppendDouble(result, size, (int8_t) options->sizeNdigits);
+    if (options->sizeSpaceBeforeUnit != FF_SPACE_BEFORE_UNIT_NEVER)
+        ffStrbufAppendC(result, ' ');
+    ffStrbufAppendS(result, prefixes[counter]);
+}
+
+void ffSizeAppendNum(uint64_t bytes, FFstrbuf* result)
+{
+    const FFOptionsDisplay* options = &instance.config.display;
+    switch (options->sizeBinaryPrefix)
+    {
+        case FF_SIZE_BINARY_PREFIX_TYPE_IEC:
+            appendNum(result, bytes, 1024, (const char*[]) {"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB", NULL});
+            break;
+        case FF_SIZE_BINARY_PREFIX_TYPE_SI:
+            appendNum(result, bytes, 1000, (const char*[]) {"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB", NULL});
+            break;
+        case FF_SIZE_BINARY_PREFIX_TYPE_JEDEC:
+            appendNum(result, bytes, 1024, (const char*[]) {"B", "KB", "MB", "GB", "TB", NULL});
+            break;
+        default:
+            appendNum(result, bytes, 1024, (const char*[]) {"B", NULL});
+            break;
+    }
+}
@@ -0,0 +1,3 @@
+#include "fastfetch.h"
+
+void ffSizeAppendNum(uint64_t bytes, FFstrbuf* result);
@@ -5,7 +5,7 @@

 void ffTempsAppendNum(double celsius, FFstrbuf* buffer, FFColorRangeConfig config, const FFModuleArgs* module)
 {
-    if (celsius != celsius) // ignores NaN
+    if (celsius == -DBL_MAX) // ignores invalid value
        return;

    const FFOptionsDisplay* options = &instance.config.display;
@@ -41,13 +41,16 @@ void ffTempsAppendNum(double celsius, FFstrbuf* buffer, FFColorRangeConfig confi
    {
        case FF_TEMPERATURE_UNIT_DEFAULT:
        case FF_TEMPERATURE_UNIT_CELSIUS:
-            ffStrbufAppendF(buffer, "%.*f°C", options->tempNdigits, celsius);
+            ffStrbufAppendF(buffer, "%.*f%s°C", options->tempNdigits, celsius,
+                options->tempSpaceBeforeUnit == FF_SPACE_BEFORE_UNIT_ALWAYS ? " " : "");
            break;
        case FF_TEMPERATURE_UNIT_FAHRENHEIT:
-            ffStrbufAppendF(buffer, "%.*f°F", options->tempNdigits, celsius * 1.8 + 32);
+            ffStrbufAppendF(buffer, "%.*f%s°F", options->tempNdigits, celsius * 1.8 + 32,
+                options->tempSpaceBeforeUnit == FF_SPACE_BEFORE_UNIT_ALWAYS ? " " : "");
            break;
        case FF_TEMPERATURE_UNIT_KELVIN:
-            ffStrbufAppendF(buffer, "%.*f K", options->tempNdigits, celsius + 273.15);
+            ffStrbufAppendF(buffer, "%.*f%sK", options->tempNdigits, celsius + 273.15,
+                options->tempSpaceBeforeUnit == FF_SPACE_BEFORE_UNIT_NEVER ? "" : " ");
            break;
    }

@@ -104,9 +107,9 @@ bool ffTempsParseCommandOptions(const char* key, const char* subkey, const char*
    return false;
 }

-bool ffTempsParseJsonObject(const char* key, yyjson_val* value, bool* useTemp, FFColorRangeConfig* config)
+bool ffTempsParseJsonObject(yyjson_val* key, yyjson_val* value, bool* useTemp, FFColorRangeConfig* config)
 {
-    if (!ffStrEqualsIgnCase(key, "temp"))
+    if (!unsafe_yyjson_equals_str(key, "temp"))
        return false;

    if (yyjson_is_bool(value))
@@ -123,7 +126,7 @@ bool ffTempsParseJsonObject(const char* key, yyjson_val* value, bool* useTemp, F

    if (!yyjson_is_obj(value))
    {
-        fprintf(stderr, "Error: usage: %s must be an object or a boolean\n", key);
+        fprintf(stderr, "Error: usage: %s must be an object or a boolean\n", unsafe_yyjson_get_str(key));
        exit(480);
    }

@@ -156,23 +159,14 @@ bool ffTempsParseJsonObject(const char* key, yyjson_val* value, bool* useTemp, F
    return true;
 }

-void ffTempsGenerateJsonConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, FF_MAYBE_UNUSED bool defaultTemp, FFColorRangeConfig defaultConfig, bool temp, FFColorRangeConfig config)
+void ffTempsGenerateJsonConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, bool temp, FFColorRangeConfig config)
 {
-    assert(defaultTemp == false); // assume defaultTemp is always false
-
    if (!temp)
-        return;
-
-    if (config.green != defaultConfig.green || config.yellow != defaultConfig.yellow)
-    {
-        yyjson_mut_val* temp = yyjson_mut_obj_add_obj(doc, module, "temp");
-        if (config.green != defaultConfig.green)
-            yyjson_mut_obj_add_uint(doc, temp, "green", config.green);
-        if (config.yellow != defaultConfig.yellow)
-            yyjson_mut_obj_add_uint(doc, temp, "yellow", config.yellow);
-    }
+        yyjson_mut_obj_add_bool(doc, module, "temp", false);
    else
    {
-        yyjson_mut_obj_add_bool(doc, module, "temp", true);
+        yyjson_mut_val* temp = yyjson_mut_obj_add_obj(doc, module, "temp");
+        yyjson_mut_obj_add_uint(doc, temp, "green", config.green);
+        yyjson_mut_obj_add_uint(doc, temp, "yellow", config.yellow);
    }
 }
@@ -5,5 +5,5 @@

 void ffTempsAppendNum(double celsius, FFstrbuf* buffer, FFColorRangeConfig config, const FFModuleArgs* module);
 bool ffTempsParseCommandOptions(const char* key, const char* subkey, const char* value, bool* useTemp, FFColorRangeConfig* config);
-bool ffTempsParseJsonObject(const char* key, yyjson_val* value, bool* useTemp, FFColorRangeConfig* config);
-void ffTempsGenerateJsonConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, FF_MAYBE_UNUSED bool defaultTemp, FFColorRangeConfig defaultConfig, bool temp, FFColorRangeConfig config);
+bool ffTempsParseJsonObject(yyjson_val* key, yyjson_val* value, bool* useTemp, FFColorRangeConfig* config);
+void ffTempsGenerateJsonConfig(yyjson_mut_doc* doc, yyjson_mut_val* module, bool temp, FFColorRangeConfig config);
@@ -0,0 +1,3 @@
+#include <time.h>
+
+char ffTimeInternalBuffer[64]; // Reduce memory usage and prevent redundant allocations
@@ -11,6 +11,8 @@
    #include <OS.h>
 #endif

+#include "util/arrayUtils.h"
+
 static inline double ffTimeGetTick(void) //In msec
 {
    #ifdef _WIN32
@@ -64,11 +66,12 @@ static inline const char* ffTimeToFullStr(uint64_t msec)
    time_t tsec = (time_t) (msec / 1000);
    const struct tm* tm = localtime(&tsec);

-    static char buf[32];
-    strftime(buf, __builtin_strlen("0000-00-00T00:00:00") + 1, "%FT%T", tm);
-    snprintf(buf + __builtin_strlen("0000-00-00T00:00:00"), __builtin_strlen(".000") + 1, ".%03u", (unsigned) (msec % 1000));
-    strftime(buf + __builtin_strlen("0000-00-00T00:00:00.000"), __builtin_strlen("+0000") + 1, "%z", tm);
-    return buf;
+    extern char ffTimeInternalBuffer[64];
+    uint32_t len = 0;
+    len += (uint32_t) strftime(ffTimeInternalBuffer, ARRAY_SIZE(ffTimeInternalBuffer) - len, "%FT%T", tm);
+    len += (uint32_t) snprintf(ffTimeInternalBuffer + len, ARRAY_SIZE(ffTimeInternalBuffer) - len, ".%03u", (unsigned) (msec % 1000));
+    len += (uint32_t) strftime(ffTimeInternalBuffer + len, ARRAY_SIZE(ffTimeInternalBuffer) - len, "%z", tm);
+    return ffTimeInternalBuffer;
 }

 // Not thread-safe
@@ -77,9 +80,9 @@ static inline const char* ffTimeToShortStr(uint64_t msec)
    if (msec == 0) return "";
    time_t tsec = (time_t) (msec / 1000);

-    static char buf[32];
-    strftime(buf, sizeof(buf), "%F %T", localtime(&tsec));
-    return buf;
+    extern char ffTimeInternalBuffer[64];
+    strftime(ffTimeInternalBuffer, ARRAY_SIZE(ffTimeInternalBuffer), "%F %T", localtime(&tsec));
+    return ffTimeInternalBuffer;
 }

 // Not thread-safe
@@ -88,12 +91,56 @@ static inline const char* ffTimeToTimeStr(uint64_t msec)
    if (msec == 0) return "";
    time_t tsec = (time_t) (msec / 1000);

-    static char buf[32];
-    strftime(buf, sizeof(buf), "%T", localtime(&tsec));
-    sprintf(buf + __builtin_strlen("00:00:00"), ".%03u", (unsigned) (msec % 1000));
-    return buf;
+    extern char ffTimeInternalBuffer[64];
+    uint32_t len = (uint32_t) strftime(ffTimeInternalBuffer, ARRAY_SIZE(ffTimeInternalBuffer), "%T", localtime(&tsec));
+    sprintf(ffTimeInternalBuffer + len, ".%03u", (unsigned) (msec % 1000));
+    return ffTimeInternalBuffer;
 }

 #ifdef _WIN32
    #pragma GCC diagnostic pop
 #endif
+
+typedef struct FFTimeGetAgeResult
+{
+    uint32_t years;
+    uint32_t daysOfYear;
+    double yearsFraction;
+} FFTimeGetAgeResult;
+
+static inline FFTimeGetAgeResult ffTimeGetAge(uint64_t birthMs, uint64_t nowMs)
+{
+    FFTimeGetAgeResult result = {};
+    if (__builtin_expect(birthMs == 0 || nowMs < birthMs, 0))
+        return result;
+
+    time_t birth_s = (time_t) (birthMs / 1000);
+    struct tm birth_tm;
+    #ifdef _WIN32
+    localtime_s(&birth_tm, &birth_s);
+    #else
+    localtime_r(&birth_s, &birth_tm);
+    #endif
+
+    time_t now_s = (time_t) (nowMs / 1000);
+    struct tm now_tm;
+    #ifdef _WIN32
+    localtime_s(&now_tm, &now_s);
+    #else
+    localtime_r(&now_s, &now_tm);
+    #endif
+
+    result.years = (uint32_t) (now_tm.tm_year - birth_tm.tm_year);
+    if (now_tm.tm_yday < birth_tm.tm_yday)
+        result.years--;
+
+    birth_tm.tm_year += (int) result.years;
+    birth_s = mktime(&birth_tm);
+    uint32_t diff_s = (uint32_t) (now_s - birth_s);
+    result.daysOfYear = diff_s / (24 * 60 * 60);
+
+    birth_tm.tm_year += 1;
+    result.yearsFraction = (double) diff_s / (double) (mktime(&birth_tm) - birth_s) + result.years;
+
+    return result;
+}
@@ -1,8 +1,9 @@
 #pragma once

 #include "fastfetch.h"
+#include "modules/battery/option.h"

-#define FF_BATTERY_TEMP_UNSET (0/0.0)
+#define FF_BATTERY_TEMP_UNSET (-DBL_MAX)

 typedef struct FFBatteryResult
 {
@@ -15,7 +16,7 @@ typedef struct FFBatteryResult
    double capacity;
    double temperature;
    uint32_t cycleCount;
-    int32_t timeRemaining;
+    int32_t timeRemaining; // in seconds, -1 if unknown
 } FFBatteryResult;

 const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results);
@@ -96,6 +96,7 @@ static const char* parseDumpsys(FFBatteryOptions* options, FFlist* results)
    battery->temperature = FF_BATTERY_TEMP_UNSET;
    battery->cycleCount = 0;
    battery->timeRemaining = -1;
+    battery->capacity = 0;
    ffStrbufInit(&battery->manufacturer);
    ffStrbufInit(&battery->modelName);
    ffStrbufInit(&battery->status);
@@ -124,11 +125,11 @@ static const char* parseDumpsys(FFBatteryOptions* options, FFlist* results)
    {
        double level = 0, scale = 0;
        if (ffParsePropLines(start, "level: ", &temp))
-            level = ffStrbufToDouble(&temp);
+            level = ffStrbufToDouble(&temp, -DBL_MAX);
        ffStrbufClear(&temp);

        if (ffParsePropLines(start, "scale: ", &temp))
-            scale = ffStrbufToDouble(&temp);
+            scale = ffStrbufToDouble(&temp, -DBL_MAX);
        ffStrbufClear(&temp);

        if (level > 0 && scale > 0)
@@ -138,7 +139,11 @@ static const char* parseDumpsys(FFBatteryOptions* options, FFlist* results)
    if(options->temp)
    {
        if (ffParsePropLines(start, "temperature: ", &temp))
-            battery->temperature = ffStrbufToDouble(&temp);
+        {
+            battery->temperature = ffStrbufToDouble(&temp, FF_BATTERY_TEMP_UNSET);
+            if (battery->temperature != FF_BATTERY_TEMP_UNSET)
+                battery->temperature /= 10.0; // Android returns temperature in tenths of a degree
+        }
        ffStrbufClear(&temp);
    }

@@ -45,7 +45,7 @@ static void parseBattery(int dfd, const char* id, FFBatteryOptions* options, FFl
        return;

    FFBatteryResult* result = ffListAdd(results);
-    result->capacity = ffStrbufToDouble(&tmpBuffer);
+    result->capacity = ffStrbufToDouble(&tmpBuffer, 0);

    //At this point, we have a battery. Try to get as much values as possible.

@@ -154,7 +154,11 @@ static void parseBattery(int dfd, const char* id, FFBatteryOptions* options, FFl
    if (options->temp)
    {
        if (ffReadFileBufferRelative(dfd, "temp", &tmpBuffer))
-            result->temperature = ffStrbufToDouble(&tmpBuffer) / 10;
+        {
+            result->temperature = ffStrbufToDouble(&tmpBuffer, FF_BATTERY_TEMP_UNSET);
+            if (result->temperature != FF_BATTERY_TEMP_UNSET)
+                result->temperature /= 10;
+        }
    }
 }

@@ -16,8 +16,8 @@

 const char* ffDetectBattery(FF_MAYBE_UNUSED FFBatteryOptions* options, FFlist* results)
 {
-    FF_AUTO_CLOSE_FD int fd = open(_PATH_SYSMON, O_RDONLY);
-    if (fd < 0) return "open(_PATH_SYSMON, O_RDONLY) failed";
+    FF_AUTO_CLOSE_FD int fd = open(_PATH_SYSMON, O_RDONLY | O_CLOEXEC);
+    if (fd < 0) return "open(_PATH_SYSMON, O_RDONLY | O_CLOEXEC) failed";

    prop_dictionary_t root = NULL;
    if (prop_dictionary_recv_ioctl(fd, ENVSYS_GETDICTIONARY, &root) < 0)
@@ -8,9 +8,9 @@

 const char* ffDetectBattery(FF_MAYBE_UNUSED FFBatteryOptions* options, FFlist* result)
 {
-    FF_AUTO_CLOSE_FD int devfd = open("/dev/apm", O_RDONLY);
+    FF_AUTO_CLOSE_FD int devfd = open("/dev/apm", O_RDONLY | O_CLOEXEC);

-    if (devfd < 0) return "open(dev/apm, O_RDONLY) failed";
+    if (devfd < 0) return "open(dev/apm, O_RDONLY | O_CLOEXEC) failed";

    struct apm_power_info info = {};

@@ -8,40 +8,31 @@

 #undef WIN32_LEAN_AND_MEAN
 #include <windows.h>
-#include <setupapi.h>
 #include <batclass.h>
 #include <devguid.h>
+#include <cfgmgr32.h>
 #include <winternl.h>

-static inline void wrapSetupDiDestroyDeviceInfoList(HDEVINFO* hdev)
+static const char* detectWithCmApi(FFBatteryOptions* options, FFlist* results)
 {
-    if(*hdev)
-        SetupDiDestroyDeviceInfoList(*hdev);
-}
+    //https://learn.microsoft.com/en-us/windows-hardware/drivers/install/using-device-interfaces
+    ULONG cchDeviceInterfaces = 0;
+    CONFIGRET cr = CM_Get_Device_Interface_List_SizeW(&cchDeviceInterfaces, (LPGUID)&GUID_DEVCLASS_BATTERY, NULL, CM_GET_DEVICE_INTERFACE_LIST_PRESENT);
+    if (cr != CR_SUCCESS)
+        return "CM_Get_Device_Interface_List_SizeW() failed";

-static const char* detectWithSetupApi(FFBatteryOptions* options, FFlist* results)
-{
-    //https://learn.microsoft.com/en-us/windows/win32/power/enumerating-battery-devices
-    HDEVINFO hdev __attribute__((__cleanup__(wrapSetupDiDestroyDeviceInfoList))) =
-        SetupDiGetClassDevsW(&GUID_DEVCLASS_BATTERY, 0, 0, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
-    if(hdev == INVALID_HANDLE_VALUE)
-        return "SetupDiGetClassDevsW(&GUID_DEVCLASS_BATTERY) failed";
+    if (cchDeviceInterfaces <= 1)
+        return NULL; // Not found

-    SP_DEVICE_INTERFACE_DATA did = { .cbSize = sizeof(did) };
-    for(DWORD idev = 0; SetupDiEnumDeviceInterfaces(hdev, NULL, &GUID_DEVCLASS_BATTERY, idev, &did); idev++)
+    wchar_t* FF_AUTO_FREE mszDeviceInterfaces = (wchar_t*)malloc(cchDeviceInterfaces * sizeof(wchar_t));
+    cr = CM_Get_Device_Interface_ListW((LPGUID)&GUID_DEVCLASS_BATTERY, NULL, mszDeviceInterfaces, cchDeviceInterfaces, CM_GET_DEVICE_INTERFACE_LIST_PRESENT);
+    if (cr != CR_SUCCESS)
+        return "CM_Get_Device_Interface_ListW() failed";
+
+    for (const wchar_t* pDeviceInterface = mszDeviceInterfaces; *pDeviceInterface; pDeviceInterface += wcslen(pDeviceInterface) + 1)
    {
-        DWORD cbRequired = 0;
-        SetupDiGetDeviceInterfaceDetailW(hdev, &did, NULL, 0, &cbRequired, NULL); //Fail with not enough buffer
-        SP_DEVICE_INTERFACE_DETAIL_DATA_W* FF_AUTO_FREE pdidd = (SP_DEVICE_INTERFACE_DETAIL_DATA_W*)malloc(cbRequired);
-        if(!pdidd)
-            break; //Out of memory
-
-        pdidd->cbSize = sizeof(*pdidd);
-        if(!SetupDiGetDeviceInterfaceDetailW(hdev, &did, pdidd, cbRequired, &cbRequired, NULL))
-            continue;
-
        HANDLE FF_AUTO_CLOSE_FD hBattery =
-            CreateFileW(pdidd->DevicePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+            CreateFileW(pDeviceInterface, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

        if(hBattery == INVALID_HANDLE_VALUE)
            continue;
@@ -99,7 +90,7 @@ static const char* detectWithSetupApi(FFBatteryOptions* options, FFlist* results
            bqi.InformationLevel = BatteryManufactureDate;
            BATTERY_MANUFACTURE_DATE date;
            if(DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_INFORMATION, &bqi, sizeof(bqi), &date, sizeof(date), &dwOut, NULL))
-                ffStrbufSetF(&battery->manufactureDate, "%.4d-%.2d-%.2d", date.Year + 1900, date.Month, date.Day);
+                ffStrbufSetF(&battery->manufactureDate, "%.4d-%.2d-%.2d", date.Year < 1000 ? date.Year + 1900 : date.Year, date.Month, date.Day);
        }

        {
@@ -112,7 +103,7 @@ static const char* detectWithSetupApi(FFBatteryOptions* options, FFlist* results

        battery->cycleCount = bi.CycleCount;

-        battery->temperature = 0.0/0.0;
+        battery->temperature = FF_BATTERY_TEMP_UNSET;
        if(options->temp)
        {
            bqi.InformationLevel = BatteryTemperature;
@@ -131,7 +122,7 @@ static const char* detectWithSetupApi(FFBatteryOptions* options, FFlist* results
        {
            BATTERY_STATUS bs;
            BATTERY_WAIT_STATUS bws = { .BatteryTag = bqi.BatteryTag };
-            if(DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_STATUS, &bws, sizeof(bws), &bs, sizeof(bs), &dwOut, NULL) && bs.Capacity != BATTERY_UNKNOWN_CAPACITY)
+            if(DeviceIoControl(hBattery, IOCTL_BATTERY_QUERY_STATUS, &bws, sizeof(bws), &bs, sizeof(bs), &dwOut, NULL) && bs.Capacity != BATTERY_UNKNOWN_CAPACITY && bi.FullChargedCapacity != 0)
                battery->capacity = bs.Capacity * 100.0 / bi.FullChargedCapacity;
            else
                battery->capacity = 0;
@@ -271,6 +262,6 @@ static const char* detectWithNtApi(FF_MAYBE_UNUSED FFBatteryOptions* options, FF
 const char* ffDetectBattery(FFBatteryOptions* options, FFlist* results)
 {
    return options->useSetupApi
-        ? detectWithSetupApi(options, results)
+        ? detectWithCmApi(options, results)
        : detectWithNtApi(options, results);
 }
@@ -1,6 +1,7 @@
 #pragma once

 #include "fastfetch.h"
+#include "modules/bios/option.h"

 typedef struct FFBiosResult
 {
@@ -32,6 +32,10 @@ typedef struct _SYSTEM_BOOT_ENVIRONMENT_INFORMATION

 #include <fcntl.h>
 #include <unistd.h>
+
+#elif __sun
+#include <libdevinfo.h>
+#include <sys/sunddi.h>
 #endif

 typedef struct FFSmbiosBios
@@ -59,6 +63,7 @@ typedef struct FFSmbiosBios
 static_assert(offsetof(FFSmbiosBios, ExtendedBiosRomSize) == 0x18,
    "FFSmbiosBios: Wrong struct alignment");

+
 const char* ffDetectBios(FFBiosResult* bios)
 {
    const FFSmbiosHeaderTable* smbiosTable = ffGetSmbiosHeaderTable();
@@ -94,6 +99,17 @@ const char* ffDetectBios(FFBiosResult* bios)
            default: break;
        }
    }
+    #elif __sun
+    di_node_t rootNode = di_init("/", DINFOPROP);
+    if (rootNode != DI_NODE_NIL)
+    {
+        char* efiVersion = NULL;
+        if (di_prop_lookup_strings(DDI_DEV_T_ANY, rootNode, "efi-version", &efiVersion) > 0)
+            ffStrbufSetStatic(&bios->type, "UEFI");
+        else
+            ffStrbufSetStatic(&bios->type, "BIOS");
+    }
+    di_fini(rootNode);
    #elif __HAIKU__ || __OpenBSD__
    // Currently SMBIOS detection is supported in legancy BIOS only
    ffStrbufSetStatic(&bios->type, "BIOS");
@@ -1,6 +1,7 @@
 #pragma once

 #include "fastfetch.h"
+#include "modules/bluetooth/option.h"

 typedef struct FFBluetoothResult
 {
@@ -6,7 +6,13 @@
 static int enumDev(FF_MAYBE_UNUSED int sockfd, struct bt_devinfo const* dev, FFlist* devices)
 {
    FFBluetoothResult* device = ffListAdd(devices);
-    ffStrbufInitS(&device->name, bt_devremote_name_gen(dev->devname, &dev->bdaddr));
+    ffStrbufInitS(&device->name,
+        #if __FreeBSD__
+        bt_devremote_name_gen(dev->devname, &dev->bdaddr)
+        #else
+        dev->devname
+        #endif
+    );
    ffStrbufInitS(&device->address, bt_ntoa(&dev->bdaddr, NULL));
    ffStrbufUpperCase(&device->address);
    ffStrbufInit(&device->type);
@@ -232,7 +232,7 @@ static uint32_t connectedDevices(void)

 #endif

-const char* ffDetectBluetooth(FFBluetoothOptions* options, FF_MAYBE_UNUSED FFlist* devices /* FFBluetoothResult */)
+const char* ffDetectBluetooth(FF_MAYBE_UNUSED FFBluetoothOptions* options, FF_MAYBE_UNUSED FFlist* devices /* FFBluetoothResult */)
 {
    #ifdef FF_HAVE_DBUS
        int32_t connectedCount = -1;
@@ -1,6 +1,7 @@
 #pragma once

 #include "fastfetch.h"
+#include "modules/bluetoothradio/option.h"

 typedef struct FFBluetoothRadioResult
 {
@@ -1,6 +1,7 @@
 #pragma once

 #include "fastfetch.h"
+#include "modules/board/option.h"

 typedef struct FFBoardResult
 {
@@ -9,9 +9,19 @@ const char* ffDetectBoard(FFBoardResult* result)
    if (!service)
        return "No IOPlatformExpertDevice found";

-    io_name_t name;
-    if (IORegistryEntryGetName(service, name) == kIOReturnSuccess)
-        ffStrbufSetS(&result->name, name);
+    FF_CFTYPE_AUTO_RELEASE CFTypeRef boardId = IORegistryEntryCreateCFProperty(service, CFSTR("board-id"), kCFAllocatorDefault, kNilOptions);
+    if (boardId)
+        ffCfStrGetString(boardId, &result->name);
+    else
+    {
+        io_name_t name;
+        if (IORegistryEntryGetName(service, name) == kIOReturnSuccess)
+            ffStrbufSetS(&result->name, name);
+    }
+
+    FF_CFTYPE_AUTO_RELEASE CFStringRef version = IORegistryEntryCreateCFProperty(service, CFSTR("version"), kCFAllocatorDefault, kNilOptions);
+    if (version)
+        ffCfStrGetString(version, &result->version);

    FF_CFTYPE_AUTO_RELEASE CFTypeRef manufacturer = IORegistryEntryCreateCFProperty(service, CFSTR("manufacturer"), kCFAllocatorDefault, kNilOptions);
    if (manufacturer)
@@ -1,6 +1,7 @@
 #pragma once

 #include "fastfetch.h"
+#include "modules/bootmgr/option.h"

 typedef struct FFBootmgrResult
 {
@@ -20,7 +20,7 @@

 const char* ffDetectBootmgr(FFBootmgrResult* result)
 {
-    FF_AUTO_CLOSE_FD int efifd = open("/dev/efi", O_RDWR);
+    FF_AUTO_CLOSE_FD int efifd = open("/dev/efi", O_RDWR | O_CLOEXEC);
    if (efifd < 0) return "open(/dev/efi) failed";

    uint8_t buffer[2048];
@@ -1,7 +1,7 @@
 #pragma once

 #include "fastfetch.h"
-#include "util/FFlist.h"
+#include "modules/brightness/option.h"

 typedef struct FFBrightnessResult
 {
@@ -32,7 +32,7 @@ static const char* detectWithBacklight(FFlist* result)
        ffStrbufAppendS(&backlightDir, "/brightness");
        if(ffReadFileBuffer(backlightDir.chars, &buffer))
        {
-            double actualBrightness = ffStrbufToDouble(&buffer);
+            double actualBrightness = ffStrbufToDouble(&buffer, 0);
            ffStrbufSubstrBefore(&backlightDir, backlightDirLength);
            ffStrbufAppendS(&backlightDir, entry->d_name);
            ffStrbufAppendS(&backlightDir, "/max_brightness");
@@ -71,7 +71,7 @@ static const char* detectWithBacklight(FFlist* result)
                }
                else
                    ffStrbufInitS(&brightness->name, entry->d_name);
-                brightness->max = ffStrbufToDouble(&buffer);
+                brightness->max = ffStrbufToDouble(&buffer, 0);
                brightness->min = 0;
                brightness->current = actualBrightness;
                brightness->builtin = true;
@@ -12,7 +12,7 @@ const char* ffDetectBrightness(FF_MAYBE_UNUSED FFBrightnessOptions* options, FFl
    for (char i = '0'; i <= '9'; ++i) {
        path[strlen("/dev/ttyC")] = i;

-        FF_AUTO_CLOSE_FD int devfd = open(path, O_RDONLY);
+        FF_AUTO_CLOSE_FD int devfd = open(path, O_RDONLY | O_CLOEXEC);

        if (devfd < 0) {
            if (errno == EACCES && i == '0')
@@ -1,6 +1,7 @@
 #pragma once

 #include "fastfetch.h"
+#include "modules/btrfs/option.h"

 typedef struct FFBtrfsDiskUsage
 {
@@ -1,6 +1,7 @@
 #pragma once

 #include "fastfetch.h"
+#include "modules/camera/option.h"

 typedef struct FFCameraResult
 {
@@ -45,7 +45,7 @@ const char* ffDetectCamera(FF_MAYBE_UNUSED FFlist* result)
                ffStrbufInitStatic(&camera->name, "Unknown");
        }
        ffStrbufInit(&camera->vendor);
-        ffStrbufInitS(&camera->id, yyjson_get_str(yyjson_obj_get(device, "id")));
+        ffStrbufInitJsonVal(&camera->id, yyjson_obj_get(device, "id"));
        yyjson_val* sizes = yyjson_arr_get_first(yyjson_obj_get(device, "jpeg_output_sizes"));
        if (yyjson_is_obj(sizes))
        {
@@ -7,6 +7,9 @@

 #if FF_HAVE_LINUX_VIDEODEV2
    #include <linux/videodev2.h>
+#elif __has_include(<sys/videoio.h>) // OpenBSD
+    #include <sys/videoio.h>
+    #define FF_HAVE_LINUX_VIDEODEV2 1
 #endif

 const char* ffDetectCamera(FFlist* result)
@@ -17,9 +20,15 @@ const char* ffDetectCamera(FFlist* result)
    for (uint32_t i = 0; i <= 9; ++i)
    {
        path[ARRAY_SIZE(path) - 2] = (char) (i + '0');
-        FF_AUTO_CLOSE_FD int fd = open(path, O_RDONLY);
+        FF_AUTO_CLOSE_FD int fd = open(path, O_RDONLY | O_CLOEXEC);
        if (fd < 0)
-            break;
+        {
+            if (errno == ENOENT)
+                break;
+            if (errno == ENXIO)
+                continue;
+            return "Failed to open /dev/videoN";
+        }

        struct v4l2_capability cap = {};
        if (ioctl(fd, VIDIOC_QUERYCAP, &cap) < 0 || !(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE))
@@ -1,6 +1,7 @@
 #pragma once

 #include "fastfetch.h"
+#include "modules/chassis/option.h"

 typedef struct FFChassisResult
 {
@@ -60,3 +60,474 @@ const char* ffCPUQualcommCodeToName(uint32_t code)
        default: return NULL;
    }
 }
+
+#if defined(__x86_64__) || defined(__i386__)
+
+#include <cpuid.h>
+
+void ffCPUDetectByCpuid(FFCPUResult* cpu)
+{
+    uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
+    if (__get_cpuid(0x16, &eax, &ebx, &ecx, &edx))
+    {
+        // WARNING: CPUID may report frequencies of efficient cores
+        // cpuid returns 0 MHz when hypervisor is enabled
+        if (eax) cpu->frequencyBase = eax;
+        if (ebx) cpu->frequencyMax = ebx;
+    }
+
+    if (__get_cpuid(1, &eax, &ebx, &ecx, &edx))
+    {
+        // Feature tests (leaf1.ecx, leaf7.ebx)
+        bool sse2     = (ecx & bit_SSE2) != 0;
+        bool sse4_2   = (ecx & bit_SSE4_2) != 0;
+        bool pclmul   = (ecx & bit_PCLMUL) != 0;
+        bool popcnt   = (ecx & bit_POPCNT) != 0;
+        bool fma      = (ecx & bit_FMA) != 0;
+        bool osxsave  = (ecx & bit_OSXSAVE) != 0;
+
+        unsigned int eax7 = 0, ebx7 = 0, ecx7 = 0, edx7 = 0;
+        __get_cpuid_count(7, 0, &eax7, &ebx7, &ecx7, &edx7);
+
+        bool avx2     = (ebx7 & bit_AVX2) != 0;
+        bool bmi2     = (ebx7 & bit_BMI2) != 0;
+        bool avx512f  = (ebx7 & bit_AVX512F) != 0;
+        bool avx512bw = (ebx7 & bit_AVX512BW) != 0;
+        bool avx512dq = (ebx7 & bit_AVX512DQ) != 0;
+
+        // OS support for AVX/AVX512: check XGETBV (requires OSXSAVE)
+        bool avx_os    = false;
+        bool avx512_os = false;
+        if (osxsave)
+        {
+            __asm__ __volatile__(
+                "xgetbv"
+                : "=a"(eax), "=d"(edx)
+                : "c"(0)
+                :
+            );
+            uint64_t xcr0 = ((uint64_t)edx << 32) | eax;
+
+            // AVX requires XCR0[1:2] == 11b (XMM and YMM state)
+            avx_os = (xcr0 & 0x6ULL) == 0x6ULL;
+            // AVX512 requires XCR0[7,5,6] etc. common mask 0xE6 (bits 1,2,5,6,7)
+            avx512_os = (xcr0 & 0xE6ULL) == 0xE6ULL;
+        }
+
+        cpu->march = "unknown";
+        if (avx512f && avx512bw && avx512dq && avx512_os) cpu->march = "x86_64-v4";
+        else if (avx2 && fma && bmi2 && avx_os) cpu->march = "x86_64-v3";
+        else if (sse4_2 && popcnt && pclmul) cpu->march = "x86_64-v2";
+        else if (sse2) cpu->march = "x86_64-v1";
+    }
+}
+
+#elif defined(__aarch64__)
+
+// This is not accurate because a lot of flags are optional from old versions
+// https://developer.arm.com/documentation/109697/2025_06/Feature-descriptions?lang=en
+// https://en.wikipedia.org/wiki/AArch64#ARM-A_(application_architecture)
+// Worth noting: Apple M1 is marked as ARMv8.5-A on Wikipedia, but it lacks BTI (mandatory in v8.5)
+
+#ifdef __linux__
+#include "common/io/io.h"
+#include <elf.h>
+#include <asm/hwcap.h>
+
+#ifndef HWCAP2_SME
+#define HWCAP2_SME         (1UL << 23)
+#endif
+#ifndef HWCAP2_SME2
+#define HWCAP2_SME2        (1UL << 37)
+#endif
+#ifndef HWCAP2_CSSC
+#define HWCAP2_CSSC        (1UL << 34)
+#endif
+#ifndef HWCAP2_SME2P1
+#define HWCAP2_SME2P1      (1UL << 38)
+#endif
+#ifndef HWCAP2_MOPS
+#define HWCAP2_MOPS        (1UL << 43)
+#endif
+#ifndef HWCAP2_F8E4M3
+#define HWCAP2_F8E4M3      (1UL << 55)
+#endif
+#ifndef HWCAP2_F8E5M2
+#define HWCAP2_F8E5M2      (1UL << 56)
+#endif
+#ifndef HWCAP_CMPBR
+#define HWCAP_CMPBR        (1UL << 33)
+#endif
+#ifndef HWCAP_FPRCVT
+#define HWCAP_FPRCVT       (1UL << 34)
+#endif
+
+void ffCPUDetectByCpuid(FFCPUResult* cpu)
+{
+    char buf[PROC_FILE_BUFFSIZ];
+    ssize_t nRead = ffReadFileData("/proc/self/auxv", ARRAY_SIZE(buf), buf);
+
+    if (nRead < (ssize_t) sizeof(Elf64_auxv_t)) return;
+
+    uint64_t hwcap = 0, hwcap2 = 0;
+
+    for (Elf64_auxv_t* auxv = (Elf64_auxv_t*)buf; (char*)auxv < buf + nRead; ++auxv)
+    {
+        if (auxv->a_type == AT_HWCAP)
+        {
+            hwcap = auxv->a_un.a_val;
+        }
+        else if (auxv->a_type == AT_HWCAP2)
+        {
+            hwcap2 = auxv->a_un.a_val;
+        }
+    }
+
+    if (!hwcap) return;
+
+    cpu->march = "unknown";
+
+    // ARMv8-A
+    bool has_fp = (hwcap & HWCAP_FP) != 0;
+    bool has_asimd = (hwcap & HWCAP_ASIMD) != 0;
+
+    // ARMv8.1-A
+    bool has_atomics = (hwcap & HWCAP_ATOMICS) != 0; // optional from v8.0
+    bool has_crc32 = (hwcap & HWCAP_CRC32) != 0; // optional from v8.0
+    bool has_asimdrdm = (hwcap & HWCAP_ASIMDRDM) != 0; // optional from v8.0
+
+    // ARMv8.2-A
+    bool has_fphp = (hwcap & HWCAP_FPHP) != 0; // optional
+    bool has_dcpop = (hwcap & HWCAP_DCPOP) != 0; // DC CVAP, optional from v8.1
+
+    // ARMv8.3-A
+    bool has_paca = (hwcap & HWCAP_PACA) != 0; // optional from v8.2
+    bool has_lrcpc = (hwcap & HWCAP_LRCPC) != 0; // optional from v8.2
+    bool has_fcma = (hwcap & HWCAP_FCMA) != 0; // optional from v8.2
+    bool has_jscvt = (hwcap & HWCAP_JSCVT) != 0; // optional from v8.2
+
+    // ARMv8.4-A
+    bool has_dit = (hwcap & HWCAP_DIT) != 0; // optional from v8.3
+    bool has_flagm = (hwcap & HWCAP_FLAGM) != 0; // optional from v8.1
+    bool has_ilrcpc = (hwcap & HWCAP_ILRCPC) != 0; // optional from v8.2
+
+    // ARMv8.5-A
+    bool has_bti = (hwcap2 & HWCAP2_BTI) != 0; // optional from v8.4
+    bool has_sb = (hwcap & HWCAP_SB) != 0; // optional from v8.0
+    bool has_dcpodp = (hwcap2 & HWCAP2_DCPODP) != 0; // optional from v8.1
+    bool has_flagm2 = (hwcap2 & HWCAP2_FLAGM2) != 0; // optional from v8.4
+    bool has_frint = (hwcap2 & HWCAP2_FRINT) != 0; // optional from v8.4
+
+    // ARMv9.0-A
+    bool has_sve2 = (hwcap2 & HWCAP2_SVE2) != 0;
+
+    // ARMv9.1-A
+    // ARMv8.6-A
+    bool has_bf16 = (hwcap2 & HWCAP2_BF16) != 0; // optional from v8.2
+    bool has_i8mm = (hwcap2 & HWCAP2_I8MM) != 0; // optional from v8.1
+
+    // ARMv8.7-A
+    bool has_afp = (hwcap2 & HWCAP2_AFP) != 0; // optional from v8.6
+
+    // ARMv9.2-A
+    bool has_sme = (hwcap2 & HWCAP2_SME) != 0;
+
+    // ARMv9.3-A
+    bool has_sme2 = (hwcap2 & HWCAP2_SME2) != 0; // optional from v9.2
+
+    // ARMv8.8-A
+    bool has_mops = (hwcap2 & HWCAP2_MOPS) != 0; // optional from v8.7
+
+    // ARMv8.9-A
+    bool has_cssc = (hwcap2 & HWCAP2_CSSC) != 0; // optional from v8.7
+
+    // ARMv9.4-A
+    bool has_sme2p1 = (hwcap2 & HWCAP2_SME2P1) != 0; // optional from v9.2
+
+    // ARMv9.5-A
+    bool has_f8e4m3 = (hwcap2 & HWCAP2_F8E4M3) != 0; // optional from v9.2
+    bool has_f8e5m2 = (hwcap2 & HWCAP2_F8E5M2) != 0; // optional from v9.2
+
+    // ARMv9.6-A
+    bool has_cmpbr = (hwcap & HWCAP_CMPBR) != 0; // optional from v9.5
+    bool has_fprcvt = (hwcap & HWCAP_FPRCVT) != 0; // optional from v9.5
+
+    if (has_sve2 || has_sme) {
+        // ARMv9
+        if (has_cmpbr && has_fprcvt) {
+            cpu->march = "ARMv9.6-A";
+        } else if (has_f8e5m2 && has_f8e4m3) {
+            cpu->march = "ARMv9.5-A";
+        } else if (has_sme2p1) {
+            cpu->march = "ARMv9.4-A";
+        } else if (has_sme2) {
+            cpu->march = "ARMv9.3-A";
+        } else if (has_sme) {
+            cpu->march = "ARMv9.2-A";
+        } else if (has_i8mm && has_bf16) {
+            cpu->march = "ARMv9.1-A";
+        } else {
+            cpu->march = "ARMv9.0-A";
+        }
+    } else {
+        // ARMv8
+        if (has_cssc) {
+            cpu->march = "ARMv8.9-A";
+        } else if (has_mops) {
+            cpu->march = "ARMv8.8-A";
+        } else if (has_afp) {
+            cpu->march = "ARMv8.7-A";
+        } else if (has_i8mm && has_bf16) {
+            cpu->march = "ARMv8.6-A";
+        } else if (has_bti && has_sb && has_dcpodp && has_flagm2 && has_frint) {
+            cpu->march = "ARMv8.5-A";
+        } else if (has_dit && has_flagm && has_ilrcpc) {
+            cpu->march = "ARMv8.4-A";
+        } else if (has_paca && has_lrcpc && has_fcma && has_jscvt) {
+            cpu->march = "ARMv8.3-A";
+        } else if (has_fphp && has_dcpop) {
+            cpu->march = "ARMv8.2-A";
+        } else if (has_atomics && has_crc32 && has_asimdrdm) {
+            cpu->march = "ARMv8.1-A";
+        } else if (has_asimd && has_fp) {
+            cpu->march = "ARMv8-A";
+        }
+    }
+}
+#elif __APPLE__
+#include <sys/sysctl.h>
+// #include <arm/cpu_capabilities_public.h> // Not available in macOS 14-
+
+void ffCPUDetectByCpuid(FFCPUResult* cpu)
+{
+    uint64_t caps[2] = {0}; // 80-bit capability mask, split into two 64-bit values
+    size_t size = sizeof(caps);
+
+    if (sysctlbyname("hw.optional.arm.caps", caps, &size, NULL, 0) != 0) return;
+
+    // Helper macro to test bit in 80-bit capability mask
+    #define FF_HAS_CAP(bit) \
+        (((bit) < 64) ? ((caps[0] >> (bit)) & 1ULL) : ((caps[1] >> ((bit) - 64U)) & 1ULL))
+
+    cpu->march = "unknown";
+
+    // ARMv8-A
+    bool has_fp        = FF_HAS_CAP(50); /* CAP_BIT_AdvSIMD_HPFPCvt */ // Full FP16 support (implies FP/ASIMD)
+    bool has_asimd     = FF_HAS_CAP(49); /* CAP_BIT_AdvSIMD */         // Advanced SIMD (NEON)
+
+    // ARMv8.1-A
+    bool has_lse       = FF_HAS_CAP(6);  /* CAP_BIT_FEAT_LSE */        // Large System Extensions, optional in v8.0
+    bool has_crc32     = FF_HAS_CAP(51); /* CAP_BIT_FEAT_CRC32 */      // CRC32 instructions, optional in v8.0
+    bool has_rdm       = FF_HAS_CAP(5);  /* CAP_BIT_FEAT_RDM */        // AdvSIMD rounding double multiply accumulate, optional in v8.0
+
+    // ARMv8.2-A
+    bool has_fp16      = FF_HAS_CAP(34); /* CAP_BIT_FEAT_FP16 */       // Half-precision FP support, optional
+    bool has_dpb       = FF_HAS_CAP(22); /* CAP_BIT_FEAT_DPB */        // DC CVAP, optional from v8.1
+
+    // ARMv8.3-A
+    bool has_pauth     = FF_HAS_CAP(19); /* CAP_BIT_FEAT_PAuth */      // Pointer Authentication (PAC), optional from v8.2
+    bool has_lrcpc     = FF_HAS_CAP(15); /* CAP_BIT_FEAT_LRCPC */      // LDAPR/LR with RCPC semantics, optional from v8.2
+    bool has_fcma      = FF_HAS_CAP(17); /* CAP_BIT_FEAT_FCMA */       // Complex number multiply-add, optional from v8.2
+    bool has_jscvt     = FF_HAS_CAP(18); /* CAP_BIT_FEAT_JSCVT */      // JavaScript-style conversion (FJCVTZS), optional from v8.2
+
+    // ARMv8.4-A
+    bool has_lse2      = FF_HAS_CAP(30); /* CAP_BIT_FEAT_LSE2 */       // Large System Extensions version 2, optional from v8.2
+    bool has_dit       = FF_HAS_CAP(33); /* CAP_BIT_FEAT_DIT */        // Data Independent Timing, optional from v8.3
+    bool has_flagm     = FF_HAS_CAP(0);  /* CAP_BIT_FEAT_FlagM */      // Flag manipulation (FMOV/FCVT), optional from v8.1
+    bool has_lrcpc2    = FF_HAS_CAP(16); /* CAP_BIT_FEAT_LRCPC2 */     // Enhanced RCPC (LDAPUR/LDAPST), optional from v8.2
+
+    // ARMv8.5-A
+    bool has_bti       = FF_HAS_CAP(36); /* CAP_BIT_FEAT_BTI */        // Branch Target Identification, optional from v8.4
+    bool has_sb        = FF_HAS_CAP(13); /* CAP_BIT_FEAT_SB */         // Speculative Barrier, optional from v8.0
+    bool has_dpb2      = FF_HAS_CAP(23); /* CAP_BIT_FEAT_DPB2 */       // DC CVADP (DPB2), optional from v8.1
+    bool has_flagm2    = FF_HAS_CAP(1);  /* CAP_BIT_FEAT_FlagM2 */     // Enhanced FlagM, optional from v8.4
+    bool has_frintts   = FF_HAS_CAP(14); /* CAP_BIT_FEAT_FRINTTS */    // Floating-point to integer instructions, optional from v8.4
+
+    // ARMv9.0-A
+    bool has_sve2      = false;                                        // Not exposed and not supported by Apple M4
+
+    // ARMv9.1-A
+    // ARMv8.6-A
+    bool has_bf16      = FF_HAS_CAP(24); /* CAP_BIT_FEAT_BF16 */       // Brain float16, optional from v8.2
+    bool has_i8mm      = FF_HAS_CAP(25); /* CAP_BIT_FEAT_I8MM */       // Int8 Matrix Multiply, optional from v8.1
+
+    // ARMv8.7-A
+    bool has_afp       = FF_HAS_CAP(29); /* CAP_BIT_FEAT_AFP */        // Alternate FP16 (FEXPA), optional from v8.6
+
+    // ARMv9.2-A
+    bool has_sme       = FF_HAS_CAP(40); /* CAP_BIT_FEAT_SME */        // Scalable Matrix Extension, optional from v9.2
+
+    // ARMv9.3-A
+    bool has_sme2      = FF_HAS_CAP(41); /* CAP_BIT_FEAT_SME2 */       // SME2, optional from v9.2
+
+    // ARMv8.8-A
+    bool has_hbc       = FF_HAS_CAP(64); /* CAP_BIT_FEAT_HBC */        // Hinted conditional branches, optional from v8.7
+
+    // ARMv8.9-A
+    bool has_cssc      = FF_HAS_CAP(67); /* CAP_BIT_FEAT_CSSC */       // Common Short String Compare, optional from v8.7
+
+    // ARMv9.4-A+ are not exposed yet
+
+    if (has_sve2 || has_sme) {
+        // ARMv9 family
+        if (has_sme2) {
+            cpu->march = "ARMv9.3-A";
+        } else if (has_sme) {
+            cpu->march = "ARMv9.2-A";
+        } else if (has_i8mm && has_bf16) {
+            cpu->march = "ARMv9.1-A";
+        } else {
+            cpu->march = "ARMv9.0-A";
+        }
+    } else {
+        // ARMv8 family
+        if (has_cssc) {
+            cpu->march = "ARMv8.9-A";
+        } else if (has_hbc) {
+            cpu->march = "ARMv8.8-A";
+        } else if (has_afp) {
+            cpu->march = "ARMv8.7-A";
+        } else if (has_i8mm && has_bf16) {
+            cpu->march = "ARMv8.6-A";
+        } else if (has_bti && has_sb && has_dpb2 && has_flagm2 && has_frintts) {
+            cpu->march = "ARMv8.5-A";
+        } else if (has_lse2 && has_dit && has_flagm && has_lrcpc2) {
+            cpu->march = "ARMv8.4-A";
+        } else if (has_pauth && has_lrcpc && has_fcma && has_jscvt) {
+            cpu->march = "ARMv8.3-A";
+        } else if (has_fp16 && has_dpb) {
+            cpu->march = "ARMv8.2-A";
+        } else if (has_lse && has_crc32 && has_rdm) {
+            cpu->march = "ARMv8.1-A";
+        } else if (has_asimd && has_fp) {
+            cpu->march = "ARMv8-A";
+        }
+    }
+
+    #undef HAS_CAP
+}
+#elif _WIN32
+#include <processthreadsapi.h>
+
+// Missing from winnt.h of MinGW-w64
+#define PF_ARM_LSE2_AVAILABLE                       62
+#define PF_RESERVED_FEATURE                         63
+#define PF_ARM_SHA3_INSTRUCTIONS_AVAILABLE          64
+#define PF_ARM_SHA512_INSTRUCTIONS_AVAILABLE        65
+#define PF_ARM_V82_I8MM_INSTRUCTIONS_AVAILABLE      66
+#define PF_ARM_V82_FP16_INSTRUCTIONS_AVAILABLE      67
+#define PF_ARM_V86_BF16_INSTRUCTIONS_AVAILABLE      68
+#define PF_ARM_V86_EBF16_INSTRUCTIONS_AVAILABLE     69
+#define PF_ARM_SME_INSTRUCTIONS_AVAILABLE           70
+#define PF_ARM_SME2_INSTRUCTIONS_AVAILABLE          71
+#define PF_ARM_SME2_1_INSTRUCTIONS_AVAILABLE        72
+#define PF_ARM_SME2_2_INSTRUCTIONS_AVAILABLE        73
+#define PF_ARM_SME_AES_INSTRUCTIONS_AVAILABLE       74
+#define PF_ARM_SME_SBITPERM_INSTRUCTIONS_AVAILABLE  75
+#define PF_ARM_SME_SF8MM4_INSTRUCTIONS_AVAILABLE    76
+#define PF_ARM_SME_SF8MM8_INSTRUCTIONS_AVAILABLE    77
+#define PF_ARM_SME_SF8DP2_INSTRUCTIONS_AVAILABLE    78
+#define PF_ARM_SME_SF8DP4_INSTRUCTIONS_AVAILABLE    79
+#define PF_ARM_SME_SF8FMA_INSTRUCTIONS_AVAILABLE    80
+#define PF_ARM_SME_F8F32_INSTRUCTIONS_AVAILABLE     81
+#define PF_ARM_SME_F8F16_INSTRUCTIONS_AVAILABLE     82
+#define PF_ARM_SME_F16F16_INSTRUCTIONS_AVAILABLE    83
+#define PF_ARM_SME_B16B16_INSTRUCTIONS_AVAILABLE    84
+#define PF_ARM_SME_F64F64_INSTRUCTIONS_AVAILABLE    85
+#define PF_ARM_SME_I16I64_INSTRUCTIONS_AVAILABLE    86
+#define PF_ARM_SME_LUTv2_INSTRUCTIONS_AVAILABLE     87
+#define PF_ARM_SME_FA64_INSTRUCTIONS_AVAILABLE      88
+
+void ffCPUDetectByCpuid(FFCPUResult* cpu)
+{
+    // ARMv8-A
+    bool has_vfp       = IsProcessorFeaturePresent(PF_ARM_VFP_32_REGISTERS_AVAILABLE); // Implies basic FP support
+    bool has_neon      = IsProcessorFeaturePresent(PF_ARM_NEON_INSTRUCTIONS_AVAILABLE); // NEON (ASIMD)
+
+    // ARMv8.1-A
+    bool has_atomics   = IsProcessorFeaturePresent(PF_ARM_V81_ATOMIC_INSTRUCTIONS_AVAILABLE); // LSE atomics
+    bool has_crc32     = IsProcessorFeaturePresent(PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE); // CRC32
+
+    // ARMv8.2-A
+    bool has_fp16      = IsProcessorFeaturePresent(PF_ARM_V82_FP16_INSTRUCTIONS_AVAILABLE); // Half-precision FP
+
+    // ARMv8.3-A
+    bool has_lrcpc     = IsProcessorFeaturePresent(PF_ARM_V83_LRCPC_INSTRUCTIONS_AVAILABLE); // LDAPR/LR with RCPC semantics
+    bool has_jscvt     = IsProcessorFeaturePresent(PF_ARM_V83_JSCVT_INSTRUCTIONS_AVAILABLE); // FJCVTZS
+
+    // ARMv8.4-A
+    // My CPU (Apple M1 Pro in VM) does support LSE2, but Windows doesn't detect it for some reason
+    // bool has_lse2      = IsProcessorFeaturePresent(PF_ARM_LSE2_AVAILABLE); // Large System Extensions version 2, optional from v8.2
+    bool has_dp        = IsProcessorFeaturePresent(PF_ARM_V82_DP_INSTRUCTIONS_AVAILABLE); // DotProd, optional from v8.1 (*)
+
+    // ARMv9.0-A
+    bool has_sve2      = IsProcessorFeaturePresent(PF_ARM_SVE2_INSTRUCTIONS_AVAILABLE); // SVE2
+
+    // ARMv9.1-A
+    // ARMv8.6-A
+    bool has_bf16      = IsProcessorFeaturePresent(PF_ARM_V86_BF16_INSTRUCTIONS_AVAILABLE); // BF16, optional from v8.2
+    bool has_i8mm      = IsProcessorFeaturePresent(PF_ARM_V82_I8MM_INSTRUCTIONS_AVAILABLE); // Int8 matrix multiply, optional from v8.2
+
+    // ARMv8.7-A
+    bool has_ebf16     = IsProcessorFeaturePresent(PF_ARM_V86_EBF16_INSTRUCTIONS_AVAILABLE); // Extended BFloat16 behaviors, optional from v8.2
+
+    // ARMv9.2-A
+    bool has_sme       = IsProcessorFeaturePresent(PF_ARM_SME_INSTRUCTIONS_AVAILABLE); // SME
+
+    // ARMv9.3-A
+    bool has_sme2      = IsProcessorFeaturePresent(PF_ARM_SME2_INSTRUCTIONS_AVAILABLE); // SME2
+
+    // ARMv9.4-A
+    bool has_sme2p1    = IsProcessorFeaturePresent(PF_ARM_SME2_1_INSTRUCTIONS_AVAILABLE); // SME2.1
+
+
+    if (has_sve2 || has_sme)
+    {
+        // ARMv9 family
+        if (has_sme2p1) {
+            cpu->march = "ARMv9.4-A";
+        } else if (has_sme2) {
+            cpu->march = "ARMv9.3-A";
+        } else if (has_sme) {
+            cpu->march = "ARMv9.2-A";
+        } else if (has_i8mm && has_bf16) {
+            cpu->march = "ARMv9.1-A";
+        } else {
+            cpu->march = "ARMv9.0-A";
+        }
+    }
+    else
+    {
+        // ARMv8 family
+        if (has_ebf16) {
+            cpu->march = "ARMv8.7-A";
+        } else if (has_i8mm && has_bf16) {
+            cpu->march = "ARMv8.6-A";
+        } else if (has_dp) {
+            cpu->march = "ARMv8.4-A";
+        } else if (has_lrcpc && has_jscvt) {
+            cpu->march = "ARMv8.3-A";
+        } else if (has_fp16) {
+            cpu->march = "ARMv8.2-A";
+        } else if (has_atomics && has_crc32) {
+            cpu->march = "ARMv8.1-A";
+        } else if (has_neon && has_vfp) {
+            cpu->march = "ARMv8-A";
+        }
+    }
+}
+#else
+void ffCPUDetectByCpuid(FF_MAYBE_UNUSED FFCPUResult* cpu)
+{
+    // Unsupported system
+}
+#endif
+
+#else
+
+void ffCPUDetectByCpuid(FF_MAYBE_UNUSED FFCPUResult* cpu)
+{
+    // Unsupported architecture
+}
+
+#endif
@@ -1,8 +1,9 @@
 #pragma once

 #include "fastfetch.h"
+#include "modules/cpu/option.h"

-#define FF_CPU_TEMP_UNSET (0/0.0)
+#define FF_CPU_TEMP_UNSET (-DBL_MAX)

 typedef struct FFCPUCore
 {
@@ -14,6 +15,7 @@ typedef struct FFCPUResult
 {
    FFstrbuf name;
    FFstrbuf vendor;
+    const char* march; // Microarchitecture

    uint16_t packages;
    uint16_t coresPhysical;
@@ -31,29 +33,4 @@ typedef struct FFCPUResult
 const char* ffDetectCPU(const FFCPUOptions* options, FFCPUResult* cpu);
 const char* ffCPUAppleCodeToName(uint32_t code);
 const char* ffCPUQualcommCodeToName(uint32_t code);
-
-#if defined(__x86_64__) || defined(__i386__)
-
-#include <cpuid.h>
-
-// WARNING: CPUID may report frequencies of efficient cores
-inline static const char* ffCPUDetectSpeedByCpuid(FFCPUResult* cpu)
-{
-    uint32_t base = 0, max = 0, bus = 0, unused = 0;
-    if (!__get_cpuid(0x16, &base, &max, &bus, &unused))
-        return "Unsupported instruction";
-
-    // cpuid returns 0 MHz when hyper-v is enabled
-    if (base) cpu->frequencyBase = base;
-    if (max) cpu->frequencyMax = max;
-    return NULL;
-}
-
-#else
-
-inline static const char* ffCPUDetectSpeedByCpuid(FF_MAYBE_UNUSED FFCPUResult* cpu)
-{
-    return "Unsupported platform";
-}
-
-#endif
+void ffCPUDetectByCpuid(FFCPUResult* cpu);
@@ -126,6 +126,7 @@ const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
    if(cpu->coresOnline == 1)
        cpu->coresOnline = (uint16_t) ffSysctlGetInt("hw.activecpu", 1);

+    ffCPUDetectByCpuid(cpu);
    detectFrequency(cpu);
    if (options->showPeCoreCount) detectCoreCount(cpu);

@@ -106,9 +106,14 @@ static const char* armPartId2name(uint32_t partId)
    case 0xd80: return "Cortex-A520";
    case 0xd81: return "Cortex-A720";
    case 0xd82: return "Cortex-X4";
+    case 0xd83: return "Neoverse-V3AE";
    case 0xd84: return "Neoverse-V3";
    case 0xd85: return "Cortex-X925";
    case 0xd87: return "Cortex-A725";
+    case 0xd88: return "Cortex-A520AE";
+    case 0xd89: return "Cortex-A720AE";
+    case 0xd8e: return "Neoverse-N3";
+    case 0xd8f: return "Cortex-A320";
    default: return NULL;
    }
 }
@@ -314,6 +319,7 @@ static const char* fujitsuPartId2name(uint32_t partId)
    switch (partId)
    {
    case 0x001: return "A64FX";
+    case 0x003: return "MONAKA";
    default: return NULL;
    }
 }
@@ -1,5 +1,6 @@
 #include "cpu.h"
 #include "common/sysctl.h"
+#include "util/stringUtils.h"

 #include <sys/param.h>
 #if __has_include(<sys/cpuset.h>)
@@ -34,36 +35,30 @@ const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
    if (ffSysctlGetString("hw.model", &cpu->name) != NULL)
        return "sysctlbyname(hw.model) failed";

-    cpu->coresPhysical = (uint16_t) ffSysctlGetInt("hw.ncpu", 1);
-    cpu->coresLogical = cpu->coresPhysical;
+    cpu->coresLogical = (uint16_t) ffSysctlGetInt("hw.ncpu", 1);
+    cpu->coresPhysical = (uint16_t) ffSysctlGetInt("kern.smp.cores", 0);
    cpu->coresOnline = (uint16_t) ffSysctlGetInt("kern.smp.cpus", cpu->coresLogical);

    FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
    if (ffSysctlGetString("kern.sched.topology_spec", &buffer) == NULL && buffer.length > 0)
    {
        // <groups>
-        // <group level="1" cache-level="3">
-        // <cpu count="4" mask="f,0,0,0">0, 1, 2, 3</cpu>
-        // <children>
-        // <group level="2" cache-level="2">
-        // <cpu count="2" mask="3,0,0,0">0, 1</cpu>
-        // <flags><flag name="THREAD">THREAD group</flag><flag name="SMT">SMT group</flag></flags>
-        // </group>
-        // <group level="2" cache-level="2">
-        // <cpu count="2" mask="c,0,0,0">2, 3</cpu>
-        // <flags><flag name="THREAD">THREAD group</flag><flag name="SMT">SMT group</flag></flags>
-        // </group>
-        // </children>
-        // </group>
+        //  <group level="1" cache-level="3">
+        //   <cpu count="4" mask="f,0,0,0">0, 1, 2, 3</cpu>
+        //   <children>
+        //    <group level="2" cache-level="2">
+        //     <cpu count="2" mask="3,0,0,0">0, 1</cpu>
+        //     <flags><flag name="THREAD">THREAD group</flag><flag name="SMT">SMT group</flag></flags>
+        //    </group>
+        //    <group level="2" cache-level="2">
+        //     <cpu count="2" mask="c,0,0,0">2, 3</cpu>
+        //     <flags><flag name="THREAD">THREAD group</flag><flag name="SMT">SMT group</flag></flags>
+        //    </group>
+        //   </children>
+        //  </group>
        // </groups>
-        uint32_t i = 0;
-        while (true)
-        {
-            i = ffStrbufNextIndexS(&buffer, i, "<flag name=\"THREAD\">THREAD group</flag>"); // Find physical core with hyper-threading enabled
-            if (i >= buffer.length) break;
-            cpu->coresPhysical--;
-            i += (uint32_t) strlen("<flag name=\"THREAD\">THREAD group</flag>");
-        }
+        for (char* p = buffer.chars; (p = strstr(p, "\n </group>\n")); ++p)
+            cpu->packages++;
    }

 #if FF_HAVE_CPUSET && (__x86_64__ || __i386__)
@@ -75,10 +70,28 @@ const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
    cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID, -1, sizeof(cpuset_t), &currentCPU);
 #endif

-    ffCPUDetectSpeedByCpuid(cpu);
+    ffCPUDetectByCpuid(cpu);

    uint32_t clockrate = (uint32_t) ffSysctlGetInt("hw.clockrate", 0);
    if (clockrate > cpu->frequencyBase) cpu->frequencyBase = clockrate;
+
+    for (uint16_t i = 0; i < cpu->coresLogical; ++i)
+    {
+        ffStrbufClear(&buffer);
+        char key[32];
+        snprintf(key, sizeof(key), "dev.cpu.%u.freq_levels", i);
+        if (ffSysctlGetString(key, &buffer) == NULL)
+        {
+            if (buffer.length == 0) continue;
+
+            // MHz/Watts pairs like: 2501/32000 2187/27125 2000/24000
+            uint32_t fmax = (uint32_t) strtoul(buffer.chars, NULL, 10);
+            if (cpu->frequencyMax < fmax) cpu->frequencyMax = fmax;
+        }
+        else
+            break;
+    }
+
    cpu->temperature = FF_CPU_TEMP_UNSET;

    if (options->temp)
@@ -55,7 +55,7 @@ const char* ffDetectCPUImpl(FF_MAYBE_UNUSED const FFCPUOptions* options, FFCPURe
        ffStrbufSetF(&cpu->name, "(Unknown %" B_PRIx32 ")", cpuModel);
    ffStrbufSetS(&cpu->vendor, get_cpu_vendor_string(cpuVendor));

-    ffCPUDetectSpeedByCpuid(cpu);
+    ffCPUDetectByCpuid(cpu);
    if (cpu->frequencyBase < frequency) cpu->frequencyBase = frequency;
    cpu->packages = packages;
    cpu->coresPhysical = cores;
@@ -9,87 +9,133 @@
 #include <stdlib.h>
 #include <unistd.h>
 #include <dirent.h>
+#include <fcntl.h>

 #define FF_CPUINFO_PATH "/proc/cpuinfo"

-static double parseHwmonDir(FFstrbuf* dir, FFstrbuf* buffer)
+static double parseTZDir(int dfd, FFstrbuf* buffer)
 {
-    //https://www.kernel.org/doc/Documentation/hwmon/sysfs-interface
-    uint32_t dirLength = dir->length;
-    ffStrbufAppendS(dir, "temp1_input");
+    if (!ffReadFileBufferRelative(dfd, "type", buffer))
+        return FF_CPU_TEMP_UNSET;

-    if(!ffReadFileBuffer(dir->chars, buffer))
-    {
-        // Some badly implemented system put temp file in /hwmonN/device
-        ffStrbufSubstrBefore(dir, dirLength);
-        ffStrbufAppendS(dir, "device/");
-        dirLength = dir->length;
-        ffStrbufAppendS(dir, "temp1_input");
+    if (!ffStrbufStartsWithS(buffer, "cpu") &&
+        !ffStrbufStartsWithS(buffer, "soc") &&
+        #if __x86_64__ || __i386__
+        !ffStrbufEqualS(buffer, "x86_pkg_temp") &&
+        #endif
+        true
+    ) return FF_CPU_TEMP_UNSET;

-        if(!ffReadFileBuffer(dir->chars, buffer))
-            return 0.0/0.0;
-    }
+    if (!ffReadFileBufferRelative(dfd, "temp", buffer))
+        return FF_CPU_TEMP_UNSET;

-    ffStrbufSubstrBefore(dir, dirLength);
+    double value = ffStrbufToDouble(buffer, FF_CPU_TEMP_UNSET);// millidegree Celsius
+    if (value == FF_CPU_TEMP_UNSET)
+        return FF_CPU_TEMP_UNSET;

-    double value = ffStrbufToDouble(buffer);// millidegree Celsius
+    return value / 1000.;
+}

-    if(value != value)
-        return 0.0/0.0;
-
-    ffStrbufAppendS(dir, "name");
-    if (!ffReadFileBuffer(dir->chars, buffer))
-        return 0.0/0.0;
+static double parseHwmonDir(int dfd, FFstrbuf* buffer)
+{
+    if (!ffReadFileBufferRelative(dfd, "name", buffer))
+        return FF_CPU_TEMP_UNSET;

    ffStrbufTrimRightSpace(buffer);

-    if(
-        ffStrbufContainS(buffer, "cpu") ||
-        ffStrbufEqualS(buffer, "k10temp") || // AMD
-        ffStrbufEqualS(buffer, "fam15h_power") || // AMD
-        ffStrbufEqualS(buffer, "coretemp") // Intel
-    ) return value / 1000.;
+    if (
+        !ffStrbufContainS(buffer, "cpu") &&
+        #if __x86_64__ || __i386__
+        !ffStrbufEqualS(buffer, "k10temp") && // AMD
+        !ffStrbufEqualS(buffer, "fam15h_power") && // AMD
+        !ffStrbufEqualS(buffer, "coretemp") && // Intel
+        #endif
+        true
+    ) return FF_CPU_TEMP_UNSET;

-    return 0.0/0.0;
-}
+    //https://www.kernel.org/doc/Documentation/hwmon/sysfs-interface
+    if (!ffReadFileBufferRelative(dfd, "temp1_input", buffer))
+        return FF_CPU_TEMP_UNSET;

-static double detectTZTemp(FFstrbuf* buffer)
-{
-    if (ffReadFileBuffer("/sys/class/thermal/thermal_zone0/temp", buffer))
-        return ffStrbufToDouble(buffer) / 1000.;
-    return 0.0/0.0;
+    double value = ffStrbufToDouble(buffer, FF_CPU_TEMP_UNSET);// millidegree Celsius
+    if (value == FF_CPU_TEMP_UNSET)
+        return FF_CPU_TEMP_UNSET;
+
+    return value / 1000.;
 }

 static double detectCPUTemp(void)
 {
-    FF_STRBUF_AUTO_DESTROY baseDir = ffStrbufCreateA(64);
-    ffStrbufAppendS(&baseDir, "/sys/class/hwmon/");
-
    FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
-
-    uint32_t baseDirLength = baseDir.length;
-
-    FF_AUTO_CLOSE_DIR DIR* dirp = opendir(baseDir.chars);
-    if(dirp == NULL)
-        return 0.0/0.0;
-
-    struct dirent* entry;
-    while((entry = readdir(dirp)) != NULL)
    {
-        if(entry->d_name[0] == '.')
-            continue;
+        FF_AUTO_CLOSE_DIR DIR* dirp = opendir("/sys/class/hwmon/");
+        if(dirp)
+        {
+            int dfd = dirfd(dirp);
+            struct dirent* entry;
+            while((entry = readdir(dirp)) != NULL)
+            {
+                if(entry->d_name[0] == '.')
+                    continue;

-        ffStrbufAppendS(&baseDir, entry->d_name);
-        ffStrbufAppendC(&baseDir, '/');
+                FF_AUTO_CLOSE_FD int subfd = openat(dfd, entry->d_name, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
+                if(subfd < 0)
+                    continue;

-        double result = parseHwmonDir(&baseDir, &buffer);
-        if (result == result)
-            return result;
+                double result = parseHwmonDir(subfd, &buffer);
+                if (result != FF_CPU_TEMP_UNSET)
+                    return result;
+            }
+        }
+    }
+    {
+        FF_AUTO_CLOSE_DIR DIR* dirp = opendir("/sys/class/thermal/");
+        if(dirp)
+        {
+            int dfd = dirfd(dirp);
+            struct dirent* entry;
+            while((entry = readdir(dirp)) != NULL)
+            {
+                if(entry->d_name[0] == '.')
+                    continue;
+                if(!ffStrStartsWith(entry->d_name, "thermal_zone"))
+                    continue;

-        ffStrbufSubstrBefore(&baseDir, baseDirLength);
+                FF_AUTO_CLOSE_FD int subfd = openat(dfd, entry->d_name, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
+                if(subfd < 0)
+                    continue;
+
+                double result = parseTZDir(subfd, &buffer);
+                if (result != FF_CPU_TEMP_UNSET)
+                    return result;
+            }
+        }
+    }
+    {
+        FF_AUTO_CLOSE_DIR DIR* dirp = opendir("/sys/devices/platform/");
+        if(dirp)
+        {
+            int dfd = dirfd(dirp);
+            struct dirent* entry;
+            while((entry = readdir(dirp)) != NULL)
+            {
+                if(entry->d_name[0] == '.')
+                    continue;
+                if(!ffStrStartsWith(entry->d_name, "cputemp."))
+                    continue;
+
+                FF_AUTO_CLOSE_FD int subfd = openat(dfd, entry->d_name, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
+                if(subfd < 0)
+                    continue;
+
+                double result = parseHwmonDir(subfd, &buffer);
+                if (result != FF_CPU_TEMP_UNSET)
+                    return result;
+            }
+        }
    }

-    return detectTZTemp(&buffer);
+    return FF_CPU_TEMP_UNSET;
 }

 #ifdef __ANDROID__
@@ -99,85 +145,75 @@ static void detectQualcomm(FFCPUResult* cpu)
 {
    // https://en.wikipedia.org/wiki/List_of_Qualcomm_Snapdragon_systems_on_chips

-    if (ffStrbufEqualS(&cpu->name, "SM8750-AC"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 8 Elite for Galaxy [SM8750-AC]");
-    else if (ffStrbufEqualS(&cpu->name, "SM8750-3"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 8 Elite [SM8750-3]");
-    else if (ffStrbufEqualS(&cpu->name, "SM8750"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 8 Elite [SM8750]");
-    else if (ffStrbufEqualS(&cpu->name, "SM8635"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 8s Gen 3 [SM8635]");
-    else if (ffStrbufEqualS(&cpu->name, "SM8650-AC"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 8 Gen 3 for Galaxy [SM8650-AC]");
-    else if (ffStrbufEqualS(&cpu->name, "SM8650"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 8 Gen 3 [SM8650]");
-    else if (ffStrbufEqualS(&cpu->name, "SM8550-AC"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 8 Gen 2 for Galaxy [SM8550-AC]");
-    else if (ffStrbufEqualS(&cpu->name, "SM8550"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 8 Gen 2 [SM8550]");
-    else if (ffStrbufEqualS(&cpu->name, "SM8475"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 8+ Gen 1 [SM8475]");
-    else if (ffStrbufEqualS(&cpu->name, "SM8450"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 8 Gen 1 [SM8450]");
+    uint32_t code = (uint32_t) strtoul(cpu->name.chars + 2, NULL, 10);
+    const char* name = NULL;

-    else if (ffStrbufEqualS(&cpu->name, "SM7675"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 7+ Gen 3 [SM7675]");
-    else if (ffStrbufEqualS(&cpu->name, "SM7635"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 7s Gen 3 [SM7635]");
-    else if (ffStrbufEqualS(&cpu->name, "SM7550"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 7 Gen 3 [SM7550]");
-    else if (ffStrbufEqualS(&cpu->name, "SM7475"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 7+ Gen 2 [SM7550]");
-    else if (ffStrbufEqualS(&cpu->name, "SM7435"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 7s Gen 2 [SM7435]");
-    else if (ffStrbufEqualS(&cpu->name, "SM7450"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 7 Gen 1 [SM7450]");
+    switch (code)
+    {
+        case 8735: name = "8s Gen 4"; break;
+        case 8750: name = "8 Elite"; break;
+        case 8635: name = "8s Gen 3"; break;
+        case 8650: name = "8 Gen 3"; break;
+        case 8550: name = "8 Gen 2"; break;
+        case 8475: name = "8+ Gen 1"; break;
+        case 8450: name = "8 Gen 1"; break;
+        case 7750: name = "7 Gen 4"; break;
+        case 7675: name = "7+ Gen 3"; break;
+        case 7635: name = "7s Gen 3"; break;
+        case 7550: name = "7 Gen 3"; break;
+        case 7475: name = "7+ Gen 2"; break;
+        case 7435: name = "7s Gen 2"; break;
+        case 7450: name = "7 Gen 1"; break;
+        case 6650: name = "6 Gen 4"; break;
+        case 6375: name = "6s Gen 3"; break;
+        case 6475: name = "6 Gen 3"; break;
+        case 6115: name = "6s Gen 1"; break;
+        case 6450: name = "6 Gen 1"; break;
+        case 4635: name = "4s Gen 2"; break;
+        case 4450: name = "4 Gen 2"; break;
+        case 4375: name = "4 Gen 1"; break;
+    }

-    else if (ffStrbufEqualS(&cpu->name, "SM6375-AC"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 6s Gen 3 [SM6375-AC]");
-    else if (ffStrbufEqualS(&cpu->name, "SM6475"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 6 Gen 3 [SM6475]");
-    else if (ffStrbufEqualS(&cpu->name, "SM6115"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 6s Gen 1 [SM6115]");
-    else if (ffStrbufEqualS(&cpu->name, "SM6450"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 6 Gen 1 [SM6450]");
-
-    else if (ffStrbufEqualS(&cpu->name, "SM4635"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 4s Gen 2 [SM4635]");
-    else if (ffStrbufEqualS(&cpu->name, "SM4450"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 4 Gen 2 [SM4450]");
-    else if (ffStrbufEqualS(&cpu->name, "SM4375"))
-        ffStrbufSetStatic(&cpu->name, "Qualcomm Snapdragon 4 Gen 1 [SM4375]");
+    if (name)
+    {
+        char str[32];
+        ffStrCopy(str, cpu->name.chars, sizeof(str));
+        ffStrbufSetF(&cpu->name, "Qualcomm Snapdragon %s [%s]", name, str);
+        return;
+    }
 }

 static void detectMediaTek(FFCPUResult* cpu)
 {
    // https://en.wikipedia.org/wiki/List_of_MediaTek_systems_on_chips

-    if (ffStrbufEqualS(&cpu->name, "MT6991"))
-        ffStrbufSetStatic(&cpu->name, "MediaTek Dimensity 9400 [MT6991]");
-    else if (ffStrbufEqualS(&cpu->name, "MT6991Z"))
-        ffStrbufSetStatic(&cpu->name, "MediaTek Dimensity 9400 [MT6991Z]");
-    else if (ffStrbufEqualS(&cpu->name, "MT6989Z"))
-        ffStrbufSetStatic(&cpu->name, "MediaTek Dimensity 9300+ [MT6989Z]");
-    else if (ffStrbufEqualS(&cpu->name, "MT8796Z"))
-        ffStrbufSetStatic(&cpu->name, "MediaTek Dimensity 9300+ [MT8796Z]");
-    else if (ffStrbufEqualS(&cpu->name, "MT6989"))
-        ffStrbufSetStatic(&cpu->name, "MediaTek Dimensity 9300 [MT6989]");
-    else if (ffStrbufEqualS(&cpu->name, "MT8796"))
-        ffStrbufSetStatic(&cpu->name, "MediaTek Dimensity 9300 [MT8796]");
-    else if (ffStrbufEqualS(&cpu->name, "MT6985W"))
-        ffStrbufSetStatic(&cpu->name, "MediaTek Dimensity 9200+ [MT6985W]");
-    else if (ffStrbufEqualS(&cpu->name, "MT6985"))
-        ffStrbufSetStatic(&cpu->name, "MediaTek Dimensity 9200 [MT6985]");
-    else if (ffStrbufEqualS(&cpu->name, "MT6983W"))
-        ffStrbufSetStatic(&cpu->name, "MediaTek Dimensity 9000+ [MT6983W]");
-    else if (ffStrbufEqualS(&cpu->name, "MT8798Z/T"))
-        ffStrbufSetStatic(&cpu->name, "MediaTek Dimensity 9000+ [MT8798Z/T]");
-    else if (ffStrbufEqualS(&cpu->name, "MT6983Z"))
-        ffStrbufSetStatic(&cpu->name, "MediaTek Dimensity 9000 [MT6983Z]");
-    else if (ffStrbufEqualS(&cpu->name, "MT8798Z/C"))
-        ffStrbufSetStatic(&cpu->name, "MediaTek Dimensity 9000 [MT8798Z/C]");
+    uint32_t code = (uint32_t) strtoul(cpu->name.chars + 2, NULL, 10);
+    const char* name = NULL;
+
+    switch (code) // The SOC code of MTK Dimensity series is full of mess
+    {
+        case 6991: name = "9400"; break;
+        case 6989:
+        case 8796: name = "9300"; break;
+        case 6985: name = "9200"; break;
+        case 6983:
+        case 8798: name = "9000"; break;
+
+        case 6899: name = "8400"; break;
+        case 6897:
+        case 8792: name = "8300"; break;
+        case 6896: name = "8200"; break;
+        case 8795: name = "8100"; break;
+        case 6895: name = "8000"; break;
+    }
+
+    if (name)
+    {
+        char str[32];
+        ffStrCopy(str, cpu->name.chars, sizeof(str));
+        ffStrbufSetF(&cpu->name, "MediaTek Dimensity %s [%s]", name, str);
+        return;
+    }
 }

 static void detectAndroid(FFCPUResult* cpu)
@@ -432,11 +468,11 @@ FF_MAYBE_UNUSED static uint16_t getPackageCount(FFstrbuf* cpuinfo)
    {
        p += strlen("\nphysical id\t:");
        char* pend;
-        unsigned long id = strtoul(p, &pend, 10);
+        unsigned long long id = strtoul(p, &pend, 10);
        if (__builtin_expect(id > 64, false)) // Do 129-socket boards exist?
-            high |= 1 << (id - 64);
+            high |= 1ULL << (id - 64);
        else
-            low |= 1 << id;
+            low |= 1ULL << id;
        p = pend;
    }

@@ -458,13 +494,11 @@ FF_MAYBE_UNUSED static const char* detectCPUX86(const FFCPUOptions* options, FFC
    cpu->coresOnline = (uint16_t) get_nprocs();
    cpu->packages = getPackageCount(&cpuinfo);
    cpu->coresPhysical = (uint16_t) ffStrbufToUInt(&physicalCoresBuffer, 0); // physical cores in single package
-    if (cpu->coresPhysical == 0)
-        cpu->coresPhysical = cpu->coresLogical;
-    else if (cpu->packages > 1)
+    if (cpu->coresPhysical > 0 && cpu->packages > 1)
        cpu->coresPhysical *= cpu->packages;

    // Ref https://github.com/fastfetch-cli/fastfetch/issues/1194#issuecomment-2295058252
-    ffCPUDetectSpeedByCpuid(cpu);
+    ffCPUDetectByCpuid(cpu);
    if (!detectFrequency(cpu, options) || cpu->frequencyBase == 0)
        cpu->frequencyBase = (uint32_t) ffStrbufToUInt(&cpuMHz, 0);

@@ -473,6 +507,82 @@ FF_MAYBE_UNUSED static const char* detectCPUX86(const FFCPUOptions* options, FFC

 #else

+static const char* detectPhysicalCores(FFCPUResult* cpu)
+{
+    int dfd = open("/sys/devices/system/cpu/", O_RDONLY | O_DIRECTORY | O_CLOEXEC);
+    if (dfd < 0) return "open(\"/sys/devices/system/cpu/\") failed";
+
+    FF_AUTO_CLOSE_DIR DIR* dir = fdopendir(dfd);
+    if (!dir) return "fdopendir(dfd) failed";
+
+    uint64_t pkgLow = 0, pkgHigh = 0;
+
+    struct dirent* entry;
+    FF_LIST_AUTO_DESTROY cpuList = ffListCreate(sizeof(uint32_t));
+    while ((entry = readdir(dir)) != NULL)
+    {
+        if (entry->d_type != DT_DIR || !ffStrStartsWith(entry->d_name, "cpu") || !ffCharIsDigit(entry->d_name[strlen("cpu")]))
+            continue;
+
+        FF_AUTO_CLOSE_FD int cpuxfd = openat(dirfd(dir), entry->d_name, O_RDONLY | O_DIRECTORY);
+        if (cpuxfd < 0)
+            continue;
+
+        char buf[128];
+
+        // Check if the directory contains a file named "topology/physical_package_id"
+        // that lists the physical package id of the CPU.
+
+        ssize_t len = ffReadFileDataRelative(cpuxfd, "topology/physical_package_id", sizeof(buf) - 1, buf);
+        if (len > 0)
+        {
+            buf[len] = '\0';
+            unsigned long long id = strtoul(buf, NULL, 10);
+            if (__builtin_expect(id > 64, false)) // Do 129-socket boards exist?
+                pkgHigh |= 1ULL << (id - 64);
+            else
+                pkgLow |= 1ULL << id;
+        }
+
+        // Check if the directory contains a file named "topology/core_cpus_list"
+        // that lists the physical cores in the package.
+
+        len = ffReadFileDataRelative(cpuxfd, "topology/core_cpus_list", sizeof(buf) - 1, buf);
+        if (len > 0)
+        {
+            buf[len] = '\0'; // low-high or low
+
+            for (const char* p = buf; *p;)
+            {
+                char* pend;
+                uint32_t coreId = (uint32_t) strtoul(p, &pend, 10);
+                if (pend == p) break;
+
+                bool found = false;
+                FF_LIST_FOR_EACH(uint32_t, id, cpuList)
+                {
+                    if (*id == coreId)
+                    {
+                        // This core is already counted
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found)
+                    *(uint32_t*) ffListAdd(&cpuList) = coreId;
+
+                p = strchr(pend, ',');
+                if (!p) break;
+                ++p;
+            }
+        }
+    }
+
+    cpu->coresPhysical = (uint16_t) cpuList.length;
+    cpu->packages = (uint16_t) (__builtin_popcountll(pkgLow) + __builtin_popcountll(pkgHigh));
+    return NULL;
+}
+
 FF_MAYBE_UNUSED static void parseIsa(FFstrbuf* cpuIsa)
 {
    // Always use the last part of the ISA string. Ref: #590 #1204
@@ -601,7 +711,7 @@ FF_MAYBE_UNUSED static uint16_t getLoongarchPropCount(FFstrbuf* cpuinfo, const c

 FF_MAYBE_UNUSED static const char* detectCPUOthers(const FFCPUOptions* options, FFCPUResult* cpu)
 {
-    cpu->coresPhysical = cpu->coresLogical = (uint16_t) get_nprocs_conf();
+    cpu->coresLogical = (uint16_t) get_nprocs_conf();
    cpu->coresOnline = (uint16_t) get_nprocs();

    #if __ANDROID__
@@ -663,6 +773,11 @@ FF_MAYBE_UNUSED static const char* detectCPUOthers(const FFCPUOptions* options,
        #endif
    }

+    if (cpu->coresPhysical == 0)
+        detectPhysicalCores(cpu);
+
+    ffCPUDetectByCpuid(cpu);
+
    return NULL;
 }
 #endif
@@ -18,8 +18,8 @@ static void freePropDict(prop_dictionary_t* pdict)

 static const char* detectCpuTemp(double* current)
 {
-    FF_AUTO_CLOSE_FD int fd = open(_PATH_SYSMON, O_RDONLY);
-    if (fd < 0) return "open(_PATH_SYSMON, O_RDONLY) failed";
+    FF_AUTO_CLOSE_FD int fd = open(_PATH_SYSMON, O_RDONLY | O_CLOEXEC);
+    if (fd < 0) return "open(_PATH_SYSMON, O_RDONLY | O_CLOEXEC) failed";

    __attribute__((__cleanup__(freePropDict))) prop_dictionary_t root = NULL;
    if (prop_dictionary_recv_ioctl(fd, ENVSYS_GETDICTIONARY, &root) < 0)
@@ -51,7 +51,8 @@ const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
 {
    if (ffSysctlGetString("machdep.cpu_brand", &cpu->name) != NULL &&
        ffSysctlGetString("machdep.dmi.processor-version", &cpu->name) != NULL &&
-        ffSysctlGetString("hw.cpu0.name", &cpu->name) != NULL)
+        ffSysctlGetString("hw.cpu0.name", &cpu->name) != NULL &&
+        ffSysctlGetString("hw.model", &cpu->name) != NULL)
    {
        ffStrbufSetS(&cpu->name, "Unknown CPU");
    }
@@ -63,10 +64,11 @@ const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
    cpu->coresLogical = cpu->coresPhysical;
    cpu->coresOnline = (uint16_t) ffSysctlGetInt("hw.ncpuonline", cpu->coresLogical);

-    ffCPUDetectSpeedByCpuid(cpu);
+    ffCPUDetectByCpuid(cpu);

    uint32_t freq = (uint32_t) ffSysctlGetInt("machdep.cpu.frequency.target", 0);
    if (freq == 0) freq = (uint32_t) (ffSysctlGetInt64("hw.cpu0.clock_frequency", 0) / 1000000);
+    if (freq == 0) freq = (uint32_t) ffSysctlGetInt("machdep.dmi.processor-frequency", 0);
    if (freq > cpu->frequencyBase) cpu->frequencyBase = freq;

    cpu->temperature = FF_CPU_TEMP_UNSET;
@@ -1,10 +1,53 @@
 #include "cpu.h"
 #include "common/sysctl.h"
+#include "util/stringUtils.h"

+#include <errno.h>
 #include <sys/time.h>
 #include <sys/sensors.h>

-const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
+static const char* detectCPUTemp(FFCPUResult* cpu)
+{
+    int mib[5] = {CTL_HW, HW_SENSORS, 0, SENSOR_TEMP, 0};
+
+    for (mib[2] = 0; mib[2] < 1024; mib[2]++)
+    {
+        struct sensordev sensordev;
+        size_t sdlen = sizeof(struct sensordev);
+        if (sysctl(mib, 3, &sensordev, &sdlen, NULL, 0) < 0)
+        {
+            if (errno == ENOENT)
+                break;
+            if (errno == ENXIO)
+                continue;
+            return "sysctl(sensordev) failed";
+        }
+
+        if (!ffStrStartsWith(sensordev.xname, "cpu"))
+            continue;
+
+        for (mib[4] = 0; mib[4] < sensordev.maxnumt[SENSOR_TEMP]; mib[4]++)
+        {
+            struct sensor sensor;
+            size_t slen = sizeof(struct sensor);
+            if (sysctl(mib, 5, &sensor, &slen, NULL, 0) < 0)
+            {
+                if (errno != ENOENT)
+                    return "sysctl(sensor) failed";
+                continue;
+            }
+            if (sensor.flags & SENSOR_FINVALID)
+                continue;
+
+            cpu->temperature = (double)(sensor.value - 273150000) / 1E6;
+            return NULL;
+        }
+    }
+
+    return "No sensor for CPU temp found";
+}
+
+const char *ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
 {
    if (ffSysctlGetString(CTL_HW, HW_MODEL, &cpu->name))
        return "sysctl(hw.model) failed";
@@ -13,19 +56,13 @@ const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
    cpu->coresLogical = cpu->coresPhysical;
    cpu->coresOnline = (uint16_t) ffSysctlGetInt(CTL_HW, HW_NCPUONLINE, cpu->coresLogical);

-    ffCPUDetectSpeedByCpuid(cpu);
+    ffCPUDetectByCpuid(cpu);

    uint32_t cpuspeed = (uint32_t) ffSysctlGetInt(CTL_HW, HW_CPUSPEED, 0);
    if (cpuspeed > cpu->frequencyBase) cpu->frequencyBase = cpuspeed;

    cpu->temperature = FF_CPU_TEMP_UNSET;
-    if (options->temp)
-    {
-        struct sensor sensors;
-        size_t size = sizeof(sensors);
-        if (sysctl((int[]) {CTL_HW, HW_SENSORS, 0, SENSOR_TEMP, 0}, 5, &sensors, &size, NULL, 0) == 0)
-            cpu->temperature = (double) (sensors.value - 273150000) / 1E6;
-    }
+    if (options->temp) detectCPUTemp(cpu);

    return NULL;
 }
@@ -1,6 +1,60 @@
 #include "cpu.h"
+#include "common/processing.h"
+#include "util/stringUtils.h"
 #include <kstat.h>

+static const char* detectCPUTempByKstat(kstat_ctl_t* kc, FFCPUResult* cpu)
+{
+    const char* possibleModules[] = {"temperature", "cpu_temp", "acpi_thermal", NULL};
+
+    for (int i = 0; possibleModules[i] != NULL; i++) {
+        kstat_t* ks = kstat_lookup(kc, possibleModules[i], -1, NULL);
+        if (ks && kstat_read(kc, ks, NULL) >= 0) {
+            kstat_named_t* kn = kstat_data_lookup(ks, "temperature");
+            if (kn) {
+                switch (kn->data_type) {
+                    case KSTAT_DATA_INT32:
+                        cpu->temperature = (float)kn->value.i32;
+                        return NULL;
+                    case KSTAT_DATA_UINT32:
+                        cpu->temperature = (float)kn->value.ui32;
+                        return NULL;
+                    case KSTAT_DATA_FLOAT:
+                        cpu->temperature = kn->value.f;
+                        return NULL;
+                }
+            }
+        }
+    }
+
+    return "Failed to find CPU temperature using kstat";
+}
+
+static const char* detectCPUTempByIpmiTool(FFCPUResult* cpu)
+{
+    FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
+    const char* error = ffProcessAppendStdOut(&buffer, (char* const[]){
+        "ipmitool",
+        "-c",
+        "sdr",
+        "list",
+        NULL
+    });
+
+    if (error)
+        return error;
+
+    char* line = NULL;
+    size_t len = 0;
+    while (ffStrbufGetline(&line, &len, &buffer))
+    {
+        if (sscanf(line, "CPU%*d Temp,%lf,degrees C,ok", &cpu->temperature) == 1)
+            return NULL;
+    }
+
+    return "ipmitool sdr list failed to find CPU temperature";
+}
+
 static inline void kstatFreeWrap(kstat_ctl_t** pkc)
 {
    assert(pkc);
@@ -8,7 +62,46 @@ static inline void kstatFreeWrap(kstat_ctl_t** pkc)
        kstat_close(*pkc);
 }

-const char* ffDetectCPUImpl(FF_MAYBE_UNUSED const FFCPUOptions* options, FFCPUResult* cpu)
+static inline uint16_t countTypeId(kstat_ctl_t* kc, const char* type)
+{
+    uint64_t low = 0, high = 0;
+    for (kstat_t* ksp = kc->kc_chain; ksp; ksp = ksp->ks_next)
+    {
+        if (ffStrStartsWith(ksp->ks_module, "cpu_info"))
+        {
+            if (kstat_read(kc, ksp, NULL) < 0)
+                continue;
+
+            kstat_named_t* stat = kstat_data_lookup(ksp, type);
+            if (!stat)
+                continue;
+
+            uint32_t id = 0;
+            switch (stat->data_type)
+            {
+                #ifdef _INT64_TYPE
+                case KSTAT_DATA_INT64:
+                case KSTAT_DATA_UINT64:
+                    id = (uint32_t) stat->value.ui64;
+                    break;
+                #endif
+                case KSTAT_DATA_INT32:
+                case KSTAT_DATA_UINT32:
+                    id = stat->value.ui32;
+                    break;
+                default:
+                    continue;
+            }
+            if (__builtin_expect(id > 64, false))
+                high |= 1ULL << (id - 64);
+            else
+                low |= 1ULL << id;
+        }
+    }
+    return (uint16_t) (__builtin_popcountll(low) + __builtin_popcountll(high));
+}
+
+const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
 {
    __attribute__((__cleanup__(kstatFreeWrap))) kstat_ctl_t* kc = kstat_open();
    if (!kc)
@@ -29,7 +122,7 @@ const char* ffDetectCPUImpl(FF_MAYBE_UNUSED const FFCPUOptions* options, FFCPURe
        kstat_named_t* kn = kstat_data_lookup(ks, "vendor_id");
        if (kn) ffStrbufSetNS(&cpu->vendor, KSTAT_NAMED_STR_BUFLEN(kn) - 1, KSTAT_NAMED_STR_PTR(kn));
    }
-    ffCPUDetectSpeedByCpuid(cpu);
+    ffCPUDetectByCpuid(cpu);
    {
        kstat_named_t* kn = kstat_data_lookup(ks, "clock_MHz");
        if (kn && kn->value.ui32 > cpu->frequencyBase)
@@ -40,7 +133,16 @@ const char* ffDetectCPUImpl(FF_MAYBE_UNUSED const FFCPUOptions* options, FFCPURe
    if (ks && kstat_read(kc, ks, NULL) >= 0)
    {
        kstat_named_t* kn = kstat_data_lookup(ks, "ncpus");
-        if (kn) cpu->coresLogical = cpu->coresPhysical = cpu->coresOnline = (uint16_t) kn->value.ui32;
+        if (kn) cpu->coresLogical = cpu->coresOnline = (uint16_t) kn->value.ui32;
+    }
+
+    cpu->packages = countTypeId(kc, "chip_id");
+    cpu->coresPhysical = countTypeId(kc, "core_id");
+
+    if (options->temp)
+    {
+        if (detectCPUTempByKstat(kc, cpu) != NULL)
+            detectCPUTempByIpmiTool(cpu);
    }

    return NULL;
@@ -4,6 +4,120 @@
 #include "util/mallocHelper.h"
 #include "util/smbiosHelper.h"

+#include <windows.h>
+#include "util/windows/perflib_.h"
+#include <wchar.h>
+
+static inline void ffPerfCloseQueryHandle(HANDLE* phQuery)
+{
+    if (*phQuery != NULL)
+    {
+        PerfCloseQueryHandle(*phQuery);
+        *phQuery = NULL;
+    }
+}
+
+const char* detectThermalTemp(double* result)
+{
+    struct FFPerfQuerySpec
+    {
+        PERF_COUNTER_IDENTIFIER Identifier;
+        WCHAR Name[16];
+    } querySpec = {
+        .Identifier = {
+            // Thermal Zone Information
+            // HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib\_V2Providers\{383487a6-3676-4870-a4e7-d45b30c35629}\{52bc5412-dac2-449c-8bc2-96443888fe6b}
+            .CounterSetGuid = { 0x52bc5412, 0xdac2, 0x449c, {0x8b, 0xc2, 0x96, 0x44, 0x38, 0x88, 0xfe, 0x6b} },
+            .Size = sizeof(querySpec),
+            .CounterId = PERF_WILDCARD_COUNTER,
+            .InstanceId = PERF_WILDCARD_COUNTER,
+        },
+        .Name = L"\\_TZ.CPUZ", // The standard(?) instance name for CPU temperature in the thermal provider
+    };
+
+    DWORD dataSize = 0;
+    if (PerfEnumerateCounterSetInstances(NULL, &querySpec.Identifier.CounterSetGuid, NULL, 0, &dataSize) != ERROR_NOT_ENOUGH_MEMORY)
+        return "PerfEnumerateCounterSetInstances() failed";
+
+    if (dataSize <= sizeof(PERF_INSTANCE_HEADER))
+        return "No `Thermal Zone Information` instances found";
+
+    {
+        FF_AUTO_FREE PERF_INSTANCE_HEADER* const pHead = malloc(dataSize);
+        if (PerfEnumerateCounterSetInstances(NULL, &querySpec.Identifier.CounterSetGuid, pHead, dataSize, &dataSize) != ERROR_SUCCESS)
+            return "PerfEnumerateCounterSetInstances() failed to get instance headers";
+
+        PERF_INSTANCE_HEADER* pInstanceHeader = pHead;
+        while (1)
+        {
+            const wchar_t* instanceName = (const wchar_t*)((BYTE*)pInstanceHeader + sizeof(*pInstanceHeader));
+            if (wcscmp(instanceName, querySpec.Name) == 0)
+                break;
+
+            dataSize -= pInstanceHeader->Size;
+            if (dataSize == 0)
+                break;
+            pInstanceHeader = (PERF_INSTANCE_HEADER*)((BYTE*)pInstanceHeader + pInstanceHeader->Size);
+        }
+
+        if (dataSize == 0)
+        {
+            const wchar_t* instanceName = (const wchar_t*)((BYTE*)pHead + sizeof(*pHead));
+            wcscpy(querySpec.Name, instanceName); // Use the first instance name if the specific one is not found
+        }
+    }
+
+    __attribute__((__cleanup__(ffPerfCloseQueryHandle)))
+    HANDLE hQuery = NULL;
+
+    if (PerfOpenQueryHandle(NULL, &hQuery) != ERROR_SUCCESS)
+        return "PerfOpenQueryHandle() failed";
+
+    if (PerfAddCounters(hQuery, &querySpec.Identifier, sizeof(querySpec)) != ERROR_SUCCESS)
+        return "PerfAddCounters() failed";
+
+    if (querySpec.Identifier.Status != ERROR_SUCCESS)
+        return "PerfAddCounters() reports invalid identifier";
+
+    if (PerfQueryCounterData(hQuery, NULL, 0, &dataSize) != ERROR_NOT_ENOUGH_MEMORY)
+        return "PerfQueryCounterData(NULL) failed";
+
+    if (dataSize <= sizeof(PERF_DATA_HEADER) + sizeof(PERF_COUNTER_HEADER)) // PERF_ERROR_RETURN, should not happen
+        return "instance doesn't exist";
+
+    FF_AUTO_FREE PERF_DATA_HEADER* const pDataHeader = malloc(dataSize);
+
+    if (PerfQueryCounterData(hQuery, pDataHeader, dataSize, &dataSize) != ERROR_SUCCESS)
+        return "PerfQueryCounterData(pDataHeader) failed";
+
+    PERF_COUNTER_HEADER* pCounterHeader = (PERF_COUNTER_HEADER*)(pDataHeader + 1);
+    if (pCounterHeader->dwType != PERF_MULTIPLE_COUNTERS)
+        return "Invalid counter type";
+
+    PERF_MULTI_COUNTERS* pMultiCounters = (PERF_MULTI_COUNTERS*)(pCounterHeader + 1);
+    PERF_COUNTER_DATA* pCounterData = (PERF_COUNTER_DATA*)((BYTE*)pMultiCounters + pMultiCounters->dwSize);
+
+    for (ULONG iCounter = 0; iCounter != pMultiCounters->dwCounters; iCounter++)
+    {
+        if (pCounterData->dwDataSize == sizeof(int32_t))
+        {
+            DWORD* pCounterIds = (DWORD*)(pMultiCounters + 1);
+            switch (pCounterIds[iCounter]) {
+            case 0: // Temperature
+                *result = *(int32_t*)(pCounterData + 1) - 273;
+                break;
+            case 3: // High Precision Temperature
+                *result = *(int32_t*)(pCounterData + 1) / 10.0 - 273;
+                break;
+            }
+        }
+
+        pCounterData = (PERF_COUNTER_DATA*)((BYTE*)pCounterData + pCounterData->dwSize);
+    }
+
+    return NULL;
+}
+
 // 7.5
 typedef struct FFSmbiosProcessorInfo
 {
@@ -111,7 +225,7 @@ static const char* detectNCores(FFCPUResult* cpu)
        else if (ptr->Relationship == RelationProcessorCore)
            ++cpu->coresPhysical;
        else if (ptr->Relationship == RelationProcessorPackage)
-            cpu->packages++;
+            ++cpu->packages;
    }

    return NULL;
@@ -165,8 +279,6 @@ static const char* detectCoreTypes(FFCPUResult* cpu)
    return NULL;
 }

-const char* detectThermalTemp(double* current, double* critical);
-
 const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
 {
    detectNCores(cpu);
@@ -175,14 +287,14 @@ const char* ffDetectCPUImpl(const FFCPUOptions* options, FFCPUResult* cpu)
    if (error)
        return error;

-    ffCPUDetectSpeedByCpuid(cpu);
+    ffCPUDetectByCpuid(cpu);
    if (options->showPeCoreCount) detectCoreTypes(cpu);

    if (cpu->frequencyMax == 0)
        detectMaxSpeedBySmbios(cpu);

    if(options->temp)
-        detectThermalTemp(&cpu->temperature, NULL);
+        detectThermalTemp(&cpu->temperature);

    return NULL;
 }
@@ -1,34 +0,0 @@
-#include "util/windows/wmi.hpp"
-
-extern "C"
-const char* detectThermalTemp(double* current, double* critical)
-{
-    // Requires Administrator privileges
-    // https://wutils.com/wmi/root/wmi/msacpi_thermalzonetemperature/#properties
-    FFWmiQuery query(L"SELECT CurrentTemperature, CriticalTripPoint FROM MSAcpi_ThermalZoneTemperature WHERE Active = TRUE", nullptr, FFWmiNamespace::WMI);
-    if(!query)
-        return "Query WMI service failed";
-
-    if(FFWmiRecord record = query.next())
-    {
-        if (current)
-        {
-            if(auto vtCurrent = record.get(L"CurrentTemperature"))
-                *current = vtCurrent.get<int32_t>() / 10 - 273.15; // In tenth of degrees Kelvin
-            else
-                *current = 0.0/0.0;
-        }
-
-        if (critical)
-        {
-            if(auto vtCritical = record.get(L"CriticalTripPoint"))
-                *critical = vtCritical.get<int32_t>() / 10 - 273.15; // In tenth of degrees Kelvin
-            else
-                *critical = 0.0/0.0;
-        }
-
-        return NULL;
-    }
-
-    return "No WMI result returned";
-}
@@ -1,6 +1,7 @@
 #pragma once

 #include "fastfetch.h"
+#include "modules/cpucache/option.h"

 typedef enum __attribute__((__packed__)) FFCPUCacheType
 {
--- a/Show More
+++ b/Show More