Merge pull request #1239 from fastfetch-cli/dev

Release: v2.23.0
JsonSchema: update zpool
2026-09-12 18:32:10 +02:00 · 2024-09-03 10:34:07 +08:00 · 2024-09-03 10:08:23 +08:00 · 2024-09-03 09:31:25 +08:00 · 2024-09-02 20:57:47 +08:00 · 2024-09-02 16:02:05 +08:00
805 changed files with 26934 additions and 25602 deletions
@@ -2,4 +2,4 @@
 check-filenames =
 builtin = clear,rare,usage,informal
 skip = */.git,*/cmake-build-*,*/.idea,*/completions,*/presets,*/screenshots,*/tests,*/3rdparty,*/logo/ascii
-ignore-words-list = iterm,compiletime,unknwn,pengwin,siduction,master,sur,doas
+ignore-words-list = iterm,compiletime,unknwn,pengwin,siduction,master,sur,doas,conexant
@@ -7,10 +7,10 @@ tab_width = 4
 insert_final_newline = true
 trim_trailing_whitespace = true

-[*.{md,fflogo}]
+[*.md]
 trim_trailing_whitespace = false

-[*.{fflogo}]
+[*.txt]
 insert_final_newline = false

 [*.yml]
@@ -1 +1 @@
-github: [LinusDierheimer, CarterLi]
+github: [CarterLi, LinusDierheimer]
@@ -7,15 +7,18 @@ assignees: ''

 ---

-<!-- We will try hard to solve the issue. However since platforms and hardwares vary greatly, it can be hard to find the root cause is. Providing following information may help us greatly. Thanks in advance -->
+Be sure to read the [FAQ](https://github.com/fastfetch-cli/fastfetch?tab=readme-ov-file#faq) before submitting a new issue.
+
+<!-- We will try hard to solve the issue. However since platforms and hardwares vary greatly, it can be hard to find the root cause of an issue. Providing the following information may help us greatly. Thanks in advance! -->

 # General description of bug:

 * What happened:
 * What should happen:
+* Fastfetch version used: <!-- please use the latest version, if possible -->
 * Did it work in an older version: <!-- if yes, which version -->
-* Where did you get the binary: <!-- Github Release / Github Actions / Installed with a package manager (What package manager) / Built from source yourself -->
-* Does this issue still occurs in [the latest dev build](https://github.com/fastfetch-cli/fastfetch/actions/)?
+* Where did you get the binary: <!-- GitHub release / GitHub Actions / installed with a package manager (please tell us which package manager you used!) / built from source yourself -->
+* Does this issue still occur in [the latest dev build](https://github.com/fastfetch-cli/fastfetch/actions/)?

 # Often helpful information:

@@ -24,7 +27,7 @@ Screenshot:

 The content of the configuration file you use (if any):
 ```
-//paste here
+// Paste here
 ```

 Output of `fastfetch -c ci.jsonc --format json`:
@@ -33,45 +36,45 @@ Note that this output will contain you public IP. If it is not relevant for the
 -->

 ```
-//paste here
+// Paste here
 ```

 Output of `fastfetch --list-features`:
 ```
-//paste here
+// Paste here
 ```

-## If fastfatch crashed
+## If fastfatch crashed or froze

 Paste the stacktrace here. You may get it with:

-```
-$ gdb -q -ex 'set confirm off' -ex run -ex 'bt full' -ex quit --args /path/to/fastfetch
+```shell
+# You may need Ctrl+C to stop the process if it freezes
+gdb -q -ex 'set confirm off' -ex run -ex 'bt full' -ex quit --args /path/to/fastfetch
 ```

 If you are able to identify which module crashed, the strace can be helpful too

-```
-$ strace /path/to/fastfetch --multithreading false --structure {MODULE} --pipe
+```shell
+strace /path/to/fastfetch --multithreading false -s {MODULE} --pipe
 ```

 If you cannot do the instructions above, please upload the core dump file:

-## If my image logo didn't show / work
+## If fastfetch is slow

-<!-- Please make sure the terminal does support the image protocol you used. Note Gnome terminal doesn't support any image protocols -->
+Use `time fastfetch --stat` to show time usage for each module.
+
+## If an image or logo didn't show 
+
+<!-- Please make sure your terminal supports the image protocol you used. Note that GNOME Terminal doesn't support any image protocols. -->

 * The image protocol you used: 
 * The terminal you used: 
 * Upload the image file here, or paste the image URL: 
 * Does it work with `--logo-width {WIDTH} --logo-height {HEIGHT}`? 

-## If fastfetch behaves incorrectly on shell starting
+## If fastfetch behaves incorrectly on shell startup

-<!-- NOTE for zsh / p10k users:
-There are known incompatibility between fastfetch and p10k instant prompt.
-The p10k doc clearly states that you should NOT print anything to stdout after p10k-instant-prompt is initialized.
-You should either put `fastfetch` before initialization of p10k-instant-prompt (recommended), remove it or use `fastfetch --pipe false` -->
-
-* The bug is reproduceable with fresh / clean shell configuration (i.e. `fastfetch` is the single line of `.zshrc` or `~/.config/fish/config.fish`): 
+* The bug is reproducible with a clean shell configuration (i.e. `fastfetch` is the only line in `.zshrc` or `~/.config/fish/config.fish`): 
 * Does `sleep 1` before running `fastfetch` work? 
@@ -7,10 +7,12 @@ assignees: ''

 ---

-<!-- Before requesting a new feature, please try `fastfetch -c all.jsonc` to see if it has been supported -->
+Be sure to read [FAQ](https://github.com/fastfetch-cli/fastfetch?tab=readme-ov-file#faq) before submitting a new issue.

-# Current state:
+## Wanted features:

-# Wanted state:
+<!-- Your features here -->

-# Why the change is sensible:
+## Motivation:
+
+<!-- Your motivation here -->
@@ -7,12 +7,17 @@ assignees: ''

 ---

+Tip: A logo can be displayed by fastfetch without getting into fastfetch's official repo. For highly customized logo for personal use, it's recommended to keep it locally. Please refer to https://github.com/fastfetch-cli/fastfetch/wiki/Migrate-Neofetch-Logo-To-Fastfetch
+
 # OS
 ```
-Paste content of /etc/os-release here. If this file doesn't exist, describe a way to identify the distro.
+Paste content of /etc/os-release and /etc/lsb-release here. If none of these files exist, describe a way to identify the distro
 ```

 # Ascii
+
+An ASCII logo should not take up too much space (smaller than 50x20 characters). Please also include the color codes if not available in `os-release` 
+
 ```
 Paste ascii art here.
 ```
@@ -0,0 +1,21 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 60
+
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - keepalive
+
+# Label to use when marking an issue as stale
+staleLabel: stale
+
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false
@@ -14,66 +14,16 @@ jobs:

      - name: Install codespell
        shell: bash
-        run: sudo apt update && sudo apt install -y codespell
+        run: |
+          sudo apt-get update || true
+          sudo apt-get install -y codespell

      - name: Run Spellchecker
        run: codespell

-  linux-buildtest:
-    name: Linux build test
-    permissions:
-      contents: read
-    strategy:
-      fail-fast: false
-      matrix:
-        compiler: [
-          { cc: gcc, cxx: "g++" },
-          { cc: clang, cxx: "clang++" },
-          { cc: "musl-gcc", cxx: "musl-g++" }
-        ]
-        enableFeatures: [ON, OFF]
-        exclude:
-          # The feature libraries are all build against glibc, so they can't be used with musl
-          - compiler: { cc: "musl-gcc", cxx: "musl-g++" }
-            enableFeatures: ON
-    runs-on: ubuntu-22.04
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v4
-
-      - name: uname -a
-        run: uname -a
-
-      - name: install required packages
-        run: sudo apt-get update && sudo apt-get install -y musl-dev musl-tools linux-headers-generic 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 libosmesa6-dev ocl-icd-opencl-dev libnm-dev libpulse-dev libddcutil-dev libchafa-dev libdrm-dev directx-headers-dev
-
-      - name: configure project
-        env:
-          CC: ${{ matrix.compiler.cc }}
-          CXX: ${{ matrix.compiler.cxx }}
-        run: cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo -DENABLE_VULKAN=${{ matrix.enableFeatures }} -DENABLE_WAYLAND=${{ matrix.enableFeatures }} -DENABLE_XCB_RANDR=${{ matrix.enableFeatures }} -DENABLE_XCB=${{ matrix.enableFeatures }} -DENABLE_XRANDR=${{ matrix.enableFeatures }} -DENABLE_X11=${{ matrix.enableFeatures }} -DENABLE_GIO=${{ matrix.enableFeatures }} -DENABLE_DCONF=${{ matrix.enableFeatures }} -DENABLE_DBUS=${{ matrix.enableFeatures }} -DENABLE_XFCONF=${{ matrix.enableFeatures }} -DENABLE_SQLITE3=${{ matrix.enableFeatures }} -DENABLE_RPM=${{ matrix.enableFeatures }} -DENABLE_IMAGEMAGICK7=${{ matrix.enableFeatures }} -DENABLE_IMAGEMAGICK6=${{ matrix.enableFeatures }} -DENABLE_CHAFA=${{ matrix.enableFeatures }} -DENABLE_ZLIB=${{ matrix.enableFeatures }} -DENABLE_EGL=${{ matrix.enableFeatures }} -DENABLE_GLX=${{ matrix.enableFeatures }} -DENABLE_OSMESA=${{ matrix.enableFeatures }} -DENABLE_OPENCL=${{ matrix.enableFeatures }} -DENABLE_LIBNM=${{ matrix.enableFeatures }} -DENABLE_PULSE=${{ matrix.enableFeatures }} -DENABLE_DIRECTX_HEADERS=${{ matrix.enableFeatures }} -DENABLE_DRM=${{ matrix.enableFeatures }} -DENABLE_DDCUTIL=${{ matrix.enableFeatures }} -DENABLE_CHAFA=${{ matrix.enableFeatures }} .
-
-      - name: build project
-        run: cmake --build . --verbose -j4
-
-      - name: run tests
-        run: ctest
-
-      - name: run fastfetch --list-features
-        run: ./fastfetch --list-features
-
-      - name: run fastfetch
-        run: time ./fastfetch -c presets/ci.jsonc
-
-      - name: run fastfetch --format json
-        run: time ./fastfetch -c presets/ci.jsonc --format json
-
-      - name: run flashfetch
-        run: time ./flashfetch
-
-  Linux-old-amd64:
-    name: Linux-old-amd64
-    runs-on: ubuntu-20.04
+  no-features-test:
+    name: No-features-test
+    runs-on: ubuntu-latest
    permissions:
      security-events: write
      contents: read
@@ -84,8 +34,47 @@ jobs:
      - name: uname -a
        run: uname -a

+      - name: configure project
+        run: cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr . -DENABLE_VULKAN=OFF -DENABLE_WAYLAND=OFF -DENABLE_XCB_RANDR=OFF -DENABLE_XCB=OFF -DENABLE_XRANDR=OFF -DENABLE_X11=OFF -DENABLE_DRM=OFF -DENABLE_GIO=OFF -DENABLE_DCONF=OFF -DENABLE_DBUS=OFF -DENABLE_XFCONF=OFF -DENABLE_SQLITE3=OFF -DENABLE_RPM=OFF -DENABLE_IMAGEMAGICK7=OFF -DENABLE_IMAGEMAGICK6=OFF -DENABLE_CHAFA=OFF -DENABLE_ZLIB=OFF -DENABLE_EGL=OFF -DENABLE_GLX=OFF -DENABLE_OSMESA=OFF -DENABLE_OPENCL=OFF -DENABLE_FREETYPE=OFF -DENABLE_PULSE=OFF -DENABLE_DDCUTIL=OFF -DENABLE_ELF=OFF -DENABLE_DIRECTX_HEADERS=OFF -DENABLE_THREADS=OFF
+
+      - name: build project
+        run: cmake --build . --target package --verbose -j4
+
+      - name: list features
+        run: ./fastfetch --list-features
+
+      - name: run fastfetch
+        run: time ./fastfetch -c presets/ci.jsonc --stat false
+
+      - name: run fastfetch --format json
+        run: time ./fastfetch -c presets/ci.jsonc --format json
+
+      - name: run flashfetch
+        run: time ./flashfetch
+
+      - name: print dependencies
+        run: ldd fastfetch
+
+      - name: run tests
+        run: ctest
+
+  linux-amd64:
+    name: Linux-amd64
+    runs-on: ubuntu-20.04
+    permissions:
+      security-events: write
+      contents: read
+    outputs:
+      ffversion: ${{ steps.ffversion.outputs.ffversion }}
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v4
+
+      - name: uname -a
+        run: uname -a
+
      - 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 libosmesa6-dev ocl-icd-opencl-dev libnm-dev libpulse-dev libdrm-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 libosmesa6-dev ocl-icd-opencl-dev libpulse-dev libdrm-dev libelf-dev directx-headers-dev

      - name: install linuxbrew packages
        run: |
@@ -110,68 +99,7 @@ jobs:
        run: ./fastfetch --list-features

      - name: run fastfetch
-        run: time ./fastfetch -c presets/ci.jsonc
-
-      - 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
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v4
-        with:
-          name: fastfetch-linux-old-amd64
-          path: ./fastfetch-*.*
-
-  linux-amd64:
-    name: Linux-amd64
-    runs-on: ubuntu-22.04 # Ubuntu 22.04 uses Glibc 2.35. Should be fine with Debian 12, which uses Glibc 2.36 (https://packages.debian.org/source/bookworm/glibc)
-    permissions:
-      security-events: write
-      contents: read
-    outputs:
-      ffversion: ${{ steps.ffversion.outputs.ffversion }}
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v4
-
-      - name: uname -a
-        run: uname -a
-
-      - 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 libosmesa6-dev ocl-icd-opencl-dev libnm-dev libpulse-dev libdrm-dev libddcutil-dev libchafa-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 --ignore-dependencies
-
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3
-        with:
-          languages: c
-
-      - name: configure project
-        run: PKG_CONFIG_PATH=/home/linuxbrew/.linuxbrew/lib/pkgconfig:$PKG_CONFIG_PATH cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr .
-
-      - name: build project
-        run: cmake --build . --target package --verbose -j4
-
-      - name: perform CodeQL analysis
-        uses: github/codeql-action/analyze@v3
-
-      - name: list features
-        run: ./fastfetch --list-features
-
-      - name: run fastfetch
-        run: time ./fastfetch -c presets/ci.jsonc
+        run: time ./fastfetch -c presets/ci.jsonc --stat false

      - name: run fastfetch --format json
        run: time ./fastfetch -c presets/ci.jsonc --format json
@@ -210,15 +138,15 @@ jobs:
        id: runcmd
        with:
          arch: aarch64
-          distro: ubuntu22.04
+          distro: ubuntu20.04
          githubToken: ${{ github.token }}
          run: |
            uname -a
-            apt-get update && apt-get install -y cmake make g++ 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 libosmesa6-dev ocl-icd-opencl-dev libnm-dev libpulse-dev libdrm-dev libddcutil-dev libchafa-dev directx-headers-dev rpm
+            apt-get update && apt-get install -y cmake make g++ 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 libosmesa6-dev ocl-icd-opencl-dev libpulse-dev libdrm-dev libelf-dev directx-headers-dev rpm
            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr .
            cmake --build . --target package --verbose -j4
            ./fastfetch --list-features
-            time ./fastfetch -c presets/ci.jsonc
+            time ./fastfetch -c presets/ci.jsonc --stat false
            time ./fastfetch -c presets/ci.jsonc --format json
            time ./flashfetch
            ldd fastfetch
@@ -230,9 +158,164 @@ jobs:
          name: fastfetch-linux-aarch64
          path: ./fastfetch-*.*

+  linux-armv7:
+    name: Linux-armv7
+    runs-on: ubuntu-22.04
+    permissions:
+      security-events: write
+      contents: read
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v4
+
+      - name: run VM
+        uses: uraimo/run-on-arch-action@v2
+        id: runcmd
+        with:
+          arch: armv7
+          distro: ubuntu20.04
+          githubToken: ${{ github.token }}
+          run: |
+            uname -a
+            apt-get update && apt-get install -y wget
+            # CMake installed by apt has bug `list sub-command REMOVE_ITEM requires two or more arguments`
+            wget --no-check-certificate https://apt.kitware.com/ubuntu/pool/main/c/cmake/{cmake_3.29.2-0kitware1ubuntu20.04.1_armhf.deb,cmake-data_3.29.2-0kitware1ubuntu20.04.1_all.deb}
+            dpkg -i *.deb
+            apt-get install -y make g++ 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 libosmesa6-dev ocl-icd-opencl-dev libpulse-dev libdrm-dev libelf-dev directx-headers-dev rpm
+            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr .
+            cmake --build . --target package --verbose -j4
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: fastfetch-linux-armv7
+          path: ./fastfetch-*.*
+
+  linux-riscv64:
+    name: Linux-riscv64
+    runs-on: ubuntu-22.04
+    permissions:
+      security-events: write
+      contents: read
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v4
+
+      - name: run VM
+        uses: uraimo/run-on-arch-action@v2
+        id: runcmd
+        with:
+          arch: riscv64
+          distro: ubuntu22.04
+          githubToken: ${{ github.token }}
+          run: |
+            uname -a
+            apt-get update && apt-get install -y cmake make g++ 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 libosmesa6-dev ocl-icd-opencl-dev libpulse-dev libdrm-dev libddcutil-dev libchafa-dev libelf-dev directx-headers-dev rpm
+            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr .
+            cmake --build . --target package --verbose -j4
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: fastfetch-linux-riscv64
+          path: ./fastfetch-*.*
+
+  musl-amd64:
+    name: Musl-amd64
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: setup alpine linux
+        uses: jirutka/setup-alpine@master
+        with:
+          branch: v3.19
+
+      - name: install dependencies
+        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++
+        shell: alpine.sh --root {0}
+
+      - name: build
+        run: |
+            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr -DIS_MUSL=ON -GNinja .
+            cmake --build . --target package --verbose -j4
+        shell: alpine.sh {0}
+
+      - name: run
+        run: |
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest
+        shell: alpine.sh {0}
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: fastfetch-musl-amd64
+          path: ./fastfetch-*.*
+
+  musl-aarch64:
+    name: Musl-aarch64
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: setup alpine linux
+        uses: jirutka/setup-alpine@master
+        with:
+          branch: v3.19
+          arch: aarch64
+
+      - name: install dependencies
+        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++
+        shell: alpine.sh --root {0}
+
+      - name: build
+        run: |
+            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On -DCMAKE_INSTALL_PREFIX=/usr -DIS_MUSL=ON -GNinja .
+            cmake --build . --target package --verbose -j4
+        shell: alpine.sh {0}
+
+      - name: run
+        run: |
+            ./fastfetch --list-features
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
+            time ./flashfetch
+            ldd fastfetch
+            ctest
+        shell: alpine.sh {0}
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: fastfetch-musl-aarch64
+          path: ./fastfetch-*.*
+
  macos-universal:
    name: macOS-universal
-    runs-on: macos-latest
+    runs-on: macos-12
    permissions:
      security-events: write
      contents: read
@@ -245,8 +328,7 @@ jobs:

      - name: install required packages
        run: |
-          brew update
-          HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1 brew install vulkan-loader vulkan-headers molten-vk imagemagick chafa
+          HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1 brew install --overwrite vulkan-loader vulkan-headers molten-vk imagemagick chafa

      - name: Initialize CodeQL
        uses: github/codeql-action/init@v3
@@ -266,7 +348,7 @@ jobs:
        run: ./fastfetch --list-features

      - name: run fastfetch
-        run: time ./fastfetch -c presets/ci.jsonc
+        run: time ./fastfetch -c presets/ci.jsonc --stat false

      - name: run fastfetch --format json
        run: time ./fastfetch -c presets/ci.jsonc --format json
@@ -286,6 +368,39 @@ jobs:
          name: fastfetch-macos-universal
          path: ./fastfetch-*.*

+  sunos-amd64:
+    runs-on: ubuntu-latest
+    name: SunOS-amd64
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v4
+
+      - name: run VM
+        uses: vmactions/omnios-vm@v1
+        with:
+          usesh: true
+          prepare: |
+            uname -a
+            pkg update --accept
+            pkg install gcc13 cmake git pkg-config glib2 dbus sqlite-3 imagemagick
+
+          run: |
+            cmake -DSET_TWEAK=Off -DBUILD_TESTS=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
+            cpack
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: fastfetch-sunos-amd64
+          path: ./fastfetch-*.*
+
  freebsd-amd64:
    name: FreeBSD-amd64
    runs-on: ubuntu-latest
@@ -301,18 +416,18 @@ jobs:
        with:
          operating_system: freebsd
          architecture: x86-64
-          cpu_count: 3
+          cpu_count: 4
          shell: bash
-          version: '13.2'
+          version: '14.1'
          run: |
            uname -a
            sudo pkg update
-            sudo pkg install -y cmake git pkgconf binutils wayland vulkan-headers vulkan-loader libxcb libXrandr libX11 libdrm glib dconf dbus sqlite3-tcl xfce4-conf ImageMagick6 ImageMagick7 chafa egl libosmesa opencl ocl-icd v4l_compat
+            sudo pkg install -y cmake git pkgconf binutils wayland vulkan-headers vulkan-loader libxcb libXrandr libX11 libdrm libelf glib dconf dbus sqlite3-tcl xfce4-conf egl libosmesa opencl ocl-icd v4l_compat
            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .
            cmake --build . --target package --verbose -j4
            ./fastfetch --list-features
-            time ./fastfetch
-            time ./fastfetch --format json
+            time ./fastfetch -c presets/ci.jsonc --stat false
+            time ./fastfetch -c presets/ci.jsonc --format json
            time ./flashfetch
            ldd fastfetch
            ctest
@@ -323,43 +438,6 @@ jobs:
          name: fastfetch-freebsd-amd64
          path: ./fastfetch-*.*

-  freebsd-aarch64:
-    name: FreeBSD-aarch64
-    runs-on: ubuntu-latest
-    permissions:
-      security-events: write
-      contents: read
-    steps:
-      - name: checkout repository
-        uses: actions/checkout@v4
-
-      - name: run VM
-        uses: cross-platform-actions/action@master
-        with:
-          operating_system: freebsd
-          architecture: arm64
-          cpu_count: 3
-          shell: bash
-          version: '13.2'
-          run: |
-            uname -a
-            sudo pkg update
-            sudo pkg install -y cmake git pkgconf binutils wayland vulkan-headers vulkan-loader libxcb libXrandr libX11 libdrm glib dconf dbus sqlite3-tcl xfce4-conf ImageMagick6 ImageMagick7 chafa egl libosmesa opencl ocl-icd v4l_compat
-            cmake -DSET_TWEAK=Off -DBUILD_TESTS=On .
-            cmake --build . --target package --verbose -j4
-            ./fastfetch --list-features
-            time ./fastfetch
-            time ./fastfetch --format json
-            time ./flashfetch
-            ldd fastfetch
-            ctest
-
-      - name: upload artifacts
-        uses: actions/upload-artifact@v4
-        with:
-          name: fastfetch-freebsd-aarch64
-          path: ./fastfetch-*.*
-
  windows-amd64:
    name: Windows-amd64
    runs-on: windows-latest
@@ -378,7 +456,7 @@ jobs:
        with:
          msystem: CLANG64
          update: true
-          install: git mingw-w64-clang-x86_64-7zip mingw-w64-clang-x86_64-cmake mingw-w64-clang-x86_64-clang mingw-w64-clang-x86_64-vulkan-loader mingw-w64-clang-x86_64-opencl-icd
+          install: git mingw-w64-clang-x86_64-7zip mingw-w64-clang-x86_64-cmake mingw-w64-clang-x86_64-clang mingw-w64-clang-x86_64-vulkan-loader mingw-w64-clang-x86_64-vulkan-headers mingw-w64-clang-x86_64-opencl-icd mingw-w64-clang-x86_64-opencl-headers mingw-w64-clang-x86_64-cppwinrt

      - name: print msys version
        run: uname -a
@@ -392,11 +470,14 @@ jobs:
      - name: copy necessary dlls
        run: cp /clang64/bin/{OpenCL,vulkan-1}.dll .

+      - name: download amd_ags
+        run: curl -LO https://github.com/GPUOpen-LibrariesAndSDKs/AGS_SDK/raw/master/ags_lib/lib/amd_ags_x64.dll
+
      - name: list features
        run: ./fastfetch --list-features

      - name: run fastfetch
-        run: time ./fastfetch -c presets/ci.jsonc
+        run: time ./fastfetch -c presets/ci.jsonc --stat false

      - name: run fastfetch --format json
        run: time ./fastfetch -c presets/ci.jsonc --format json
@@ -411,10 +492,10 @@ jobs:
        run: ctest

      - name: create zip archive
-        run: 7z a -tzip -mx9 -bd -y fastfetch-windows-amd64.zip *.dll fastfetch.exe flashfetch.exe presets
+        run: 7z a -tzip -mx9 -bd -y fastfetch-windows-amd64.zip LICENSE *.dll fastfetch.exe flashfetch.exe presets

      - name: create 7z archive
-        run: 7z a -t7z -mx9 -bd -y fastfetch-windows-amd64.7z *.dll fastfetch.exe flashfetch.exe presets
+        run: 7z a -t7z -mx9 -bd -y fastfetch-windows-amd64.7z LICENSE *.dll fastfetch.exe flashfetch.exe presets

      - name: upload artifacts
        uses: actions/upload-artifact@v4
@@ -440,7 +521,7 @@ jobs:
        with:
          msystem: CLANG32
          update: true
-          install: git mingw-w64-clang-i686-7zip mingw-w64-clang-i686-cmake mingw-w64-clang-i686-clang mingw-w64-clang-i686-vulkan-loader mingw-w64-clang-i686-opencl-icd
+          install: git p7zip mingw-w64-clang-i686-cmake mingw-w64-clang-i686-clang mingw-w64-clang-i686-vulkan-loader mingw-w64-clang-i686-vulkan-headers mingw-w64-clang-i686-opencl-icd mingw-w64-clang-i686-opencl-headers

      - name: print msys version
        run: uname -a
@@ -462,8 +543,11 @@ jobs:
      - name: copy necessary dlls
        run: cp /clang32/bin/{OpenCL,vulkan-1}.dll .

+      - name: download amd_ags
+        run: curl -LO https://github.com/GPUOpen-LibrariesAndSDKs/AGS_SDK/raw/master/ags_lib/lib/amd_ags_x86.dll
+
      - name: run fastfetch
-        run: time ./fastfetch -c presets/ci.jsonc
+        run: time ./fastfetch -c presets/ci.jsonc --stat false

      - name: run fastfetch --format json
        run: time ./fastfetch -c presets/ci.jsonc --format json
@@ -478,10 +562,10 @@ jobs:
        run: ctest

      - name: create zip archive
-        run: 7z a -tzip -mx9 -bd -y fastfetch-windows-i686.zip *.dll fastfetch.exe flashfetch.exe presets
+        run: 7z a -tzip -mx9 -bd -y fastfetch-windows-i686.zip LICENSE *.dll fastfetch.exe flashfetch.exe presets

      - name: create 7z archive
-        run: 7z a -t7z -mx9 -bd -y fastfetch-windows-i686.7z *.dll fastfetch.exe flashfetch.exe presets
+        run: 7z a -t7z -mx9 -bd -y fastfetch-windows-i686.7z LICENSE *.dll fastfetch.exe flashfetch.exe presets

      - name: upload artifacts
        uses: actions/upload-artifact@v4
@@ -496,9 +580,13 @@ jobs:
    needs:
      - linux-amd64
      - linux-aarch64
+      - linux-armv7
+      - linux-riscv64
+      - musl-amd64
+      - musl-aarch64
      - macos-universal
      - freebsd-amd64
-      - freebsd-aarch64
+      - sunos-amd64
      - windows-amd64
      - windows-i686
    permissions:
@@ -514,11 +602,6 @@ jobs:
        if: needs.linux-amd64.outputs.ffversion != steps.get_version_release.outputs.release
        uses: actions/download-artifact@v4

-      - name: rm old artifacts
-        if: needs.linux-amd64.outputs.ffversion != steps.get_version_release.outputs.release
-        run: |
-          rm -rf fastfetch-*-old-*
-
      - name: create release
        if: needs.linux-amd64.outputs.ffversion != steps.get_version_release.outputs.release
        uses: ncipollo/release-action@v1
@@ -1,10 +1,11 @@
-**/build/
-**/.vscode/
-**/.cache/
-**/.kdev4/
-**/.DS_Store
-/.vs
+build/
+.vs/
+.vscode/
+.cache/
+.kdev4/
+.DS_Store
 cscope.*
 tags
 fastfetch.kdev4
 *.user
+*.user.*
@@ -1,3 +1,776 @@
+# 2.23.0
+
+Features:
+* Support unity version detection (DE, Linux)
+* Print model name in Battery keys if available (Battery)
+* Add module `Zpool`
+* Improve performance (Shell / Terminal, Linux)
+* Support syntax of padded strings in `--<module>-format`. `{variable<padlength}` and `{variable>padlength}` are supported.
+    * If pad length is greater than the length of the variable, the variable will be padded with spaces.
+        * `fastfetch -l none -s command --command-text 'echo 12345' --command-format 'output({1<20})'` prints `Command: output(12345               )`
+        * `fastfetch -l none -s command --command-text 'echo 12345' --command-format 'output({1>20})'` prints `Command: output(               12345)`
+    * If pad length is less than the length of the variable, the variable will be truncated.
+
+Bugfixes:
+* Fix broken `--list-presets`
+* Update zsh completion script
+* Don't print `*` if `defaultRouteOnly` is set (NetIO)
+* Fix Camera module incorrectly disabled on FreeBSD (Camera, FreeBSD)
+* Fix hanging on screen 5.0 (Terminal)
+* Improve image logo support on Windows (Logo, Windows)
+
+Logos:
+* Update AmogOS
+* Add Magix
+* Make ubuntu logo colorable
+* Add Steam Deck Logo
+* add Huawei Cloud EulerOS
+
+# 2.22.0
+
+Features:
+* Small performance improvements (Terminal, Editor)
+* Improve arm32 and loongarch support (CPU, Linux)
+* Ignore the parent process if env `$FFTS_IGNORE_PARENT` is set to `1` (Shell)
+* Add code name of Apple M4 (CPU, Linux)
+* Add ethernet speed rate detection support (LocalIP)
+* Add zsh completion script
+* Add Linglong package manager detection support (Packages, Linux)
+
+Bugfixes:
+* Fix building on macOS 10.14
+* Fix tmux in linux TTY (Colors)
+* Fix hang in WSL when custom format is used (Disk, Linux)
+* Fix `/proc/loadavg` parsing (Loadavg, Linux)
+* Disable use of `LC_NUMERIC` locale settings to fix parsing of decimal numbers
+* Fix possible segfault (DiskIO, Linux)
+* Honor `preciseRefreshRate` in custom format (Display)
+
+Logos:
+* Add Lingmo OS
+* Add Sleeper OS
+
+# 2.21.3
+
+Bugfixes:
+* Fix bad Intel Arc GPU name detection, which was supposed to be fixed in the last version but the change was reverted accidentally (#1177, GPU, Linux)
+* Fix arm32 CPU name detection no longer work. Regression of 2.21.2 (CPU, Linux)
+
+# 2.21.2
+
+Features:
+* Support `--stat <num_in_ms>` to display long running modules in yellow or red
+
+Bugfixes:
+* Fix bad Intel Arc GPU name and type detection (GPU, Linux)
+* Fix uninited struct fields (GPU, Linux)
+* Skip cpu model smbios detection on ARM platforms (CPU, Linux)
+* Always use `CurrentControlSet` instead of `ControlSet001` when querying registry (Windows)
+* Fix NVIDIA GPUs are missing in GPU detection sometimes (GPU, Windows)
+* Fixing detection of `pthread_timedjoin_np` (Linux)
+
+Logos:
+* Add HyprOS
+* Add GoldenDog Linux
+
+# 2.21.1
+
+Hotfix for a regression that breaks WM detection when running `startx` from TTY (Regression from 2.21.0, #1172 / #1162)
+
+Changes:
+* On Linux, FreeBSD and SunOS, a new recommended dependency `libelf` is introduced to extract strings in ELF binary, used for
+    * st term font detection when the term font is compiled directly into the binary
+    * fast path of systemd version detection
+
+Features:
+* Improve performance of
+    * kitty version detection (Terminal, Linux)
+    * st term font detection (TerminalFont, Linux)
+    * systemd version detection (InitSystem, Linux)
+
+Bugfixes:
+* Fix building error without `linux/wireless.h` (Wifi, Linux)
+* Fix wrong GPU max frequency on Asahi Linux (GPU, Linux)
+* Don't rely `$XDG_SESSION_TYPE` for detecting wm protocol (#1172 / #1162, WM, Linux)
+* Fix light color doesn't work on Linux console (Colors, Linux)
+* `LC_ALL`, if set, overrides every other locale-related environment variable (Locale)
+* Increase timeout of DBus calls (Linux)
+
+Logos:
+* Add vanilla_small and vanilla2
+* Add LFS (Linux From Scratch)
+
+# 2.21.0
+
+Changes:
+* We no longer use `libnm` for Wifi detection on Linux. Instead, we use `libdbus` to communicate with NetworkManager directly
+    * To package managers: libnm dependency should be removed
+
+Features:
+* Add module `BluetoothRadio` that prints bluetooth radios installed on the system
+    * Don't confuse with module `Bluetooth` which lists connected bluetooth devices
+* Detect more information when `--gpu-driver-specific` is used (GPU)
+* Detect which type of nvidia driver (open source or proprietary) is used (GPU, Linux)
+* `--gpu-driver-specific` adds supports for Moore Threads GPU (#1142, GPU, Linux / Windows)
+* Use SetupAPI for detecting GPUs to support GPU detection when running fastfetch as a Windows Service (GPU, Windows)
+    * See https://github.com/gpustack/gpustack/pull/97#issuecomment-2264699787 for detail
+* Detect playback status (Media, Linux)
+
+Bugfixes:
+* Don't try to connect display server in tty mode (Linux, #1110)
+* Improve ssh detection
+* Fix max frequency printing in custom format (CPU)
+* Fix displaying random characters when detecting kitty term font (#1136 / #1145, TerminalFont, Linux)
+* Make sure to detect all physical memory devices (#1137)
+* Don't detect `wl-restart` as WM (#1135, WM, Linux)
+* Use PCI bus ID to match Nvidia cards; fix multi-GPU detection (GPU)
+* Ignore invalid GPU (#1066, GPU, macOS)
+* Print error when invalid color code is found (#1138)
+* Fix invalid refresh rate detection on old macOS versions (Display, macOS)
+* Fix disk size detection on 32-bit systems (Disk, BSD)
+* Don't ignore disabled GPUs (#1140, GPU, Linux)
+* Fix GPU type detection on FreeBSD (GPU, FreeBSD)
+* Remove shell version detection for unknown shells (#1144, Shell)
+* Don't detect hyfetch as shell on NixOS (Shell, NixOS)
+
+Logos:
+* Update EndeavourOS_small
+* Add QTS
+
+# 2.20.0
+
+This release fixes regression of `2.19.0` on M1 MacBook Air. It also introduces a new option `--key-type icon` to display predefined icons in keys (requires newest nerd font). See `fastfetch -h key-type` for detail.
+
+Changes:
+* JSON option `display.keyWidth` has been renamed to `display.key.width`
+    * Previously: `{ "display": { "keyWidth": 3 } }`
+    * Now: `{ "display": { "key": { "width": 3 } } }`
+* Windows Terminal font detection **in WSL** has been removed due to [issue #1113](https://github.com/fastfetch-cli/fastfetch/issues/1113)
+
+Features:
+* Add option `display.key.type: <enum>` to print icons in keys
+    * Supported value `string`, `icon` and `both`. Default to `string` (don't display icons)
+    * Example: `{ "display": { "key": { "type": "icon" } } }`
+* Add option `display.key.paddingLeft: <num>` to print left padding (whitespaces) in keys
+    * Example: `{ "display": { "key": { "paddingLeft": 2 } } }`
+* Add option `modules.keyIcon` to set icon for specified module
+    * Example: `{ "modules": { "type": "command", "keyIcon": "🔑" } }`
+* Report system mono font name for Terminator if used (TerminalFont, Linux)
+* Don't require logo height to be set when using `--logo-position right`
+* Report Snapdragon SOC marketing name for newer Android phones (CPU, Android)
+* Detect MTK SOC part name (CPU, Android)
+
+Bugfixes:
+* Don't wake up suspended GPUs when using `--ds-force-drm` (Display, Linux)
+* Fix printing editor type in JSON result (Editor)
+* Fix `--logo-padding-*` not working correctly (#1121, Logo)
+* Fix possible segfault when detecting GPU frequency (#1121, macOS, GPU)
+
+# 2.19.1
+
+Bugfixes
+* Fix frequency value printing when using custom format (#1111, CPU / GPU)
+* Fix display detection for XiaoMi Android phone (Display, Android)
+
+Features:
+* Display if HDR mode is enabled for screens (Display)
+    * Supported in Windows and Linux (KDE) correctly
+
+# 2.19.0
+
+Changes:
+* JSON option `modules.cpu.freqNdigits` has been renamed and moved to `display.freq.ndigits`
+    * Previously: `{ "modules": { "type": "cpu", "freqNdigits": 2 } }`
+    * Now: `{ "display": { "freq": { "ndigits": 2 } } }`
+    * This option now affects GPU frequency too
+    * By default, frequencies are displayed in *GHz*. Set `display.freq.ndigits` to `-1` to display them in *MHz*
+* JSON option `display.binaryPrefix` has been moved to `display.size.binaryPrefix`
+    * Previously: `{ "display": { "binaryPrefix": "IEC" } }`
+    * Now: `{ "display": { "size": { "binaryPrefix": "IEC" } } }`
+
+Features:
+* Print physical diagonal length if supported (Display)
+* Detect display type in X11 mode (Display)
+* Assume displays connected via DisplayPort are external monitors (Display, Linux)
+* Support GPU frequency detection for Intel XE driver (GPU, Linux)
+* Detect init system on Android (InitSystem, Android)
+* Use background to display color blocks (Colors)
+    * To fix weird vertical black lines in some terminals and match the behavior of neofetch (#1094)
+    * Can be reverted to old behavior with `--colors-symbol block`
+* Support Zed terminal version detection (Terminal)
+* Improve wezterm font detection (TerminalFont)
+* Add option `--separator-length`
+* Support GPU frequency detection for Apple Silicon (GPU, macOS)
+* Detect maximum refresh rate (#1101, Monitor)
+* Detect if HDR mode is supported and enabled (Windows, Display / Monitor)
+* Support physical monitor info detection for FreeBSD and SunOS (Monitor)
+* Support defining constant strings in JSON config file, which can be used to dedupe formattion strings
+```jsonc
+{
+    "display": {
+        "constants": [
+            "Hello", // {$1}
+            "world"  // {$2}
+        ]
+    },
+    "modules": [
+        {
+            "type": "custom",
+            "format": "{$1} {$2}!" // print "Hello world!"
+        },
+        {
+            "type": "custom",
+            "format": "{$2} {$1}" // print "world Hello"
+        }
+    ]
+}
+```
+
+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 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
+* Fix buffer overflow with long font family names when detecting kitty term font (TerminalFont)
+* Fix some typos
+
+Logos:
+* Update void_small
+* Add ALT Linux
+
+# 2.18.1
+
+Fix a regression introduced in v2.18.0
+
+Changes:
+* `--ts-version` has been renamed to `--detect-version`
+    * `general.detectVersion` in JSON config file
+
+Bugfixes:
+* Fix and improve GPU driver detection (#1084, GPU, Linux)
+
+# 2.18.0
+
+Changes:
+* `yyjson 0.10.0` is required
+* Fastfetch no longer prints `*` (which means it's the default route) if `defaultRouteOnly` is set (LocalIP)
+
+Bugfixes:
+* Fix some memory leaks
+* Fix compatibility with old Python versions
+* Don't detect frequency for AMD cards (GPU, Linux)
+    * Fix possible hang with discrete AMD cards (#1077)
+* Don't print colors in `--pipe` mode (Separator)
+* Don't print `(null)` in property `locator` (PhysicalMemory)
+* Ignore disabled PCI devices (GPU)
+* Fix flag `--opengl-library` doesn't work (OpenGL)
+
+Features:
+* Detect revision of USB drives (#1048, Disk)
+* Support fractional scale factor detection (Display, Linux)
+* Support primary display detection for KDE and GNOME (Display, Linux)
+* Support percent bar in custom formatting
+* Print signal quality by default (Wifi)
+* Detect used OpenGL library version (OpenGL)
+* Support detecting OpenGL version by `EGL` (ANGLE) on Windows (OpenGL)
+
+Logos:
+* Add Arkane Linux
+* Add Opak
+
+# 2.17.2
+
+Changes:
+* Flatpak package count no longer takes runtime packages into account (Packages, Linux)
+
+Bugfixes:
+* Fix formattion with multiple batteries (Battery)
+* Fix incorrect size value for large memory sticks (PhysicalMemory)
+* Fix spelling of `Qt` and `LXQt`
+* Fix building on SunOS if imagemagick support is enabled (Logo, SunOS)
+* Fix typos
+
+Features:
+* Support Ptyxis terminal version and font detection (Terminal / TerminalFont, Linux)
+* Improve Cinnamon version detection (DE)
+* Support `cinnamon-wayland` (WMTheme)
+* `--ts-version false` will disable editor version detection (Editor)
+
+# 2.17.1
+
+Hotfix for a regression that breaks Qt font detection
+
+Bugfixes:
+* Don't generate and install `libffwinrt.dll.a` on MinGW (Windows)
+* Fix building on Windows when imagemagick support is enabled (Logo, Windows)
+* Don't print GPU frequency with `--gpu-temp` for Nvidia cards (#1052, GPU)
+    * `--gpu-driver-specific` needs to be specified
+* Print formatted size when `--gpu-format` is used (#1052, GPU)
+* Ignore QVariant format; fix unreadable Qt font (#1053, Theme, Linux)
+* Fix segfaults with `--show-errors` and an invalid module (#1055)
+
+# 2.17.0
+
+Changes:
+* CMake option `ENABLE_PROPRIETARY_GPU_DRIVER_API` is removed. The GPU driver APIs are now enabled by default.
+    * The option was introduced to reduce the license concerns. Since all non MIT proprietary code has been rewritten manually from scratch, it is no longer necessary.
+    * See <https://github.com/fastfetch-cli/fastfetch/issues/533#issuecomment-2122830958> for detail
+* Option `--logo-separate true` is changed to `--logo-position top` for better readability
+    * Builtin ascii logos can be positioned on the right side now with`--logo-position right`
+
+Features:
+* Add support for `--gpu-detection-method opencl` which uses OpenCL to detect GPUs.
+* Support detecting CPU cache size by using SMBIOS as fallback (CPUCache)
+* Support GPU detection (SunOS)
+* Support GPU type detection with AMD GPU driver (GPU, Windows)
+* Add fast path of version and font detection for kitty (Terminal / TerminalFont)
+* Make sure `stdin` and `stdout` are TTYs when querying terminal
+    * So modules like `TerminalSize` should work when `stdin` or `stdout` is redirected
+* Support argument truncation in `--<module>-format` (#1043)
+    * See `fastfetch --help format` for detail
+* Improve Qt theme detection (#1047, Theme, Linux)
+* Add new JSON config option `general.preRun`, which is executed before fastfetch prints output.
+    * It can be used to generate a temp logo file. For example  
+```jsonc
+{
+    "general": {
+        "preRun": "kitten icat --align=left /path/to/image > /tmp/logo.kitty"
+    },
+    "logo": {
+        "source": "/tmp/logo.kitty",
+        "type": "raw"
+    }
+}
+```
+
+Bugfixes:
+* Fix invalid path (#1031, LM, Linux)
+* Fix VMEM detection for Nvidia GPU (requires `--gpu-driver-specific`) (GPU)
+* Fix AMD `--gpu-driver-specific` for AMD cards (#1032, GPU, Windows)
+* Use Coordinated Universal Time rather than timezone-varying local date (#1046)
+
+Logo:
+* Fix colors of Asahi Linux
+
+# 2.16.0
+
+This release added basic support for SunOS (Solaris, illumos). The binaries provided in the release lack a few useful features (such as Display detection). People who use SunOS should consider building fastfetch themselves.
+
+Changes:
+* Fastfetch now prefers `/etc/os-release` over `/etc/lsb-release` when detecting distro info. 
+    * This may break some distros (notably some debian based distros). File a bug with the content of `os-release` and `lsb-release` if it breaks your distro.
+
+Features:
+* Support Media detection in Windows (Media / Player, Windows)
+    * Requires Windows 10 and later
+* Add new option `--users-myself-only` to display current login user only (Users)
+* Add code name of macOS Sequoia (OS, macOS)
+* Add new module `DNS` to show active DNS servers (DNS)
+* Add new option `--loadavg-compact`. Defaults to true (Loadavg)
+    * Use `--loadavg-compact false` to display load averages in different lines
+* Detect MTU size (LocalIP)
+* Support version detection of pluma, which is the default editor of OpenIndiana (Editor)
+* Print used OGL library, eg EGL, GLX or OSMesa (OpenGL)
+
+Bugfixes:
+* Report error if cache size is unavailable (CPUCache, Android)
+* Trim white spaces in device name (Sound, Linux, #1005)
+* Fix `display.bar.border{Left,Right}` doesn't work in JSON config files (Config)
+* Fix invalid call to `realpath(3)` (Platform, Linux)
+* Fix result calculation (CPUUsage, FreeBSD)
+
+Logos:
+* Add Mauna
+* Add Tuxdeo
+* Add Manjaro ARM
+* Add RedOS
+* Add Arch3
+
+# 2.15.0
+
+Changes:
+* `--bar-border <?bool>` has been changed to `--bar-border-left <string>` and `--bar-border-right <string>`, which are used for customizing the style of bar border.
+    * `--bar-border-left '' --bar-border-right ''` can be used to disable the border
+
+Features:
+* Add ability to skip installing license with INSTALL_LICENSE option (CMake)
+* Make it possible to shorten the theme and icons output (Theme / Icons)
+* Support `-l '?'` to show a question mark
+* Add new module `CPUCache` to display CPU cache sizes (CPUCache)
+* In `--<module>-format`, `{#keys}` and `{#title}` can be used to reference the color of keys and title
+* Improve speed of Guix package detection (Packages, Linux)
+* Assume wm plugins are daemon processes to improve performance (WM, macOS)
+
+Bugfixes:
+* Remove shebangs from completions (#980)
+* Fix while chars not visible in terminal of light theme (Logo)
+* Normalize bright colors to fix color display in Apple Terminal (#991, Colors)
+* Correctly capitalize GNOME (#997, DE, Linux)
+* Fix segfault on system using turkish language (#995, InitSystem, Linux)
+* Fix kubuntu detection (#1000, OS, Linux)
+* Don't display duplicate entries (OS, Linux)
+
+# 2.14.0
+
+Features:
+* Support monochrome bar type (#960)
+* Support editor version detection on Windows (Editor, Windows)
+* Apply default color palettes in `--file` and `--data` (Logo)
+* Print all presets in `--list-presets` for better Windows support (Windows)
+* Support for guix package manager detection (Packages, Linux)
+* Support named variable placeholders in custom module formattion string (#796)
+    * `--title-format '{user-name-colored}{at-symbol-colored}{host-name-colored}'` is now equivalent to `--title-format '{6}{7}{8}'`
+* Support named color placeholders in custom module formattion string
+    * `--<module>-format '{#red}'` is now equivalent to `--<module>-format '{#31}'`
+    * `'{#red}'` or `'{#31}'` is preferred over `\u001b[31m` because is more readable and `--pipe` aware (will be ignored in pipe mode)
+    * Supported in `Custom` module too
+    * See `fastfetch -h format` for detail
+* Add new module `InitSystem`, which detects the name of init system
+    * i.e. process name of pid1. `init`, `systemd`, etc
+* Add option `--color-separator` to set the color of key-value separators
+* Support Guix package manager count (#792, Packages, Linux)
+* Improve python based shell detection (#977, Shell, macOS)
+* Print error reason when vulkan init fails (Vulkan)
+
+Bugfixes:
+* Don't detect `.conf` files in `--list-config-paths`
+* Don't try to detect terminals in MSYS shell with process backtracing (Windows)
+* Fix `outputColor` doesn't work if module keys are disabled
+
+Logos:
+* Add Cereus Linux
+* Re-add special handling of Loc-OS
+
+# 2.13.2
+
+Another hotfix release :(
+
+Bugfixes:
+* Remove DRM driver version detection feature, which caused a performance regression for nouveau drivers (#956, Display, Linux)
+* Fix compatibility for old python versions. Regression of `2.13.0`
+* Don't use `*-unknown` as display name for Wayland protocol (Display, Linux)
+
+Features:
+* Add new module `Editor` which prints information of the default editor, i.e. $VISUAL or $EDITOR (#430, Editor)
+
+Logos:
+* Added CuerdOS
+* Remove special handling of Loc-OS
+
+# 2.13.1
+
+Fix a regression introduced in v2.13.0
+
+Bugfixes:
+* Fix CPU frequency not displayed if `bios_limit` is not available (CPU, Linux)
+
+Features:
+* Add `--cpu-show-pe-core-count` to detect and display core count for performance / efficiency cores (CPU, FreeBSD)
+
+# 2.13.0
+
+Changes:
+* Option `--gpu-force-vulkan <?bool>` has been changed to `--gpu-detection-method <enum>`
+    * Use `--gpu-detection-method vulkan` to get the old behavior
+    * See `fastfetch -h gpu-detection-method` for detail
+* In Linux, BIOS limited CPU frequency is printed by default to match the behavior of neofetch (CPU, Linux, #947)
+
+Features:
+* Add new module `Bootmgr` which prints information of stage 2 bootloader (grub, system-boot, etc)
+    * Requires root permission to work on Windows and FreeBSD
+    * Requires booting in UEFI mode
+* Add package manager lpkg and lpkg-build support (Packages, Linux)
+* Improve macOS 10.13 compatibility (macOS)
+* Detect core count for performance / efficiency cores (CPU)
+    * Test it with `fastfetch -s cpu --cpu-format '{9}'`
+* Support min / max frequency and physical core count detection in FreeBSD, if kernel supports it (CPU, FreeBSD)
+* Detect DRM driver version if DRM detection method is used (GPU, Linux)
+
+Bugfixes:
+* Don't detect `clifm` and `valgrind` as a terminal (Terminal, Linux)
+* Improve stability (PhysicalMemory, FreeBSD)
+* Fix bssid & status detection (Wifi, FreeBSD)
+* Ensure createTime is correctly initialized (Disk, FreeBSD / macOS)
+* Fix `--cpu-freq-ndigits` not working if `--cpu-format` is used
+* Fix `nix-user` package count detection (Packages, Linux)
+* Fix some memory leaks
+
+Logos:
+* Fix Manjaro logo not displayed
+* Add SpoinkOS
+* Add Loc-OS
+* Add Furreto Linux
+* Fix TorizonCore logo colors
+* Fix KDE neon logo not displayed
+
+# 2.12.0
+
+Changes:
+* The long deprecated flag based config files are removed.
+    * They can still be used with `xargs fastfetch < /path/to/config.conf`
+    * `--gen-config` can be used to migrate them to json based config files
+* The long deprecated options `--set` and `--set-keyless` are removed.
+* `Kernel` module now prints kernel name by default
+
+Features:
+* Support `st` terminal font detection for font configuration compiled in `st` binary (TerminalFont, Linux)
+* Add option `--color-output` to change output color of all modules except `Title`, `Separator`
+    * `display.color.output` in JSONC config file
+* Add option `--<module>-output-color` to change output color of one specified module, which overrides the global option `--color-output`
+* Add option `--publicip-ipv6` to print IPv6 address (PublicIP)
+* Add new module `Loadavg` to print load averages (Loadavg)
+* Add new module `PhysicalMemory` to print information of physical memory devices (PhysicalMemory)
+    * Requires root permission to work on Linux and FreeBSD
+* Support specifying `--logo-width` only for `--kitty-direct` and `--iterm` (Logo)
+* Add option `--localip-show-all-ips` to show all IPs assigned to the same interface (LocalIP)
+    * Default to `false`
+* Improve compatibility with `(*term)` (#909, Terminal, macOS)
+* Support GPU core count and frequency detection for Asahi Linux (GPU, Linux)
+
+Bugfixes:
+* Rename option `--temperature-unit` to `--temp-unit` as documented in help messages
+* Fix alternate logo doesn't work with `{ "type": "builtin" }` (#914, Logo)
+
+Logos:
+* Fix DahliaOS detection
+* Add openSUSE Slowroll
+* Add macOS3
+* Add Quirinux
+
+# 2.11.5
+
+Bugfix:
+* Fix logo printing for OpenMandriva (#896)
+* Remove `--os-file` in help messages
+
+# 2.11.4
+
+Changes:
+* Fastfetch will print a colorless ascii logo in `--pipe` mode for better `lolcat` compatibility. `fastfetch | lolcat` should work and no `--pipe false` needed.
+    * Previously the logo would be disabled in `--pipe` mode.
+    * Use `--pipe -l none` to get the old beheavior
+* `--os-file` was removed and CMake option `-DCUSTOM_OS_RELEASE_PATH=/path/to/os-release` was introduced for configuring at compile time by package managers if needed. This option should not used in most cases.
+
+Bugfixes:
+* Fix possible out-of-bound memory access (#868)
+* Fix Apple Terminal detection (#878, macOS, Terminal)
+* Fix deprecation warning for macOS 14.0 hopefully (#860, macOS, Camera)
+* Fix memory leaks when passing informative options (#888)
+* Fix JSON config `size.ndigits` doesn't work 
+
+Features:
+* Enable `--pipe` mode if environment variable `$NO_COLOR` is set
+* Support Armbian and Proxmox distro detection (OS, Linux)
+
+Logo:
+* Add Armbian
+
+# 2.11.3
+
+Hotfix for nix (https://github.com/NixOS/nixpkgs/issues/308849#issuecomment-2093962376)
+
+Features:
+* Add cmake option `CUSTOM_AMDGPU_IDS_PATH` for specifying custom path of `amdgpu.ids`
+
+Bugfixes:
+* Fix hanging when detecting disconnected network drive (Disk, Windows)
+* Ensure line ending is printed when printing image logo errors (Logo)
+* Revert image logo limitation change in 2.11.2; allow image logo in SSH session and tmux again (#861, Logo)
+* Fix doubled output in custom formation (PhysicalDisk, Windows)
+
+# 2.11.2
+
+Hotfix for Debian 11
+
+Changes:
+* Error messages when trying to print image logo will only be printed with `--show-errors`
+* When generating JSON output, fastfetch will generate an empty array when no result is detected, instead of an error.
+
+Bugfixes:
+* Fix segfault in Debian 11 and some old kernels. Regression introduced in 2.11.0 (#845, GPU, Linux)
+* Don't try detecting version of raw `sh` shell (#849, Shell, Linux)
+* Trim `\r` on Windows
+
+Features:
+* Check xdg state home for nix user packages (#837, Packages, Linux)
+* Disable image logos in ssh and tmux sessions (#839)
+* Support MX Linux distro detection (#847, OS, Linux)
+
+Logo:
+* Add KernelOS
+* Fix name of DraugerOS
+* Add missing `FF_LOGO_LINE_TYPE_SMALL_BIT` flags
+* Add MX2
+
+# 2.11.1
+
+Hotfix for Android
+
+Bugfixes:
+* Fix uninitialized variables which can cause crashes (#760 #838, Battery, Android)
+* Don't detect hyfetch as shell when used as backend of [hyfetch](https://github.com/hykilpikonna/hyfetch)
+* Fix incorrect information in man page (#828)
+
+Features:
+* Support sorcery package manager detection (Packages, Linux)
+* Make `--custom-format` optional (Custom)
+* Make `/` an alias of `C:\` for `--disk-folders` (Disk, Windows)
+* Build for Linux armv7
+
+Logo:
+* Fix colors of Source Mage logo
+
+# 2.11.0
+
+Changes:
+* Default `hideCursor` to false. It doesn't make much difference but makes user's terminal unusable if fastfetch is not exited correctly.
+* Linux amd64 binaries are built with Ubuntu 20.04 again (#808)
+
+Bugfixes:
+* Fix swap usage detection in x86-32 build (Windows, Swap)
+* Fix minimum cmake version support (#810)
+* Fix wifi detection on platforms that don't use NetworkManager (#811, Wifi, Linux)
+* Fix NixOS wrapped process name (#814, Terminal, Linux)
+* Fix GPU type detection for AMD cards (#816, GPU, Linux)
+* Silence system deprecation warnings (#822, Camera, macOS)
+
+Features:
+* Add basic support DE detection support for UKUI (DE, Linux)
+* Support printing total number of nix / flatpak / brew packages (Packages)
+    * See `fastfetch -h packages-format` for detail
+* Better max CPU frequency detection support with `CPUID / 16H` instruction (CPU, Windows)
+    * This requires Intel Core I Gen 6 or newer, and with `Virtual Machine Platform` Windows feature disabled. X86 only.
+* Improve performance of nix packages detection (Packages, Linux)
+* Make config specified in JSONC overridable by command line flags
+    * Note this change only make global config overridable; module configs are still not
+* Suggest increasing `--processing-timeout` when child process timeouts
+* Only detect folders that specified by `--disk-folders`
+    * Previously `--disk-folders` only omits unmatched disks from output
+    * This option can be used to improve detection performance by ignoring slow network drives
+
+# 2.10.2
+
+Bugfixes:
+* Fix a regression that detect x11 as wayland (#805, WM, Linux)
+
+# 2.10.1
+
+Bugfixes:
+* Fix build with `-DENABLE_DBUS=OFF` (Linux)
+
+# 2.10.0
+
+Changes:
+* We now always detect max frequency of GPUs for consistent, instead of current frequency
+
+Features:
+* Improve display detection for wlroots based WMs. Fastfetch now correctly reports fractional scale factors in hyprland (Display, Linux)
+* Improve GPU detection on Linux (GPU, Linux)
+    * Support GPU memory usage detection for AMD GPUs
+    * Support GPU frequency detection for Intel GPUs
+* Improve performance of GNOME version detection (DE, Linux)
+* Improve performance of kitty version detection (Terminal, Linux)
+* Detect refresh rate when using `--ds-force-drm sysfs-only` (Display, Linux)
+* Add option `--ts-version` to disable terminal and shell version detection. Mainly for benchmarking purposes
+* Improve performance of detecting WSL version (Host, Linux)
+
+Bugfixes:
+* Correctly detect `/bin/sh` as current shell if it's used as default shell (#798, Shell, Linux)
+* Work around an issue which CPU module reports incorrect CPU frequency that is too high (#800, CPU, Linux)
+* Don't print ANSI escape codes in `--pipe` mode
+
+# 2.9.2
+
+Changes:
+* To make use of the newly introduced `yyjson` flag `YYJSON_WRITE_NEWLINE_AT_END`, fastfetch now requires `yyjson` 0.9.0 or later
+
+Features:
+* Always add a final new-line when generating JSON output
+* Detect partition create time, which can be used as OS installation time (Disk)
+* Print time string when generating JSON result instead of UNIX epoch time number, which is more human-readable
+
+Bugfixes:
+* Fix a memory leak
+* Better portable mode detection of Windows Terminal (TerminalFont, Windows)
+* Fix parsing of option `--packages-disabled` (Packages)
+* Don't use command `time` as a shell (Shell)
+
+Logos:
+* Add openSUSE MicroOS
+* Fix color of AOSC OS
+
+# 2.9.1
+
+Features:
+* Support weston-terminal (missed commit in v2.9.0) (TerminalFont, Linux)
+* Support hyprcursor detection (#776, Cursor, Linux)
+
+Bugfixes:
+* Fix `fastfetch --gen-config` raises SIGSEGV when `~/.config/fastfetch` doesn't exist. Regression of `2.9.0` (#778)
+
+# 2.9.0
+
+Features:
+* Support Lxterminal version detection (Terminal, Linux)
+* Support weston-terminal version detection (Terminal, Linux)
+* Support `am` package manager detection (#771, Packages, Linux)
+* Support network prefix length detection for IPv6 (LocalIP)
+* Display all IPs when multiple IPs are assigned to the same interface (LocalIP)
+* Add option `--localip-show-prefix-len` to show network prefix length for both IPv4 and IPv6. Defaults to `true` (LocalIP)
+
+Bugfixes:
+* Fix network prefix length detection when the value is greater than 24 (#773, LocalIP, Linux)
+* For xfce4-terminal, use system mono font if no config file is found (TerminalFont, Linux)
+
+# 2.8.10
+
+Bugfixes:
+* Don't display 0.00 GHz (CPU, FreeBSD)
+* Don't detect manufactor of Qualcomm as ARM (CPU, Android)
+* Ignore `chezmoi` (Terminal, Linux)
+* Trim trailing possible whitespaces (PublicIP)
+* Fix detection compatibility for KDE 6 (Font, Linux)
+* Always use Metal API to detect vmem size (GPU, macOS)
+
+Features:
+* Improve stability; print more useful error message; avoid misuse (PublicIP / Weather)
+* Use MS-DOS device name as mountFrom result, instead of useless GUID volume name (Windows, Disk)
+* Some adjustments to Terminal detection (Terminal, Windows)
+    * Don't pretty print CMD
+    * Print conhost as Windows Console
+    * Don't detect `wininit` as Terminal
+
+Logo:
+* Fix color of Arco Linux
+
+# 2.8.9
+
+Bugfixes:
+* Don't detect `SessionLeader` as terminal, actually (Terminal, Linux)
+* Fix blurry chafa result when specifying both width and height (#757, Logo)
+
+Features:
+* Support new MacBook Air (Host, macOS)
+* Distinguish min frequency and base frequency (CPU)
+
+Logo:
+* Fix proxmox
+
+# 2.8.8
+
+Bugfixes:
+* Fix old fish version compatibility (#744)
+* Fix truncated texts in `--help format` (#745)
+* Fix old vulkan-header and libdrm library compatibility (#748, Linux)
+* Fix possible segfaults in `--help *-format` (#749)
+* Fix invalid resolution detection when using libdrm (Linux, Display)
+* Fix segfault when `/sys/devices/system/cpu/cpufreq/` doesn't exist (#750, CPU, Linux)
+* Don't detect `SessionLeader` as terminal (Terminal, Linux)
+* Fix detection of client IP (Users, Linux)
+
 # 2.8.7

 Bugfixes:
@@ -589,7 +1362,7 @@ Bugfixes:
 This release backports some changes from dev branch, and fixes 2 crashing issues

 Features:
-* Support KDE / LXQT / MATE / Cinnamon wallpaper detection (Wallpaper, Linux)
+* Support KDE / LXQt / MATE / Cinnamon wallpaper detection (Wallpaper, Linux)
 * Support QTerminal version & terminal font detection
 * Support MATE Terminal version & terminal font detection
 * Set `--pipe true` automatically if stdout is not a tty
@@ -605,7 +1378,7 @@ Bugfixes:
 * Fix Windows drives detection in WSL (Linux, Disk)
 * Fix CPU temp detection (FreeBSD, CPU)
 * Fix disk detection (Android, Disk)
-* Fix Gnome Terminal version and font detection (FreeBSD, TerminalFont)
+* Fix GNOME Terminal version and font detection (FreeBSD, TerminalFont)
 * Fix crash on newer wayland desktops (Linux, Display, #477)
 * Fix vendor detection for Intel GPU (macOS, GPU)
 * Fix possible crashes on Windows Server (Windows, GPU, #484)
@@ -631,11 +1404,11 @@ Features:
 * Add mac address detection `--localip-show-mac` (LocalIP, #451)

 Bugfixes:
-* Fix Gnome version detection on Fedora (DE)
+* Fix GNOME version detection on Fedora (DE)
 * Fix Windows drives detection in WSL (Disk)

 Changes:
-* In order to make Icons module consistent between different platforms, `--icons-format` no longer supports individual GTK / QT icon params.
+* In order to make Icons module consistent between different platforms, `--icons-format` no longer supports individual GTK / Qt icon params.
 * `--theme-format` no longer supports individual GTK / plasma theme params.
 * `--local-ip-*` and `--public-ip-*` have been changed to `--localip-*` and `--publicip-*`
 * `--localip-compact-type` is no longer supported. Fastfetch now display IPs as `--localip-compat-type multiline` by default, with `--local-compact true` can be set as an alias of `--localip-compact-type oneline`
@@ -1009,7 +1782,7 @@ Fixes build on android (#205)
 # 1.6.0

 Features:
-* Detect QT on more DEs than just KDE Plasma. The [Plasma] category was therefore renamed to [QT]
+* Detect Qt on more DEs than just KDE Plasma. The [Plasma] category was therefore renamed to [Qt]
 * Alacritty font detection
 * Load `/etc/fastfetch/config.conf` before user config
 * Disk: print one decimal point if size < 100GB
@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.12.0) # target_link_libraries with OBJECT libs & project homepage url

 project(fastfetch
-    VERSION 2.8.7
+    VERSION 2.23.0
    LANGUAGES C
    DESCRIPTION "Fast neofetch-like system information tool"
    HOMEPAGE_URL "https://github.com/fastfetch-cli/fastfetch"
@@ -14,10 +14,12 @@ set(PROJECT_LICENSE "MIT license")
 ###################
 if(ANDROID)
    set(LINUX FALSE)
-elseif("${CMAKE_SYSTEM_NAME}" MATCHES ".*[Ll]inux.*")
+elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
    set(LINUX TRUE CACHE BOOL "..." FORCE) # LINUX means GNU/Linux, not just the kernel
-elseif("${CMAKE_SYSTEM_NAME}" MATCHES ".*[Bb][Ss][Dd].*")
-    set(BSD TRUE CACHE BOOL "..." FORCE)
+elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "FreeBSD")
+    set(FreeBSD TRUE CACHE BOOL "..." FORCE)
+elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "SunOS")
+    set(SunOS TRUE CACHE BOOL "..." FORCE)
 elseif(NOT APPLE AND NOT WIN32)
    message(FATAL_ERROR "Unsupported platform: ${CMAKE_SYSTEM_NAME}")
 endif()
@@ -42,42 +44,54 @@ include(CheckIncludeFile)

 include(CMakeDependentOption)

-cmake_dependent_option(ENABLE_VULKAN "Enable vulkan" ON "LINUX OR APPLE OR BSD OR WIN32 OR ANDROID" OFF)
-cmake_dependent_option(ENABLE_WAYLAND "Enable wayland-client" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_XCB_RANDR "Enable xcb-randr" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_XCB "Enable xcb" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_XRANDR "Enable xrandr" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_X11 "Enable x11" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_DRM "Enable libdrm" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_GIO "Enable gio-2.0" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_DCONF "Enable dconf" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_DBUS "Enable dbus-1" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_XFCONF "Enable libxfconf-0" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_SQLITE3 "Enable sqlite3" ON "LINUX OR BSD OR APPLE" OFF)
+cmake_dependent_option(ENABLE_VULKAN "Enable vulkan" ON "LINUX OR APPLE OR FreeBSD OR WIN32 OR ANDROID OR SunOS" OFF)
+cmake_dependent_option(ENABLE_WAYLAND "Enable wayland-client" ON "LINUX OR FreeBSD" OFF)
+cmake_dependent_option(ENABLE_XCB_RANDR "Enable xcb-randr" ON "LINUX OR FreeBSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_XCB "Enable xcb" ON "LINUX OR FreeBSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_XRANDR "Enable xrandr" ON "LINUX OR FreeBSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_X11 "Enable x11" ON "LINUX OR FreeBSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_DRM "Enable libdrm" ON "LINUX OR FreeBSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_GIO "Enable gio-2.0" ON "LINUX OR FreeBSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_DCONF "Enable dconf" ON "LINUX OR FreeBSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_DBUS "Enable dbus-1" ON "LINUX OR FreeBSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_XFCONF "Enable libxfconf-0" ON "LINUX OR FreeBSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_SQLITE3 "Enable sqlite3" ON "LINUX OR FreeBSD OR APPLE OR SunOS" OFF)
 cmake_dependent_option(ENABLE_RPM "Enable rpm" ON "LINUX" OFF)
-cmake_dependent_option(ENABLE_IMAGEMAGICK7 "Enable imagemagick 7" ON "LINUX OR BSD OR APPLE OR WIN32" OFF)
-cmake_dependent_option(ENABLE_IMAGEMAGICK6 "Enable imagemagick 6" ON "LINUX OR BSD OR APPLE" OFF)
+cmake_dependent_option(ENABLE_IMAGEMAGICK7 "Enable imagemagick 7" ON "LINUX OR FreeBSD OR APPLE OR WIN32 OR SunOS" OFF)
+cmake_dependent_option(ENABLE_IMAGEMAGICK6 "Enable imagemagick 6" ON "LINUX OR FreeBSD OR APPLE OR SunOS" 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 BSD" OFF)
-cmake_dependent_option(ENABLE_GLX "Enable glx" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_OSMESA "Enable osmesa" ON "LINUX OR BSD" OFF)
-cmake_dependent_option(ENABLE_OPENCL "Enable opencl" ON "LINUX OR BSD OR WIN32" OFF)
-cmake_dependent_option(ENABLE_LIBNM "Enable libnm" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_EGL "Enable egl" ON "LINUX OR FreeBSD OR WIN32 OR SunOS" OFF)
+cmake_dependent_option(ENABLE_GLX "Enable glx" ON "LINUX OR FreeBSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_OSMESA "Enable osmesa" ON "LINUX OR FreeBSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_OPENCL "Enable opencl" ON "LINUX OR FreeBSD OR WIN32 OR ANDROID OR SunOS" OFF)
 cmake_dependent_option(ENABLE_FREETYPE "Enable freetype" ON "ANDROID" OFF)
-cmake_dependent_option(ENABLE_PULSE "Enable pulse" ON "LINUX" OFF)
+cmake_dependent_option(ENABLE_PULSE "Enable pulse" ON "LINUX OR SunOS" 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 FreeBSD OR ANDROID" 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)

 option(ENABLE_SYSTEM_YYJSON "Use system provided (instead of fastfetch embedded) yyjson library" OFF)
 option(ENABLE_ASAN "Build fastfetch with ASAN (address sanitizer)" OFF)
-option(ENABLE_PROPRIETARY_GPU_DRIVER_API "Enable proprietary GPU driver API (NVML, IGCL and AGS)" ON)
+option(ENABLE_LTO "Enable link-time optimization in release mode if supported" ON)
 option(BUILD_TESTS "Build tests" OFF) # Also create test executables
 option(SET_TWEAK "Add tweak to project version" ON) # This is set to off by github actions for release builds
+option(IS_MUSL "Build with musl libc" OFF) # Used by Github Actions
+option(INSTALL_LICENSE "Install license into /usr/share/licenses" ON)
+
+set(BINARY_LINK_TYPE_OPTIONS dlopen dynamic static)
+set(BINARY_LINK_TYPE dlopen CACHE STRING "How to link fastfetch")
+set_property(CACHE BINARY_LINK_TYPE PROPERTY STRINGS ${BINARY_LINK_TYPE_OPTIONS})
+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()

 if (LINUX)
    set(CUSTOM_PCI_IDS_PATH "" CACHE STRING "Custom path to file pci.ids, defaults to `/usr/share/hwdata/pci.ids`")
+    set(CUSTOM_AMDGPU_IDS_PATH "" CACHE STRING "Custom path to file amdgpu.ids, defaults to `/usr/share/libdrm/amdgpu.ids`")
+    set(CUSTOM_OS_RELEASE_PATH "" CACHE STRING "Custom path to file os-release, defaults to `/etc/os-release`")
 endif()

 ####################
@@ -107,12 +121,12 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS} -Werror=incompatible-pointe
 if(WIN32 OR ENABLE_DIRECTX_HEADERS)
    enable_language(CXX)
    set(CMAKE_CXX_STANDARD 17)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS} -fno-exceptions -fno-rtti")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS}")
 endif()

 if(WIN32)
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--tsaware -Wl,--build-id -Wl,--subsystem,console:6.1,--major-os-version,6,--minor-os-version,1")
-elseif(APPLE)
+elseif(APPLE AND CMAKE_C_COMPILER_ID MATCHES "Clang")
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fobjc-arc")
 endif()

@@ -127,7 +141,7 @@ if(NOT WIN32)
    set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} -rdynamic")
 endif()

-if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+if(ENABLE_LTO AND NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
    message(STATUS "Enabling LTO")
    include(CheckIPOSupported)
    check_ipo_supported(RESULT IPO_SUPPORTED)
@@ -189,10 +203,10 @@ if (SET_TWEAK AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
    execute_process(
        COMMAND git describe --tags
        WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
-        OUTPUT_VARIABLE PROJECT_VERSION_TWEAK
+        OUTPUT_VARIABLE PROJECT_VERSION_GIT
        OUTPUT_STRIP_TRAILING_WHITESPACE
    )
-    string(REGEX MATCH "-[0-9]+" PROJECT_VERSION_TWEAK "${PROJECT_VERSION_TWEAK}")
+    string(REGEX MATCH "-[0-9]+" PROJECT_VERSION_TWEAK "${PROJECT_VERSION_GIT}")
 endif()
 if(PROJECT_VERSION_TWEAK)
    string(REGEX MATCH "[0-9]+" PROJECT_VERSION_TWEAK_NUM "${PROJECT_VERSION_TWEAK}")
@@ -243,7 +257,7 @@ if(APPLE)
    configure_file(src/util/apple/Info.plist.in Info.plist @ONLY)
 endif()

-string(TIMESTAMP FASTFETCH_BUILD_DATE "%d %B %Y")
+string(TIMESTAMP FASTFETCH_BUILD_DATE "%d %B %Y" UTC)
 configure_file(doc/fastfetch.1.in fastfetch.1 @ONLY)

 ####################
@@ -254,7 +268,7 @@ file(GLOB LOGO_FILES "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_WLE)
+    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")
@@ -281,19 +295,24 @@ set(LIBFASTFETCH_SRC
    src/common/properties.c
    src/common/settings.c
    src/common/temps.c
+    src/detection/bluetoothradio/bluetoothradio.c
+    src/detection/bootmgr/bootmgr.c
    src/detection/chassis/chassis.c
    src/detection/cpu/cpu.c
    src/detection/cpuusage/cpuusage.c
    src/detection/disk/disk.c
    src/detection/diskio/diskio.c
    src/detection/displayserver/displayserver.c
+    src/detection/editor/editor.c
    src/detection/font/font.c
    src/detection/gpu/gpu.c
    src/detection/media/media.c
    src/detection/netio/netio.c
    src/detection/opencl/opencl.c
+    src/detection/opengl/opengl_shared.c
    src/detection/os/os.c
    src/detection/packages/packages.c
+    src/detection/physicalmemory/physicalmemory.c
    src/detection/publicip/publicip.c
    src/detection/terminaltheme/terminaltheme.c
    src/detection/terminalfont/terminalfont.c
@@ -309,13 +328,16 @@ set(LIBFASTFETCH_SRC
    src/modules/battery/battery.c
    src/modules/bios/bios.c
    src/modules/bluetooth/bluetooth.c
+    src/modules/bluetoothradio/bluetoothradio.c
    src/modules/board/board.c
+    src/modules/bootmgr/bootmgr.c
    src/modules/brightness/brightness.c
    src/modules/break/break.c
    src/modules/camera/camera.c
    src/modules/chassis/chassis.c
    src/modules/colors/colors.c
    src/modules/cpu/cpu.c
+    src/modules/cpucache/cpucache.c
    src/modules/cpuusage/cpuusage.c
    src/modules/cursor/cursor.c
    src/modules/custom/custom.c
@@ -324,13 +346,17 @@ set(LIBFASTFETCH_SRC
    src/modules/de/de.c
    src/modules/disk/disk.c
    src/modules/diskio/diskio.c
+    src/modules/dns/dns.c
+    src/modules/editor/editor.c
    src/modules/font/font.c
    src/modules/gpu/gpu.c
    src/modules/host/host.c
    src/modules/icons/icons.c
+    src/modules/initsystem/initsystem.c
    src/modules/gamepad/gamepad.c
    src/modules/kernel/kernel.c
    src/modules/lm/lm.c
+    src/modules/loadavg/loadavg.c
    src/modules/locale/locale.c
    src/modules/localip/localip.c
    src/modules/memory/memory.c
@@ -341,6 +367,7 @@ set(LIBFASTFETCH_SRC
    src/modules/os/os.c
    src/modules/packages/packages.c
    src/modules/physicaldisk/physicaldisk.c
+    src/modules/physicalmemory/physicalmemory.c
    src/modules/processes/processes.c
    src/modules/player/player.c
    src/modules/poweradapter/poweradapter.c
@@ -366,14 +393,17 @@ set(LIBFASTFETCH_SRC
    src/modules/wifi/wifi.c
    src/modules/wm/wm.c
    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/options/library.c
    src/util/edidHelper.c
+    src/util/base64.c
    src/util/FFlist.c
    src/util/FFstrbuf.c
+    src/util/path.c
    src/util/platform/FFPlatform.c
    src/util/smbiosHelper.c
 )
@@ -388,18 +418,30 @@ if(LINUX)
        src/detection/battery/battery_linux.c
        src/detection/bios/bios_linux.c
        src/detection/board/board_linux.c
+        src/detection/bootmgr/bootmgr_linux.c
        src/detection/brightness/brightness_linux.c
        src/detection/chassis/chassis_linux.c
        src/detection/cpu/cpu_linux.c
+        src/detection/cpucache/cpucache_linux.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_linux.c
+        src/detection/physicalmemory/physicalmemory_linux.c
        src/detection/diskio/diskio_linux.c
        src/detection/displayserver/linux/displayserver_linux.c
        src/detection/displayserver/linux/drm.c
-        src/detection/displayserver/linux/wayland.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/kde-output.c
+        src/detection/displayserver/linux/wayland/wlr-output-management-unstable-v1-protocol.c
+        src/detection/displayserver/linux/wayland/kde-output-device-v2-protocol.c
+        src/detection/displayserver/linux/wayland/kde-output-order-v1-protocol.c
+        src/detection/displayserver/linux/wayland/xdg-output-unstable-v1-protocol.c
        src/detection/displayserver/linux/wmde.c
        src/detection/displayserver/linux/xcb.c
        src/detection/displayserver/linux/xlib.c
@@ -409,8 +451,10 @@ if(LINUX)
        src/detection/gtk_qt/gtk.c
        src/detection/host/host_linux.c
        src/detection/icons/icons_linux.c
+        src/detection/initsystem/initsystem_linux.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_linux.c
@@ -439,7 +483,9 @@ if(LINUX)
        src/detection/de/de_linux.c
        src/detection/wmtheme/wmtheme_linux.c
        src/detection/camera/camera_linux.c
+        src/detection/zpool/zpool_linux.c
        src/util/platform/FFPlatform_unix.c
+        src/util/binary_linux.c
    )
 elseif(ANDROID)
    list(APPEND LIBFASTFETCH_SRC
@@ -450,22 +496,29 @@ elseif(ANDROID)
        src/detection/battery/battery_android.c
        src/detection/bios/bios_android.c
        src/detection/bluetooth/bluetooth_nosupport.c
+        src/detection/bluetoothradio/bluetoothradio_nosupport.c
        src/detection/board/board_android.c
+        src/detection/bootmgr/bootmgr_nosupport.c
        src/detection/brightness/brightness_nosupport.c
        src/detection/chassis/chassis_nosupport.c
        src/detection/cpu/cpu_linux.c
+        src/detection/cpucache/cpucache_linux.c
        src/detection/cursor/cursor_nosupport.c
        src/detection/cpuusage/cpuusage_linux.c
        src/detection/disk/disk_linux.c
+        src/detection/dns/dns_linux.c
        src/detection/physicaldisk/physicaldisk_linux.c
+        src/detection/physicalmemory/physicalmemory_nosupport.c
        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/host/host_android.c
        src/detection/icons/icons_nosupport.c
+        src/detection/initsystem/initsystem_linux.c
        src/detection/libc/libc_android.c
        src/detection/lm/lm_nosupport.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
@@ -493,9 +546,11 @@ elseif(ANDROID)
        src/detection/de/de_nosupport.c
        src/detection/wmtheme/wmtheme_nosupport.c
        src/detection/camera/camera_android.c
+        src/detection/zpool/zpool_nosupport.c
        src/util/platform/FFPlatform_unix.c
+        src/util/binary_linux.c
    )
-elseif(BSD)
+elseif(FreeBSD)
    list(APPEND LIBFASTFETCH_SRC
        src/common/dbus.c
        src/common/io/io_unix.c
@@ -506,18 +561,30 @@ elseif(BSD)
        src/detection/battery/battery_bsd.c
        src/detection/bios/bios_bsd.c
        src/detection/bluetooth/bluetooth_linux.c
+        src/detection/bluetoothradio/bluetoothradio_linux.c
        src/detection/board/board_bsd.c
+        src/detection/bootmgr/bootmgr_bsd.c
        src/detection/brightness/brightness_bsd.c
        src/detection/chassis/chassis_bsd.c
        src/detection/cpu/cpu_bsd.c
+        src/detection/cpucache/cpucache_shared.c
        src/detection/cpuusage/cpuusage_bsd.c
        src/detection/cursor/cursor_linux.c
        src/detection/disk/disk_bsd.c
+        src/detection/dns/dns_linux.c
        src/detection/physicaldisk/physicaldisk_bsd.c
+        src/detection/physicalmemory/physicalmemory_linux.c
        src/detection/diskio/diskio_bsd.c
        src/detection/displayserver/linux/displayserver_linux.c
        src/detection/displayserver/linux/drm.c
-        src/detection/displayserver/linux/wayland.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/kde-output.c
+        src/detection/displayserver/linux/wayland/wlr-output-management-unstable-v1-protocol.c
+        src/detection/displayserver/linux/wayland/kde-output-device-v2-protocol.c
+        src/detection/displayserver/linux/wayland/kde-output-order-v1-protocol.c
+        src/detection/displayserver/linux/wayland/xdg-output-unstable-v1-protocol.c
        src/detection/displayserver/linux/wmde.c
        src/detection/displayserver/linux/xcb.c
        src/detection/displayserver/linux/xlib.c
@@ -528,13 +595,15 @@ elseif(BSD)
        src/detection/host/host_bsd.c
        src/detection/lm/lm_linux.c
        src/detection/icons/icons_linux.c
+        src/detection/initsystem/initsystem_linux.c
        src/detection/libc/libc_bsd.c
+        src/detection/loadavg/loadavg_bsd.c
        src/detection/locale/locale_linux.c
        src/detection/localip/localip_linux.c
        src/detection/gamepad/gamepad_bsd.c
        src/detection/media/media_linux.c
        src/detection/memory/memory_bsd.c
-        src/detection/monitor/monitor_nosupport.c
+        src/detection/monitor/monitor_linux.c
        src/detection/netio/netio_bsd.c
        src/detection/opengl/opengl_linux.c
        src/detection/os/os_linux.c
@@ -557,7 +626,9 @@ elseif(BSD)
        src/detection/de/de_linux.c
        src/detection/wmtheme/wmtheme_linux.c
        src/detection/camera/camera_linux.c
+        src/detection/zpool/zpool_linux.c
        src/util/platform/FFPlatform_unix.c
+        src/util/binary_linux.c
    )
 elseif(APPLE)
    list(APPEND LIBFASTFETCH_SRC
@@ -569,22 +640,29 @@ elseif(APPLE)
        src/detection/battery/battery_apple.c
        src/detection/bios/bios_apple.c
        src/detection/bluetooth/bluetooth_apple.m
+        src/detection/bluetoothradio/bluetoothradio_apple.m
        src/detection/board/board_apple.c
+        src/detection/bootmgr/bootmgr_apple.c
        src/detection/brightness/brightness_apple.c
        src/detection/chassis/chassis_nosupport.c
        src/detection/cpu/cpu_apple.c
+        src/detection/cpucache/cpucache_apple.c
        src/detection/cpuusage/cpuusage_apple.c
        src/detection/cursor/cursor_apple.m
        src/detection/disk/disk_bsd.c
+        src/detection/dns/dns_linux.c
        src/detection/physicaldisk/physicaldisk_apple.c
+        src/detection/physicalmemory/physicalmemory_apple.m
        src/detection/diskio/diskio_apple.c
        src/detection/displayserver/displayserver_apple.c
        src/detection/font/font_apple.m
        src/detection/gpu/gpu_apple.c
        src/detection/gpu/gpu_apple.m
        src/detection/host/host_apple.c
-        src/detection/lm/lm_nosupport.c
        src/detection/icons/icons_nosupport.c
+        src/detection/initsystem/initsystem_linux.c
+        src/detection/lm/lm_nosupport.c
+        src/detection/loadavg/loadavg_bsd.c
        src/detection/libc/libc_apple.c
        src/detection/locale/locale_linux.c
        src/detection/localip/localip_linux.c
@@ -613,9 +691,11 @@ elseif(APPLE)
        src/detection/de/de_nosupport.c
        src/detection/wmtheme/wmtheme_apple.m
        src/detection/camera/camera_apple.m
+        src/detection/zpool/zpool_nosupport.c
        src/util/apple/cf_helpers.c
        src/util/apple/osascript.m
        src/util/platform/FFPlatform_unix.c
+        src/util/binary_apple.c
    )
 elseif(WIN32)
    list(APPEND LIBFASTFETCH_SRC
@@ -626,27 +706,34 @@ elseif(WIN32)
        src/detection/battery/battery_windows.c
        src/detection/bios/bios_windows.c
        src/detection/bluetooth/bluetooth_windows.c
+        src/detection/bluetoothradio/bluetoothradio_windows.c
        src/detection/board/board_windows.c
+        src/detection/bootmgr/bootmgr_windows.c
        src/detection/brightness/brightness_windows.cpp
        src/detection/chassis/chassis_windows.c
        src/detection/cpu/cpu_windows.c
+        src/detection/cpucache/cpucache_windows.c
        src/detection/cpuusage/cpuusage_windows.c
        src/detection/cursor/cursor_windows.c
        src/detection/disk/disk_windows.c
        src/detection/physicaldisk/physicaldisk_windows.c
        src/detection/diskio/diskio_windows.c
        src/detection/displayserver/displayserver_windows.c
+        src/detection/dns/dns_windows.c
        src/detection/font/font_windows.c
        src/detection/gpu/gpu_windows.c
        src/detection/host/host_windows.c
        src/detection/icons/icons_windows.c
+        src/detection/initsystem/initsystem_nosupport.c
        src/detection/libc/libc_windows.cpp
        src/detection/lm/lm_nosupport.c
+        src/detection/loadavg/loadavg_nosupport.c
        src/detection/locale/locale_windows.c
        src/detection/localip/localip_windows.c
        src/detection/gamepad/gamepad_windows.c
-        src/detection/media/media_nosupport.c
+        src/detection/media/media_windows.c
        src/detection/memory/memory_windows.c
+        src/detection/physicalmemory/physicalmemory_linux.c
        src/detection/monitor/monitor_windows.c
        src/detection/netio/netio_windows.c
        src/detection/opengl/opengl_windows.c
@@ -669,12 +756,92 @@ elseif(WIN32)
        src/detection/de/de_nosupport.c
        src/detection/wmtheme/wmtheme_windows.c
        src/detection/camera/camera_windows.cpp
+        src/detection/zpool/zpool_nosupport.c
        src/util/windows/getline.c
        src/util/windows/com.cpp
        src/util/windows/registry.c
        src/util/windows/unicode.c
        src/util/windows/wmi.cpp
        src/util/platform/FFPlatform_windows.c
+        src/util/binary_windows.c
+    )
+elseif(SunOS)
+    list(APPEND LIBFASTFETCH_SRC
+        src/common/dbus.c
+        src/common/io/io_unix.c
+        src/common/netif/netif_bsd.c
+        src/common/networking_linux.c
+        src/common/processing_linux.c
+        src/detection/battery/battery_nosupport.c
+        src/detection/bios/bios_windows.c
+        src/detection/board/board_windows.c
+        src/detection/bootmgr/bootmgr_nosupport.c
+        src/detection/brightness/brightness_nosupport.c
+        src/detection/chassis/chassis_windows.c
+        src/detection/cpu/cpu_sunos.c
+        src/detection/cpucache/cpucache_shared.c
+        src/detection/cpuusage/cpuusage_sunos.c
+        src/detection/cursor/cursor_linux.c
+        src/detection/bluetooth/bluetooth_nosupport.c
+        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/physicalmemory/physicalmemory_linux.c
+        src/detection/diskio/diskio_sunos.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/kde-output.c
+        src/detection/displayserver/linux/wayland/wlr-output-management-unstable-v1-protocol.c
+        src/detection/displayserver/linux/wayland/kde-output-device-v2-protocol.c
+        src/detection/displayserver/linux/wayland/kde-output-order-v1-protocol.c
+        src/detection/displayserver/linux/wayland/xdg-output-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_sunos.c
+        src/detection/gpu/gpu_pci.c
+        src/detection/gtk_qt/gtk.c
+        src/detection/host/host_windows.c
+        src/detection/icons/icons_linux.c
+        src/detection/initsystem/initsystem_linux.c
+        src/detection/libc/libc_nosupport.c
+        src/detection/lm/lm_nosupport.c
+        src/detection/loadavg/loadavg_sunos.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_sunos.c
+        src/detection/monitor/monitor_linux.c
+        src/detection/netio/netio_sunos.c
+        src/detection/opengl/opengl_linux.c
+        src/detection/os/os_sunos.c
+        src/detection/packages/packages_sunos.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_sunos.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/uptime/uptime_sunos.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/de/de_linux.c
+        src/detection/wmtheme/wmtheme_linux.c
+        src/detection/camera/camera_nosupport.c
+        src/detection/zpool/zpool_linux.c
+        src/util/platform/FFPlatform_unix.c
+        src/util/binary_linux.c
    )
 endif()

@@ -683,22 +850,23 @@ if(ENABLE_DIRECTX_HEADERS)
    list(APPEND LIBFASTFETCH_SRC src/detection/gpu/gpu_wsl.cpp)
 endif()

-if(ENABLE_PROPRIETARY_GPU_DRIVER_API AND (LINUX OR BSD OR WIN32))
-    message(STATUS "Enabling proprietary GPU driver API")
-    if(LINUX OR BSD OR WIN32)
-        list(APPEND LIBFASTFETCH_SRC src/detection/gpu/gpu_nvidia.c)
-    endif()
-    if(WIN32)
-        list(APPEND LIBFASTFETCH_SRC src/detection/gpu/gpu_intel.c)
-        list(APPEND LIBFASTFETCH_SRC src/detection/gpu/gpu_amd.c)
-    endif()
+# Proprietary GPU driver APIs
+if(LINUX OR FreeBSD OR WIN32)
+    list(APPEND LIBFASTFETCH_SRC src/detection/gpu/gpu_nvidia.c)
+    list(APPEND LIBFASTFETCH_SRC src/detection/gpu/gpu_mthreads.c)
+endif()
+if(WIN32)
+    list(APPEND LIBFASTFETCH_SRC src/detection/gpu/gpu_intel.c)
+    list(APPEND LIBFASTFETCH_SRC src/detection/gpu/gpu_amd.c)
 endif()
-
 include(CheckFunctionExists)
 check_function_exists(wcwidth HAVE_WCWIDTH)
 if(NOT HAVE_WCWIDTH)
    list(APPEND LIBFASTFETCH_SRC src/3rdparty/mk_wcwidch/wcwidth.c)
 endif()
+if(LINUX)
+    check_function_exists(statx HAVE_STATX)
+endif()

 if(ENABLE_SYSTEM_YYJSON)
    find_package(yyjson)
@@ -717,10 +885,6 @@ add_library(libfastfetch OBJECT
    ${LIBFASTFETCH_SRC}
 )

-if(ENABLE_PROPRIETARY_GPU_DRIVER_API AND (LINUX OR BSD OR WIN32))
-    target_compile_definitions(libfastfetch PRIVATE FF_USE_PROPRIETARY_GPU_DRIVER_API)
-endif()
-
 if(yyjson_FOUND)
    target_compile_definitions(libfastfetch PRIVATE FF_USE_SYSTEM_YYJSON)
    target_link_libraries(libfastfetch PRIVATE yyjson::yyjson)
@@ -747,7 +911,7 @@ if(APPLE AND EXISTS "/usr/bin/otool")
        target_compile_definitions(libfastfetch PUBLIC FF_LIBSYSTEM_VERSION="${CMAKE_MATCH_1}")
    endif()
 endif()
-if(BSD AND EXISTS "/usr/local/bin/objdump")
+if(FreeBSD AND EXISTS "/usr/local/bin/objdump")
    execute_process(COMMAND /bin/sh -c "/usr/local/bin/objdump -T /lib/libc.so.* | grep 'FBSD_[^ )]*' -o | sort -Vru | head -1"
                    OUTPUT_VARIABLE OBJDUMP_T_RESULT)
    if("${OBJDUMP_T_RESULT}" MATCHES "FBSD_([0-9]+\\.[0-9]+)")
@@ -755,11 +919,17 @@ if(BSD AND EXISTS "/usr/local/bin/objdump")
    endif()
 endif()

-target_compile_definitions(libfastfetch PUBLIC _GNU_SOURCE _XOPEN_SOURCE __STDC_WANT_LIB_EXT1__=1)
+target_compile_definitions(libfastfetch PUBLIC _GNU_SOURCE _XOPEN_SOURCE __STDC_WANT_LIB_EXT1__=1 _FILE_OFFSET_BITS=64)
 if(WIN32)
    target_compile_definitions(libfastfetch PUBLIC WIN32_LEAN_AND_MEAN=1)
 elseif(APPLE)
    target_compile_definitions(libfastfetch PUBLIC _DARWIN_C_SOURCE)
+elseif(SunOS)
+    target_compile_definitions(libfastfetch PUBLIC __EXTENSIONS__ _POSIX_C_SOURCE=1)
+endif()
+
+if(HAVE_STATX)
+    target_compile_definitions(libfastfetch PRIVATE FF_HAVE_STATX)
 endif()

 if(HAVE_WCWIDTH)
@@ -770,6 +940,19 @@ if(NOT "${CUSTOM_PCI_IDS_PATH}" STREQUAL "")
    message(STATUS "Custom file path of pci.ids: ${CUSTOM_PCI_IDS_PATH}")
    target_compile_definitions(libfastfetch PRIVATE FF_CUSTOM_PCI_IDS_PATH=${CUSTOM_PCI_IDS_PATH})
 endif()
+if(NOT "${CUSTOM_AMDGPU_IDS_PATH}" STREQUAL "")
+    message(STATUS "Custom file path of amdgpu.ids: ${CUSTOM_AMDGPU_IDS_PATH}")
+    target_compile_definitions(libfastfetch PRIVATE FF_CUSTOM_AMDGPU_IDS_PATH=${CUSTOM_AMDGPU_IDS_PATH})
+endif()
+if(NOT "${CUSTOM_OS_RELEASE_PATH}" STREQUAL "")
+    message(STATUS "Custom file path of os_release: ${CUSTOM_OS_RELEASE_PATH}")
+    target_compile_definitions(libfastfetch PRIVATE FF_CUSTOM_OS_RELEASE_PATH=${CUSTOM_OS_RELEASE_PATH})
+endif()
+
+if(NOT BINARY_LINK_TYPE STREQUAL "dlopen")
+    message(STATUS "Enabling custom link type: ${BINARY_LINK_TYPE}")
+    target_compile_definitions(libfastfetch PRIVATE FF_DISABLE_DLOPEN=1)
+endif()

 function(ff_lib_enable VARNAME PKGCONFIG_NAMES CMAKE_NAME)
    if(NOT ENABLE_${VARNAME})
@@ -799,6 +982,11 @@ function(ff_lib_enable VARNAME PKGCONFIG_NAMES CMAKE_NAME)
    target_compile_definitions(libfastfetch PRIVATE FF_HAVE_${VARNAME}=1)
    target_include_directories(libfastfetch PRIVATE ${${VARNAME}_INCLUDE_DIRS})

+    if(NOT BINARY_LINK_TYPE STREQUAL "dlopen")
+        target_link_directories(libfastfetch PUBLIC ${${VARNAME}_LIBRARY_DIRS})
+        target_link_libraries(libfastfetch PRIVATE ${${VARNAME}_LIBRARIES})
+    endif()
+
    foreach(FLAG ${${VARNAME}_CFLAGS_OTHER})
        if(FLAG MATCHES "-D.*")
            string(SUBSTRING ${FLAG} 2 -1 FLAG)
@@ -891,10 +1079,6 @@ ff_lib_enable(OPENCL
    "OpenCL"
    "OpenCL"
 )
-ff_lib_enable(LIBNM
-    "libnm"
-    "libnm"
-)
 ff_lib_enable(FREETYPE
    "freetype2"
    "FreeType2"
@@ -907,10 +1091,33 @@ ff_lib_enable(DDCUTIL
    "ddcutil"
    "Ddcutil"
 )
+ff_lib_enable(ELF
+    "libelf"
+    "libelf"
+)
 ff_lib_enable(DIRECTX_HEADERS
    "DirectX-Headers"
    "DirectX-Headers"
 )
+# The system <libzfs.h> is only usable on SunOS. We provide our local copy of it so it's always available.
+if(ENABLE_LIBZFS)
+    if(BINARY_LINK_TYPE STREQUAL "dlopen")
+        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_LIBZFS=1)
+    else()
+        set(CMAKE_REQUIRED_LIBRARIES_BACKUP ${CMAKE_REQUIRED_LIBRARIES})
+        set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} zfs)
+        check_function_exists("libzfs_init" LIBZFS_FOUND)
+        set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES_BACKUP})
+        if(NOT LIBZFS_FOUND)
+            message(STATUS "Library: missing: LIBZFS")
+        else()
+            message(STATUS "Library: found LIBZFS")
+            target_compile_definitions(libfastfetch PRIVATE FF_HAVE_LIBZFS=1)
+            target_link_libraries(libfastfetch PRIVATE zfs)
+        endif()
+    endif()
+endif()
+

 if(ENABLE_THREADS)
    target_compile_definitions(libfastfetch PRIVATE FF_HAVE_THREADS)
@@ -919,10 +1126,6 @@ if(ENABLE_THREADS)
    endif()
 endif()

-if(ENABLE_PCI_MEMORY)
-    target_compile_definitions(libfastfetch PRIVATE FF_USE_PCI_MEMORY)
-endif()
-
 if(LINUX)
    target_link_libraries(libfastfetch
        PRIVATE "m"
@@ -963,13 +1166,23 @@ elseif(WIN32)
        PRIVATE "setupapi"
        PRIVATE "hid"
        PRIVATE "wtsapi32"
+        PRIVATE "imagehlp"
    )
-elseif(BSD)
+elseif(FreeBSD)
    target_link_libraries(libfastfetch
        PRIVATE "m"
        PRIVATE "usbhid"
        PRIVATE "geom"
    )
+elseif(SunOS)
+    target_link_libraries(libfastfetch
+        PRIVATE "m"
+        PRIVATE "socket"
+        PRIVATE "kstat"
+        PRIVATE "proc"
+        PRIVATE "zfs"
+        PRIVATE "nvpair"
+    )
 elseif(ANDROID)
    CHECK_LIBRARY_EXISTS(-l:libandroid-wordexp.a wordexp "" HAVE_LIBANDROID_WORDEXP_STATIC)
    if(HAVE_LIBANDROID_WORDEXP_STATIC)
@@ -995,6 +1208,63 @@ target_link_libraries(libfastfetch
    PRIVATE ${CMAKE_DL_LIBS}
 )

+target_compile_options(libfastfetch PRIVATE
+    $<$<COMPILE_LANGUAGE:CXX>:-fno-exceptions -fno-rtti>)
+
+if(WIN32)
+    set(CMAKE_CXX_STANDARD 20)
+    include(CheckIncludeFileCXX)
+    CHECK_INCLUDE_FILE_CXX("winrt/Windows.Foundation.h" HAVE_WINRT)
+    if(HAVE_WINRT)
+        add_library(ffwinrt MODULE src/detection/media/media_windows.dll.cpp)
+        target_link_libraries(ffwinrt PRIVATE "RuntimeObject")
+        target_compile_definitions(ffwinrt PRIVATE WIN32_LEAN_AND_MEAN=1 WINRT_LEAN_AND_MEAN=1)
+        target_link_options(ffwinrt
+            PRIVATE "-static" # stdc++, winpthread, gcc_s, etc.
+        )
+    endif()
+    set(CMAKE_CXX_STANDARD 17)
+endif()
+if(FreeBSD)
+  set(CMAKE_REQUIRED_INCLUDES "/usr/local/include" "/usr/include")
+endif()
+if(LINUX OR FreeBSD)
+    CHECK_INCLUDE_FILE("linux/videodev2.h" HAVE_LINUX_VIDEODEV2)
+    if(HAVE_LINUX_VIDEODEV2)
+        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_LINUX_VIDEODEV2=1)
+    endif()
+endif()
+if(LINUX)
+    CHECK_INCLUDE_FILE("linux/wireless.h" HAVE_LINUX_WIRELESS)
+    if(HAVE_LINUX_WIRELESS)
+        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_LINUX_WIRELESS=1)
+    endif()
+endif()
+if(NOT WIN32)
+    CHECK_INCLUDE_FILE("utmpx.h" HAVE_UTMPX)
+    if(HAVE_UTMPX)
+        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_UTMPX=1)
+    endif()
+    CHECK_INCLUDE_FILE("wordexp.h" HAVE_WORDEXP)
+    if(HAVE_WORDEXP)
+        target_compile_definitions(libfastfetch PRIVATE FF_HAVE_WORDEXP=1)
+    endif()
+    if(ENABLE_THREADS AND CMAKE_USE_PTHREADS_INIT)
+        CHECK_INCLUDE_FILE("pthread_np.h" HAVE_PTHREAD_NP)
+        if(HAVE_PTHREAD_NP)
+            target_compile_definitions(libfastfetch PRIVATE FF_HAVE_PTHREAD_NP=1)
+            set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} pthread_np.h)
+        endif()
+        set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} Threads::Threads)
+        check_function_exists("pthread_timedjoin_np" HAVE_TIMEDJOIN_NP)
+        if(HAVE_TIMEDJOIN_NP)
+            target_compile_definitions(libfastfetch PRIVATE FF_HAVE_TIMEDJOIN_NP=1)
+        else()
+            message(WARNING "pthread_timedjoin_np was not found; networking timeout will not work")
+        endif()
+    endif()
+endif()
+
 ######################
 # Executable targets #
 ######################
@@ -1033,12 +1303,9 @@ if(yyjson_FOUND)
 endif()

 if(WIN32)
-    set(TARGET_NAME fastfetch)
    target_sources(fastfetch
        PRIVATE src/util/windows/version.rc
    )
-
-    set(TARGET_NAME flashfetch)
    target_sources(flashfetch
        PRIVATE src/util/windows/version.rc
    )
@@ -1051,6 +1318,11 @@ elseif(APPLE)
    )
 endif()

+if(BINARY_LINK_TYPE STREQUAL "static")
+    target_link_options(fastfetch PRIVATE "-static")
+    target_link_options(flashfetch PRIVATE "-static")
+endif()
+
 ###################
 # Testing targets #
 ###################
@@ -1070,9 +1342,17 @@ if (BUILD_TESTS)
        PRIVATE libfastfetch
    )

+    add_executable(fastfetch-test-format
+        tests/format.c
+    )
+    target_link_libraries(fastfetch-test-format
+        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)
 endif()

 ##################
@@ -1086,14 +1366,27 @@ install(
    DESTINATION "${CMAKE_INSTALL_BINDIR}"
 )

+if (TARGET ffwinrt)
+    install(
+        TARGETS ffwinrt
+        DESTINATION "${CMAKE_INSTALL_BINDIR}"
+    )
+endif()
+
 install(
-    FILES "${CMAKE_SOURCE_DIR}/completions/bash"
+    FILES "${CMAKE_SOURCE_DIR}/completions/${CMAKE_PROJECT_NAME}.bash"
    DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/bash-completion/completions"
    RENAME "${CMAKE_PROJECT_NAME}"
 )

 install(
-    FILES "${CMAKE_SOURCE_DIR}/completions/fish"
+    FILES "${CMAKE_SOURCE_DIR}/completions/${CMAKE_PROJECT_NAME}.zsh"
+    DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/zsh/site-functions"
+    RENAME "_${CMAKE_PROJECT_NAME}"
+)
+
+install(
+    FILES "${CMAKE_SOURCE_DIR}/completions/${CMAKE_PROJECT_NAME}.fish"
    DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/fish/vendor_completions.d"
    RENAME "${CMAKE_PROJECT_NAME}.fish"
 )
@@ -1103,10 +1396,12 @@ install(
    DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/${CMAKE_PROJECT_NAME}"
 )

-install(
-    FILES "${CMAKE_SOURCE_DIR}/LICENSE"
-    DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/licenses/${CMAKE_PROJECT_NAME}"
-)
+if(INSTALL_LICENSE)
+    install(
+        FILES "${CMAKE_SOURCE_DIR}/LICENSE"
+        DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/licenses/${CMAKE_PROJECT_NAME}"
+    )
+endif()

 install(
    FILES "${PROJECT_BINARY_DIR}/fastfetch.1"
@@ -1124,17 +1419,42 @@ else() # We don't use this in Windows
    if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
        set(CMAKE_SYSTEM_PROCESSOR "amd64")
    endif()
-    string(TOLOWER "${CMAKE_PROJECT_NAME}-${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}" CPACK_PACKAGE_FILE_NAME)
+    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()
 endif()

 if(LINUX)
-    set(CPACK_GENERATOR "${CPACK_GENERATOR};DEB;RPM")
+    find_program(HAVE_DPKG "dpkg")
+    if(HAVE_DPKG)
+        set(CPACK_GENERATOR "${CPACK_GENERATOR};DEB")

-    set(CPACK_DEBIAN_PACKAGE_SECTION, "utils")
-    set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
-    set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6")
+        set(CPACK_DEBIAN_PACKAGE_SECTION, "utils")
+        set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")

-    set(CPACK_RPM_PACKAGE_LICENSE "MIT")
+        if(NOT IS_MUSL)
+            EXECUTE_PROCESS(
+                COMMAND getconf GNU_LIBC_VERSION
+                OUTPUT_VARIABLE GLIBC_VERSION
+                OUTPUT_STRIP_TRAILING_WHITESPACE)
+            if(GLIBC_VERSION)
+                STRING(REPLACE "glibc " "" GLIBC_VERSION ${GLIBC_VERSION})
+                set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6 (>= ${GLIBC_VERSION})")
+                message(STATUS "found glibc ${GLIBC_VERSION}")
+            else()
+                message(WARNING "Could not determine glibc version. If `musl` is used, `-DIS_MUSL=ON` should be set")
+            endif()
+        endif()
+    endif()
+
+    find_program(HAVE_RPMBUILD "rpmbuild")
+    if(HAVE_RPMBUILD)
+        set(CPACK_GENERATOR "${CPACK_GENERATOR};RPM")
+
+        set(CPACK_RPM_PACKAGE_LICENSE "MIT")
+    endif()
 endif()

 set(CPACK_SET_DESTDIR ON)
@@ -0,0 +1,133 @@
+
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations
@@ -1,34 +0,0 @@
-# Development help
-
-This file is not an official documentation!
-Here i just add things that are easy to forget.
-
-## Features i am planning to implement
-
-### Specific
-
- [ ] Split the project in different libs / executables, all linking static by default:
-  - `libffdetect`: contains all the detection stuff. To be used by anything that needs system information
-  - `libffprint`: contains the printing functions, logos, format etc
-  - `fastfetch` and `flashfetch`: Executables, that initialize the config of libffprint. Fist one at runtime, second one at compile time
- [ ] Make LocalIP module more configurable
- [ ] Automatic migrate old config files to newer versions
- [ ] ZSH completions
- [ ] Fish completions
- [ ] Make CPU usage detection much faster and more accurate
- [ ] Detect CPU usage in a common detection method and expose it both to the cpuUsage module and the cpu format string
- [ ] Per session caching
-
-### General
- More presets
- More logos
- More package managers
- More DE detections
- More WM theme detections
- More terminal font detections
- Performance optimizations
- More module specific options
- Better error handling, especially the messages shown when using --show-errors
- Using package managers libraries for package count detection instead own. E.g. using libalpm instead of counting files in /var/lib/pacman/local
- Better documentation (especially default config file and the various --help options. Colored output?)
- General feature parity with neofetch, to demonstrate supremity of c
@@ -1,6 +1,7 @@
 MIT License

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

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -11,7 +11,7 @@
 [![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)

-Fastfetch is a [neofetch](https://github.com/dylanaraps/neofetch)-like tool for fetching system information and displaying them in a pretty way. It is written mainly in C, with performance and customizability in mind. Currently, Linux, Android, FreeBSD, MacOS and Windows 7+ are supported.
+Fastfetch is a [neofetch](https://github.com/dylanaraps/neofetch)-like tool for fetching system information and displaying it prettily. It is written mainly in C, with performance and customizability in mind. Currently, Linux, Android, FreeBSD, macOS, SunOS and Windows 7+ are supported.

 <img src="screenshots/example1.png" width="49%" align="left" />
 <img src="https://upload.wikimedia.org/wikipedia/commons/2/24/Transparent_Square_Tiles_Texture.png" width="49%" height="16px" align="left" />
@@ -21,49 +21,58 @@ 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" />

-There are [screenshots on different platforms](https://github.com/fastfetch-cli/fastfetch/wiki)
+There are [screenshots on different platforms](https://github.com/fastfetch-cli/fastfetch/wiki).

 ## Installation

 ### Linux

-* Ubuntu: `ppa:zhangsongcui3371/fastfetch`
-* Debian / Ubuntu: Download `fastfetch-<version>-Linux.deb` from [Github release page](https://github.com/fastfetch-cli/fastfetch/releases/latest) and `dpkg -i fastfetch-<version>-Linux.deb`
-* Arch Linux: `sudo pacman -S fastfetch`. You can also find fastfetch [on the AUR](https://aur.archlinux.org/packages/fastfetch-git).
-* Fedora: `sudo dnf install fastfetch`
-* Gentoo: `sudo emerge --ask app-misc/fastfetch`
+Some distros packaged an outdated fastfetch version. Older version receive no support, so please try always to use the latest version.
+
+* 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`
+* Fedora: `dnf install fastfetch`
+* Gentoo: `emerge --ask app-misc/fastfetch`
 * Alpine: `apk add --upgrade fastfetch`
 * NixOS: `nix-shell -p fastfetch`
-* openSUSE: `sudo zypper install fastfetch`
-* ALT Linux: `sudo apt-get install fastfetch`
+* openSUSE: `zypper install fastfetch`
+* ALT Linux: `apt-get install fastfetch`
+* Exherbo: `cave resolve --execute app-misc/fastfetch`
+* GNU Guix: `guix install fastfetch`
+* Solus: `eopkg install fastfetch`
+* Slackware: `sbopkg -i fastfetch`
+* Void Linux: `xbps-install fastfetch`
+* Venom Linux: `scratch install fastfetch`

-Replace sudo with doas depending on what you use.
+You may need `sudo`, `doas` or `sup` to run these commands.

-[See also if fastfetch has been packaged for your favorite Linux distro](#Packaging)
+[See also if fastfetch has been packaged for your favorite Linux distro](#Packaging).
+
+If fastfetch is not packaged for your distro or an outdated version is packaged, [linuxbrew](https://brew.sh/) is a good alternative: `brew install fastfetch`

 ### macOS

-...via [HomeBrew](https://brew.sh):
-
-`brew install fastfetch`
-
-...via [MacPorts](https://www.macports.org):
-
-`sudo port 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

-`scoop install fastfetch`
+* [scoop](https://scoop.sh/#/apps?q=fastfetch): `scoop install fastfetch`
+* [Chocolatey](https://community.chocolatey.org/packages/fastfetch): `choco install fastfetch`
+* [winget](https://github.com/microsoft/winget-pkgs/tree/master/manifests/f/Fastfetch-cli/Fastfetch): `winget install fastfetch`
+* [MSYS2 MinGW](https://packages.msys2.org/base/mingw-w64-fastfetch): `pacman -S mingw-w64-<subsystem>-<arch>-fastfetch`

-You may also download it directly from [GitHub releases page](https://github.com/fastfetch-cli/fastfetch/releases/latest) and extract the archive.
+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

-`pkg install fastfetch`
+* `pkg install fastfetch`

 ### Android (Termux)

-`pkg install fastfetch`
+* `pkg install fastfetch`

 ## Build from source

@@ -79,7 +88,7 @@ See Wiki: https://github.com/fastfetch-cli/fastfetch/wiki/Building

 ## Customization

-Fastfetch uses the JSONC (or JSON with comments) for configuration. [See Wiki for detail](https://github.com/fastfetch-cli/fastfetch/wiki/Configuration). There are some premade config files in [`presets`](presets), including the ones used for the screenshots above. You can load them using `-c <filename>`. They may also serve as a good example for format arguments.
+Fastfetch uses the JSONC (or JSON with comments) for configuration. [See Wiki for detail](https://github.com/fastfetch-cli/fastfetch/wiki/Configuration). There are some premade config files in [`presets`](presets), including the ones used for the screenshots above. You can load them using `-c <filename>`. Those files can serve as examples of the configuration syntax.

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

@@ -97,11 +106,109 @@ Logos can be heavily customized too; see the [logo documentation](https://github

 ## FAQ

-Q: Why do you need a very performant version of neofetch?
-> I like putting neofetch in my ~/.bashrc to have a system overview whenever I use the terminal, but the slow speed annoyed me, so I created this. Also neofetch didn't output everything correctly (e.g Font is displayed as "[Plasma], Noto Sans, 10 [GTK2/3]") and writing my own tool gave me the possibility to fine tune it to run perfectly on at least my configuration.
+### Q: Neofetch is good enough. Why do I need fastfetch?

-Q: It does not display [*] correctly for me, what can I do?
-> This is most likely because your system is not implemented (yet). At the moment I am focusing more on making the core app better, than adding more configurations. Feel free to open a pull request if you want to add support for your configuration
+1. Fastfetch is actively maintained.
+2. Fastfetch is faster. As the name suggests.
+3. Fastfetch has a greater number of features, though by default fastfetch only has a few modules enabled; use `fastfetch -c all` to find what you want.
+4. Fastfetch is more configurable. You can find more information in the Wiki: <https://github.com/fastfetch-cli/fastfetch/wiki/Configuration>.
+5. Fastfetch is more polished. For example, neofetch prints `555MiB` in `Memory` module and `23G` in `Disk` module, whereas fastfetch prints `555.00 MiB` and `22.97 GiB` respectively.
+6. Fastfetch is more accurate. For example, [neofetch never actually supports the Wayland protocol](https://github.com/dylanaraps/neofetch/pull/2395).
+
+### Q: Fastfetch shows my local IP address. It leaks my privacy!
+
+A local IP (10.x.x.x, 172.x.x.x, 192.168.x.x) has nothing to do with privacy. It only makes sense if you are on the same network, for example, if you connect to the same Wi-Fi network.
+
+Actually the `Local IP` module is the most useful module for me personally. I (@CarterLi) have several VMs installed to test fastfetch and often need to SSH into them. I have fastfetch running on shell startup and I never need to type `ip addr` manually.
+
+If you really don't like it, you can disable the `Local IP` module in `config.jsonc`.
+
+### Q: Where is the config file? I can't find it.
+
+`Fastfetch` does not generate config file automatically. You can use `fastfetch --gen-config` to generate one. The config file will be saved in `~/.config/fastfetch/config.jsonc` by default. See [Wiki for detail](https://github.com/fastfetch-cli/fastfetch/wiki/Configuration).
+
+### Q: The configuration is so complex. Where is the documentation?
+
+Fastfetch uses JSON (with comments) for configuration. I suggest you use an IDE with JSON schema support (like VSCode) to edit it.
+
+Alternatively, you can refer to the presets in [`presets` directory](https://github.com/fastfetch-cli/fastfetch/tree/dev/presets).
+
+The **correct** way to edit the configuration:
+
+This is an example that [changes size prefix from MiB / GiB to MB / GB](https://github.com/fastfetch-cli/fastfetch/discussions/1014). Editor used: [helix](https://github.com/helix-editor/helix)
+
+[![asciicast](https://asciinema.org/a/1uF6sTPGKrHKI1MVaFcikINSQ.svg)](https://asciinema.org/a/1uF6sTPGKrHKI1MVaFcikINSQ)
+
+### Q: I WANT THE DOCUMENTATION!
+
+[Here is the documentation](https://github.com/fastfetch-cli/fastfetch/wiki/Json-Schema). It is generated from [JSON schema](https://github.com/fastfetch-cli/fastfetch/blob/dev/doc/json_schema.json) but you won't like it.
+
+### Q: How can I customize the module output?
+
+Fastfetch uses `format` to generate output. For example, to make the `GPU` module show only the GPU name (leaving other information undisplayed), you can use
+
+```jsonc
+{
+    "modules": [
+        {
+            "type": "gpu",
+            "format": "{2}" // See `fastfetch -h gpu-format` for detail
+        }
+    ]
+}
+```
+
+. . which is equivalent to `fastfetch -s gpu --gpu-format '{2}'`
+
+See `fastfetch -h format` for information on basic usage. For module specific formattion, see `fastfetch -h <module>-format`
+
+### Q: I have my own ascii-art / image file. How can I show it with fastfetch?
+
+Try `fastfetch -l /path/to/logo`. See [logo documentation](https://github.com/fastfetch-cli/fastfetch/wiki/Logo-options) for detail.
+
+If you just want to display distro name in [FIGlet text](https://github.com/pwaller/pyfiglet):
+
+```bash
+# install pyfiglet and jq first
+pyfiglet -s -f small_slant $(fastfetch -s os --format json | jq -r '.[0].result.name') && fastfetch -l none
+```
+
+![image](https://github.com/fastfetch-cli/fastfetch/assets/6134068/6466524e-ab8c-484f-848d-eec7ddeb7df2)
+
+### Q: Fastfetch runs in white and black on shell startup. Why?
+
+This issue usually happens when using fastfetch with `p10k`. There are known incompatibility between fastfetch and p10k instant prompt.
+The p10k doc clearly states that you should NOT print anything to stdout after `p10k-instant-prompt` is initialized. You should either put `fastfetch` before initialization of `p10k-instant-prompt` (recommended)
+
+You can always use `fastfetch --pipe false` to force fastfetch running in colorful mode.
+
+### Q: Why do fastfetch and neofetch show different memory usage result?
+
+See [#1096](https://github.com/fastfetch-cli/fastfetch/issues/1096).
+
+### 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 `Command` module to detect it yourself, which can be used to grab output from a custom shell script:
+
+```jsonc
+// This module shows the default editor
+{
+    "modules": [
+        {
+            "type": "command",
+            "text": "$EDITOR --version | head -1",
+            "key": "Editor"
+        }
+    ]
+}
+```
+
+Otherwise, open a feature request in [GitHub Issues](https://github.com/fastfetch-cli/fastfetch/issues).
+
+### Q: I have questions. Where can I get help?
+
+* For usage questions, please start a discussion in [GitHub Discussions](https://github.com/fastfetch-cli/fastfetch/discussions).
+* For possible bugs, please open an issue in [GitHub Issues](https://github.com/fastfetch-cli/fastfetch/issues). Be sure to fill the bug-report template carefully for developers to investigate.

 ## Star History

@@ -1,5 +1,3 @@
-#!/usr/bin/env bash
-
 __fastfetch_complete_help()
 {
    local __ff_helps=(
@@ -85,12 +83,12 @@ __fastfetch_complete_logo_type()

 __fastfetch_complete_binary_prefix()
 {
-    local __ff_binary_prefixes=(
+    local __ff_size_binary_prefixes=(
        "iec"
        "si"
        "jedec"
    )
-    COMPREPLY=($(compgen -W "${__ff_binary_prefixes[*]}" -- "$CURRENT_WORD"))
+    COMPREPLY=($(compgen -W "${__ff_size_binary_prefixes[*]}" -- "$CURRENT_WORD"))
 }

 __fastfetch_complete_gl()
@@ -191,14 +189,13 @@ __fastfetch_completion()
        "--escape-bedrock"
        "--pipe"
        "--title-fqdn"
-        "--escape-bedrock"
        "--disk-folders"
        "--disk-show-external"
        "--disk-show-hidden"
        "--disk-show-subvolumes"
        "--gpu-hide-integrated"
        "--gpu-hide-discrete"
-        "--gpu-force-vulkan"
+        "--gpu-force-method"
        "--disk-show-unknown"
        "--bluetooth-show-disconnected"
    )
@@ -227,8 +224,6 @@ __fastfetch_completion()
        "--separator"
        "-s"
        "--structure"
-        "--set"
-        "--set-keyless"
        "--player-name"
        "--percent-type"
        "--publicip-url"
@@ -352,6 +347,7 @@ __fastfetch_completion()
        "--users-key"
        "--users-format"
        "--users-key-color"
+        "--users-myself-only"
        "--bluetooth-key"
        "--bluetooth-format"
        "--bluetooth-key-color"
@@ -360,8 +356,6 @@ __fastfetch_completion()
    local FF_OPTIONS_PATH=(
        "-c"
        "--config"
-        "--os-file"
-        "--lib-pci"
        "--lib-vulkan"
        "--lib-wayland"
        "--lib-xcb-randr"
@@ -0,0 +1,101 @@
+if not type -q fastfetch
+    exit
+end
+
+complete -c fastfetch -f
+
+function __fastfetch_complete_bool
+    echo -e "true\tBool"
+    echo -e "false\tBool"
+end
+
+function __fastfetch_complete_color
+    echo -e "black\tColor"
+    echo -e "red\tColor"
+    echo -e "green\tColor"
+    echo -e "yellow\tColor"
+    echo -e "blue\tColor"
+    echo -e "magenta\tColor"
+    echo -e "cyan\tColor"
+    echo -e "white\tColor"
+    echo -e "default\tColor"
+end
+
+function __fastfetch_complete_command
+    for line in (fastfetch --list-modules autocompletion)
+        set -l pair (string split -m 2 : $line)
+        set -l module (string lower $pair[1])
+
+        echo -e "$module-format\tModule format"
+    end
+    echo -e "format\tCustom format"
+    echo -e "color\tColor format"
+end
+
+function __fastfetch_complete_config
+    for line in (fastfetch --list-presets autocompletion)
+        echo -e "$line\tPreset"
+    end
+    echo -e "none\tDisable loading config file"
+end
+
+function __fastfetch_complete_logo
+    for line in (fastfetch --list-logos autocompletion)
+        echo -e "$line\tBuiltin logo"
+    end
+    echo -e "none\tDon't print logo"
+    echo -e "small\tPrint small ascii logo if available"
+end
+
+function __fastfetch_complete_structure
+    for line in (fastfetch --list-modules autocompletion)
+        set -l pair (string split -m 2 : $line)
+        echo -e "$pair[1]\t$pair[2]"
+    end
+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.get("pseudo", False):
+                continue
+
+            command_prefix = f"""complete -c fastfetch -d "{flag["desc"]}" -l "{flag["long"]}\""""
+            if "short" in flag:
+                command_prefix += f""" -o {flag["short"]}"""
+
+            if "arg" in flag:
+                type: str = flag["arg"]["type"];
+                if type == "bool":
+                    print(f"{command_prefix} -x -a \"(__fastfetch_complete_bool)\"")
+                elif type == "color":
+                    print(f"{command_prefix} -x -a \"(__fastfetch_complete_color)\"")
+                elif type == "command":
+                    print(f"{command_prefix} -x -a \"(__fastfetch_complete_command)\"")
+                elif type == "config":
+                    print(f"{command_prefix} -x -a \"(__fastfetch_complete_config)\"")
+                elif type == "enum":
+                    temp: str = " ".join(flag["arg"]["enum"])
+                    print(f"{command_prefix} -x -a \"{temp}\"")
+                elif type == "logo":
+                    print(f"{command_prefix} -x -a \"(__fastfetch_complete_logo)\"")
+                elif type == "structure":
+                    print(f"{command_prefix} -x -a \"(__fish_complete_list : __fastfetch_complete_structure)\"")
+                elif type == "path":
+                    print(f"{command_prefix} -r -F")
+                else:
+                    print(f"{command_prefix} -x")
+            else:
+                print(f"{command_prefix} -f")
+
+if __name__ == "__main__":
+    try:
+        main()
+    except:
+        sys.exit(1)
+' | python3 | source
@@ -0,0 +1,106 @@
+#compdef fastfetch
+
+function _fastfetch() {
+  local state
+
+  local -a opts=("${(f)$(
+        python3 <<EOF
+import json
+import subprocess
+import 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):
+                    command_prefix = f"--logo-color-{i}[{flag["desc"]} ({i})]"
+                    print_command(command_prefix, flag)
+                continue
+
+            if flag.get("pseudo", False):
+                continue
+
+            if "short" in flag:
+                command_prefix = f"-{flag["short"]}[{flag["desc"]}]"
+                print_command(command_prefix, flag)
+
+            if "long" in flag:
+                command_prefix = f"--{flag["long"]}[{flag["desc"]}]"
+                print_command(command_prefix, flag)
+
+
+def print_command(command_prefix: str, flag: dict):
+    if "arg" in flag:
+        type: str = flag["arg"]["type"]
+        if type == "bool":
+            print(f"{command_prefix}::bool:(true false)")
+        elif type == "color":
+            print(f"{command_prefix}:color:->colors")
+        elif type == "command":
+            print(f"{command_prefix}::module:->modules")
+        elif type == "config":
+            print(f"{command_prefix}:preset:->presets")
+        elif type == "enum":
+            temp: str = " ".join(flag["arg"]["enum"])
+            print(f'{command_prefix}:type:({temp})')
+        elif type == "logo":
+            print(f"{command_prefix}:logo:->logos")
+        elif type == "structure":
+            print(f"{command_prefix}:structure:->structures")
+        elif type == "path":
+            print(f"{command_prefix}::path:_files")
+        else:
+            print(f"{command_prefix}:")
+    else:
+        print(f"{command_prefix}")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        sys.exit(1)
+EOF
+  )}")
+
+  _arguments "$opts[@]"
+
+  case $state in
+    colors)
+      local -a colors=(black red green yellow blue magenta cyan white default)
+      _describe 'color' colors
+      ;;
+    modules)
+      local -a modules=("${(f)$(fastfetch --list-modules autocompletion)}")
+      modules=(${(L)^modules[@]%%:*}-format format color)
+      _describe 'module' modules
+      ;;
+    presets)
+      local -a presets=(
+        "${(f)$(fastfetch --list-presets autocompletion)}"
+        "none:Disable loading config file"
+      )
+      _describe 'preset' presets || _files
+      ;;
+    structures)
+      local -a structures=("${(f)$(fastfetch --list-modules autocompletion)}")
+      _describe 'structure' structures
+      ;;
+    logos)
+      local -a logos=(
+        "${(f)$(fastfetch --list-logos autocompletion)}"
+        "none:Don't print logo"
+        "small:Print small ascii logo if available"
+      )
+      _describe 'logo' logos
+      ;;
+  esac
+}
+
+_fastfetch "$@"
@@ -1,106 +0,0 @@
-#!/usr/bin/env fish
-
-if not type -q fastfetch
-    exit
-end
-
-complete -c fastfetch -f
-
-function __fastfetch_complete_bool
-    echo -e "true\tBool"
-    echo -e "false\tBool"
-end
-
-function __fastfetch_complete_color
-    echo -e "black\tColor"
-    echo -e "red\tColor"
-    echo -e "green\tColor"
-    echo -e "yellow\tColor"
-    echo -e "blue\tColor"
-    echo -e "magenta\tColor"
-    echo -e "cyan\tColor"
-    echo -e "white\tColor"
-    echo -e "default\tColor"
-end
-
-function __fastfetch_complete_command
-    for line in (fastfetch --list-modules autocompletion)
-        set -l pair (string split -m 2 : $line)
-        set -l module (string lower $pair[1])
-
-        echo -e "$module-format\tModule format"
-    end
-    echo -e "format\tCustom format"
-    echo -e "color\tColor format"
-end
-
-function __fastfetch_complete_config
-    for line in (fastfetch --list-presets autocompletion)
-        echo -e "$line\tPreset"
-    end
-    echo -e "none\tDisable loading config file"
-end
-
-function __fastfetch_complete_logo
-    for line in (fastfetch --list-logos autocompletion)
-        echo -e "$line\tBuiltin logo"
-    end
-    echo -e "none\tDon't print logo"
-    echo -e "small\tPrint small ascii logo if available"
-end
-
-function __fastfetch_complete_structure
-    for line in (fastfetch --list-modules autocompletion)
-        set -l pair (string split -m 2 : $line)
-        echo -e "$pair[1]\t$pair[2]"
-    end
-end
-
-string match -r -a -g "^###> ?(.*)" < (status -f) | string collect | python3 | source
-
-###> #!/usr/bin/env python3
-###>
-###> 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.get('pseudo', False):
-###>                 continue
-###>
-###>             command_prefix: str = f'complete -c fastfetch -d "{flag["desc"]}" -l "{flag["long"]}"';
-###>             if 'short' in flag:
-###>                 command_prefix += f' -o "{flag["short"]}"'
-###>
-###>             if 'arg' in flag:
-###>                 type: str = flag['arg']['type'];
-###>                 if type == 'bool':
-###>                     print(f'{command_prefix} -x -a "(__fastfetch_complete_bool)"')
-###>                 elif type == 'color':
-###>                     print(f'{command_prefix} -x -a "(__fastfetch_complete_color)"')
-###>                 elif type == 'command':
-###>                     print(f'{command_prefix} -x -a "(__fastfetch_complete_command)"')
-###>                 elif type == 'config':
-###>                     print(f'{command_prefix} -x -a "(__fastfetch_complete_config)"')
-###>                 elif type == 'enum':
-###>                     temp: str = ' '.join(map(lambda x: f"{x[0]}\\t{x[1]}", flag["arg"]["enum"].items()))
-###>                     print(f'{command_prefix} -x -a "{temp}"')
-###>                 elif type == 'logo':
-###>                     print(f'{command_prefix} -x -a "(__fastfetch_complete_logo)"')
-###>                 elif type == 'structure':
-###>                     print(f'{command_prefix} -x -a "(__fish_complete_list : __fastfetch_complete_structure)"')
-###>                 elif type == 'path':
-###>                     print(f'{command_prefix} -r -F')
-###>                 else:
-###>                     print(f'{command_prefix} -x')
-###>             else:
-###>                 print(f'{command_prefix} -f')
-###>
-###> if __name__ == "__main__":
-###>     try:
-###>         main()
-###>     except:
-###>         sys.exit(1)
-###>
@@ -1,3 +1,171 @@
+fastfetch (2.22.0) jammy; urgency=medium
+
+  * Update to 2.22.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Mon, 26 Aug 2024 18:53:35 +0800
+
+fastfetch (2.21.3) jammy; urgency=medium
+
+  * Update to 2.21.3
+
+ -- Carter Li <zhangsongcui@live.cn>  Thu, 15 Aug 2024 16:14:52 +0800
+
+fastfetch (2.21.2) jammy; urgency=medium
+
+  * Update to 2.21.2
+
+ -- Carter Li <zhangsongcui@live.cn>  Wed, 14 Aug 2024 14:42:07 +0800
+
+fastfetch (2.21.1) jammy; urgency=medium
+
+  * Update to 2.21.1
+
+ -- Carter Li <zhangsongcui@live.cn>  Fri, 09 Aug 2024 14:27:10 +0800
+
+fastfetch (2.21.0) jammy; urgency=medium
+
+  * Update to 2.21.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Mon, 05 Aug 2024 14:35:43 +0800
+
+fastfetch (2.20.0) jammy; urgency=medium
+
+  * Update to 2.20.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Fri, 26 Jul 2024 14:02:50 +0800
+
+fastfetch (2.19.1) jammy; urgency=medium
+
+  * Update to 2.19.1
+
+ -- Carter Li <zhangsongcui@live.cn>  Tue, 23 Jul 2024 10:25:14 +0800
+
+fastfetch (2.19.0) jammy; urgency=medium
+
+  * Update to 2.19.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Mon, 22 Jul 2024 14:17:55 +0800
+
+fastfetch (2.18.1) jammy; urgency=medium
+
+  * Update to 2.18.1
+
+ -- Carter Li <zhangsongcui@live.cn>  Thu, 11 Jul 2024 14:32:15 +0800
+
+fastfetch (2.18.0) jammy; urgency=medium
+
+  * Update to 2.18.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Wed, 10 Jul 2024 16:46:32 +0800
+
+fastfetch (2.17.2) jammy; urgency=medium
+
+  * Update to 2.17.2
+
+ -- Carter Li <zhangsongcui@live.cn>  Thu, 04 Jul 2024 10:22:44 +0800
+
+fastfetch (2.17.1) jammy; urgency=medium
+
+  * Update to 2.17.1
+
+ -- Carter Li <zhangsongcui@live.cn>  Mon, 01 Jul 2024 08:56:29 +0800
+
+fastfetch (2.17.0) jammy; urgency=medium
+
+  * Update to 2.17.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Fri, 28 Jun 2024 13:43:18 +0800
+
+fastfetch (2.16.0) jammy; urgency=medium
+
+  * Update to 2.16.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Wed, 19 Jun 2024 14:53:43 +0800
+
+fastfetch (2.15.0) jammy; urgency=medium
+
+  * Update to 2.15.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Fri, 07 Jun 2024 13:52:43 +0800
+
+fastfetch (2.14.0) jammy; urgency=medium
+
+  * Update to 2.14.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Thu, 30 May 2024 14:27:54 +0800
+
+fastfetch (2.13.2) jammy; urgency=medium
+
+  * Update to 2.13.2
+
+ -- Carter Li <zhangsongcui@live.cn>  Fri, 24 May 2024 13:48:59 +0800
+
+fastfetch (2.13.1) jammy; urgency=medium
+
+  * Update to 2.13.1
+
+ -- Carter Li <zhangsongcui@live.cn>  Tue, 21 May 2024 15:10:37 +0800
+
+fastfetch (2.12.0) jammy; urgency=medium
+
+  * Update to 2.12.0
+
+ -- Carter Li <zhangsongcui@live.cn>  Tue, 14 May 2024 16:33:33 +0800
+
+fastfetch (2.11.5) jammy; urgency=medium
+
+  * Update to 2.11.5
+
+ -- Carter Li <zhangsongcui@live.cn>  Tue, 07 May 2024 09:30:05 +0800
+
+fastfetch (2.11.3) jammy; urgency=medium
+
+  * Update to 2.11.3
+
+ -- Carter Li <zhangsongcui@live.cn>  Mon, 06 May 2024 08:46:45 +0800
+
+fastfetch (2.10.2) jammy; urgency=medium
+
+  * Update to 2.10.2
+
+ -- Carter Li <zhangsongcui@live.cn>  Tue, 23 Apr 2024 15:18:23 +0800
+
+fastfetch (2.10.1) jammy; urgency=medium
+
+  * Update to 2.10.1
+
+ -- Carter Li <zhangsongcui@live.cn>  Tue, 23 Apr 2024 09:55:02 +0800
+
+fastfetch (2.9.2) jammy; urgency=medium
+
+  * Update to 2.9.2
+
+ -- Carter Li <zhangsongcui@live.cn>  Tue, 16 Apr 2024 16:32:40 +0800
+
+fastfetch (2.9.1) jammy; urgency=medium
+
+  * Update to 2.9.1
+
+ -- Carter Li <zhangsongcui@live.cn>  Mon, 08 Apr 2024 09:34:30 +0800
+
+fastfetch (2.8.10) jammy; urgency=medium
+
+  * Update to 2.8.10
+
+ -- Carter Li <zhangsongcui@live.cn>  Mon, 25 Mar 2024 15:01:53 +0800
+
+fastfetch (2.8.9) jammy; urgency=medium
+
+  * Update to 2.8.9
+
+ -- Carter Li <zhangsongcui@live.cn>  Fri, 15 Mar 2024 10:49:42 +0800
+
+fastfetch (2.8.8) jammy; urgency=medium
+
+  * Update to 2.8.8
+
+ -- Carter Li <zhangsongcui@live.cn>  Fri, 08 Mar 2024 09:59:41 +0800
+
 fastfetch (2.8.6) jammy; urgency=medium

  * Update to 2.8.6
@@ -2,7 +2,7 @@ Source: fastfetch
 Section: universe/utils
 Priority: optional
 Maintainer: Carter Li <zhangsongcui@live.cn>
-Build-Depends: libvulkan-dev, libwayland-dev, libxrandr-dev, libxcb-randr0-dev, libdconf-dev, libdbus-1-dev, libmagickcore-dev, libxfconf-0-dev, libsqlite3-dev, librpm-dev, libegl-dev, libglx-dev, libosmesa6-dev, ocl-icd-opencl-dev, libnm-dev, libpulse-dev, libdrm-dev, libddcutil-dev, libchafa-dev, directx-headers-dev, pkgconf, cmake (>= 3.12), debhelper (>= 11.2), dh-cmake, dh-cmake-compat (= 1), dh-sequence-cmake, dh-sequence-ctest, ninja-build
+Build-Depends: 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, libosmesa6-dev, ocl-icd-opencl-dev, libpulse-dev, libdrm-dev, libddcutil-dev, libchafa-dev, directx-headers-dev, pkgconf, cmake (>= 3.12), debhelper (>= 11.2), dh-cmake, dh-cmake-compat (= 1), dh-sequence-cmake, dh-sequence-ctest, ninja-build
 Standards-Version: 4.0.0
 Homepage: https://github.com/fastfetch-cli/fastfetch

@@ -1 +1 @@
-fastfetch_2.8.6_source.buildinfo universe/utils optional
+fastfetch_2.22.0_source.buildinfo universe/utils optional
@@ -26,7 +26,7 @@ the exit code will be non\-zero.
 .SS "Informative Options"
 .TP

-.B \-h, \-\-help \fI [command]
+.B \-h, \-\-help \fI[command]
 Show help output, displaying all available options or help for given command
 .TP

@@ -43,7 +43,7 @@ List search paths of presets and logos
 .TP

 .B \-\-list\-logos
-List available logos, they can be loaded with \fI \-\-logo
+List available logos, they can be loaded with \fI\-\-logo
 .TP

 .B \-\-list\-modules
@@ -51,7 +51,7 @@ List available modules
 .TP

 .B \-\-list\-presets
-List available presets, they can be loaded with \fI \-\-config
+List available presets, they can be loaded with \fI\-\-config
 .TP

 .B \-\-list\-features
@@ -64,16 +64,24 @@ Print available logos

 .B \-\-print\-structure
 Print the default structure
+.TP
+
+.B \-\-format \fI<type>
+Set the output format. Besides the
+.I default
+format, only
+.I json
+is supported currently.


 .SS "Display Options"
 .TP

-.B \-l, \-\-logo \fI <logo>
+.B \-l, \-\-logo \fI<logo>
 Set the logo to display
 .TP

-.B \-s, \-\-structure \fI <structure>
+.B \-s, \-\-structure \fI<structure>
 Set the structure of the fetch. For details about the structure,
 see the CONFIGURATION section.

@@ -81,38 +89,40 @@ see the CONFIGURATION section.
 .SS "Config Options"
 .TP

-.B \-c, \-\-config \fI <config>
-Use the specified config file or preset. If "none", disable further config
-loading. For details about config files, see the CONFIGURATION section
+.B \-c, \-\-config \fI<config>
+Use the specified config file or preset. If
+.I none
+is specified, disable further config loading. For details about
+config files, see the CONFIGURATION section
 .TP

-.B \-\-gen\-config \fI [file]
+.B \-\-gen\-config \fI[file]
 Generate a config file with options specified on the command line.
-If \fI file \fR is specified, the configuration will written to the
+If \fIfile\fR is specified, the configuration will be written to the
 file, otherwise it will be written to stdout.
 .TP

-.B \-\-gen\-config\-force \fI [file]
-Same as \fB \-\-gen\-config\fR, but overwrites existing config
+.B \-\-gen\-config\-force \fI[file]
+Same as \fB\-\-gen\-config\fR, but overwrites existing config
 .TP


-To list all options, use \fB \-\-help\fR this will also print all available module options.
+To list all options, use \fB\-\-help\fR. It will also print all available module options.

 .SH CONFIGURATION
 .SS "Fetch Structure"
 The structure of a fetch describes the modules that should be included in
 the output. It consists of a string of modules, separated by a colon (:).
-To list all available modules, use \fB \-\-list\-modules \fR
+To list all available modules, use \fB\-\-list\-modules\fR

 .SS "Config Files"

-fastfetch supports two types of config files. The legacy
-configuration files and a JSONC based format.
+Fastfetch uses JSONC based format for configuration. Fastfetch doesn't generate
+config file automatically; it should be generated manually by \fB\-\-gen\-config\fR.
+The config file will be saved in \fB~/.config/fastfetch/config.jsonc\fR by default.

-A JSONC config file is a JSON file that also supports comments with (//). Those
-files must have the extension '.jsonc'. You can migrate a legacy config
-file to the JSONC format by using \fB\-\-gen\-config\fR.
+A JSONC config file is a JSON file that also supports comments with (// and /* */).
+Those files must have the extension '.jsonc'.

 The specified configuration/preset files are searched in the following order:

@@ -122,13 +132,10 @@ The specified configuration/preset files are searched in the following order:

 3. relative to /usr/share/fastfetch/presets/

-When both a '.jsonc' and a '.conf' file with the same name is found,
-the '.jsonc' file is preferred.
-
-Fastfetch provides some default presets. List them with \fB \-\-print\-available\-presets\fR.
+Fastfetch provides some default presets. List them with \fB\-\-list\-presets\fR.

 .SH "SEE ALSO"
 .BR neofetch (1)

 .SH BUGS
-Please report bugs to:\fI https://github.com/fastfetch\-cli/fastfetch/issues \fR
+Please report bugs to: \fIhttps://github.com/fastfetch\-cli/fastfetch/issues\fR
@@ -1,18 +1,27 @@
 {
    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "padding": {
+            "top": 2
+        }
+    },
    "modules": [
        "title",
        "separator",
        "os",
        "host",
        "bios",
+        "bootmgr",
        "board",
        "chassis",
        "kernel",
+        "initsystem",
        "uptime",
+        "loadavg",
        "processes",
        "packages",
        "shell",
+        "editor",
        "display",
        "brightness",
        "monitor",
@@ -29,18 +38,37 @@
        "terminalfont",
        "terminalsize",
        "terminaltheme",
-        "cpu",
+        {
+            "type": "cpu",
+            "showPeCoreCount": true,
+            "temp": true
+        },
+        "cpucache",
        "cpuusage",
-        "gpu",
+        {
+            "type": "gpu",
+            "driverSpecific": true,
+            "temp": true
+        },
        "memory",
+        "physicalmemory",
        "swap",
        "disk",
+        "zpool",
        "battery",
        "poweradapter",
        "player",
        "media",
-        "publicip",
-        "localip",
+        {
+            "type": "publicip",
+            "timeout": 1000
+        },
+        {
+            "type": "localip",
+            "showIpv6": true,
+            "showMac": true
+        },
+        "dns",
        "wifi",
        "datetime",
        "locale",
@@ -49,13 +77,20 @@
        "opencl",
        "users",
        "bluetooth",
+        "bluetoothradio",
        "sound",
        "camera",
        "gamepad",
-        "weather",
+        {
+          "type": "weather",
+          "timeout": 1000
+        },
        "netio",
        "diskio",
-        "physicaldisk",
+        {
+            "type": "physicaldisk",
+            "temp": true
+        },
        "version",
        "break",
        "colors"
@@ -0,0 +1,82 @@
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "modules": [
+        {
+            "type": "title",
+            "key": "User",
+            "format": "{user-name}"
+        },
+        {
+            "type": "title",
+            "key": "Hostname",
+            "format": "{host-name}"
+        },
+        {
+            "type": "host",
+            "key": "Model"
+        },
+        {
+            "type": "os",
+            "format": "{pretty-name} {version-id} {arch}"
+        },
+        "kernel",
+        "uptime",
+        {
+            "type": "loadavg",
+            "key": "Load Average"
+        },
+        "processes",
+        {
+            "type": "wm",
+            "key": "Window Manager"
+        },
+        {
+            "type": "de",
+            "key": "Desktop Environment"
+        },
+        "shell",
+        {
+            "type": "terminal",
+            "format": "{pretty-name} {version} {#37}█{#97}█ {#36}█{#96}█ {#35}█{#95}█ {#34}█{#94}█ {#33}█{#93}█ {#32}█{#92}█ {#31}█{#91}█ {#30}█{#90}█"
+        },
+        {
+            "type": "packages",
+            "format": "{all}"
+        },
+        {
+            "type": "cpu",
+            "key": "Temperature",
+            "temp": true,
+            "format": "{temperature}"
+        },
+        {
+            "type": "cpu",
+            "key": "CPU",
+            "format": "{cores-logical} x {name}"
+        },
+        {
+            "type": "gpu",
+            "format": "{name}"
+        },
+        {
+            "type": "memory",
+            "key": "RAM"
+        },
+        {
+            "type": "disk",
+            "key": "Disk",
+            "folders": "/"
+        },
+        {
+            "type": "localip",
+            "key": "LAN IP",
+            "showIpv6": true,
+            "showPrefixLen": false
+        },
+        {
+            "type": "publicip",
+            "key": "WAN IP",
+            "timeout": 1000
+        }
+    ]
+}
@@ -1,42 +0,0 @@
-{
-    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
-    "logo": {
-        "type": "builtin",
-        "source": "arch"
-    },
-    "modules": [
-        "title",
-        "separator",
-        {
-            "type": "os",
-            "format": "Arch Linux ({12})"
-        },
-        "host",
-        "kernel",
-        "uptime",
-        {
-            "type": "packages",
-            "format": "{} (pacman)"
-        },
-        "shell",
-        "display",
-        "de",
-        "wm",
-        "wmtheme",
-        "theme",
-        "icons",
-        "font",
-        "cursor",
-        "terminal",
-        "terminalfont",
-        "cpu",
-        "gpu",
-        "memory",
-        "disk",
-        "battery",
-        "poweradapter",
-        "locale",
-        "break",
-        "colors"
-    ]
-}
@@ -6,19 +6,24 @@
    "showErrors": true,
    "noBuffer": true
  },
+  "logo": null,
  "modules": [
    "title",
    "separator",
    "os",
    "host",
    "bios",
+    "bootmgr",
    "board",
    "chassis",
    "kernel",
+    "initsystem",
    "uptime",
+    "loadavg",
    "processes",
    "packages",
    "shell",
+    "editor",
    "display",
    "brightness",
    "monitor",
@@ -35,18 +40,37 @@
    "terminalfont",
    "terminalsize",
    "terminaltheme",
-    "cpu",
+    {
+        "type": "cpu",
+        "showPeCoreCount": true,
+        "temp": true
+    },
+    "cpucache",
    "cpuusage",
-    "gpu",
+    {
+        "type": "gpu",
+        "driverSpecific": true,
+        "temp": true
+    },
    "memory",
+    "physicalmemory",
    "swap",
    "disk",
+    "zpool",
    "battery",
    "poweradapter",
    "player",
    "media",
-    "publicip",
-    "localip",
+    {
+        "type": "publicip",
+        "timeout": 1000
+    },
+    {
+        "type": "localip",
+        "showIpv6": true,
+        "showMac": true
+    },
+    "dns",
    "wifi",
    "datetime",
    "locale",
@@ -55,6 +79,7 @@
    "opencl",
    "users",
    "bluetooth",
+    "bluetoothradio",
    "sound",
    "camera",
    "gamepad",
@@ -64,7 +89,10 @@
    },
    "netio",
    "diskio",
-    "physicaldisk",
+    {
+        "type": "physicaldisk",
+        "temp": true
+    },
    "version",
    "break",
    "colors"
@@ -9,12 +9,16 @@
        }
    },
    "display": {
-        "separator": " -> "
+        "separator": " -> ",
+        "constants": [
+            "──────────────────────────────"
+        ]
    },
    "modules": [
        {
            "type": "custom",
-            "format": "\u001b[90m┌────────────────────────────────────────────────────────────┐"
+            "format": "┌{$1}{$1}┐",
+            "outputColor": "90"
        },
        {
            "type": "title",
@@ -22,19 +26,21 @@
        },
        {
            "type": "custom",
-            "format": "\u001b[90m└────────────────────────────────────────────────────────────┘"
+            "format": "└{$1}{$1}┘",
+            "outputColor": "90"
        },
        {
            "type": "custom",
-            "format": " \u001b[90m  \u001b[31m  \u001b[32m  \u001b[33m  \u001b[34m  \u001b[35m  \u001b[36m  \u001b[37m  \u001b[38m  \u001b[39m       \u001b[38m  \u001b[37m  \u001b[36m  \u001b[35m  \u001b[34m  \u001b[33m  \u001b[32m  \u001b[31m  \u001b[90m"
+            "format": " {#90}  {#31}  {#32}  {#33}  {#34}  {#35}  {#36}  {#37}  {#38}  {#39}       {#38}  {#37}  {#36}  {#35}  {#34}  {#33}  {#32}  {#31}  {#90}"
        },
        {
            "type": "custom",
-            "format": "\u001b[90m┌────────────────────────────────────────────────────────────┐"
+            "format": "┌{$1}{$1}┐",
+            "outputColor": "90"
        },
        {
            "type": "os",
-            "key": " OS",
+            "key": "{icon} OS",
            "keyColor": "yellow"
        },
        {
@@ -84,17 +90,17 @@
        },
        {
            "type": "host",
-            "key": " PC",
+            "key": "󰌢 PC",
            "keyColor": "green"
        },
        {
            "type": "cpu",
-            "key": "│ ├",
+            "key": "│ ├󰻠",
            "keyColor": "green"
        },
        {
            "type": "gpu",
-            "key": "│ ├﬙",
+            "key": "│ ├󰍛",
            "keyColor": "green"
        },
        {
@@ -139,12 +145,13 @@
        },
        {
            "type": "custom",
-            "format": "\u001b[90m└────────────────────────────────────────────────────────────┘"
+            "format": "└{$1}{$1}┘",
+            "outputColor": "90"
        },
        "break",
        {
            "type": "custom",
-            "format": " \u001b[90m  \u001b[31m  \u001b[32m  \u001b[33m  \u001b[34m  \u001b[35m  \u001b[36m  \u001b[37m  \u001b[38m  \u001b[39m       \u001b[38m  \u001b[37m  \u001b[36m  \u001b[35m  \u001b[34m  \u001b[33m  \u001b[32m  \u001b[31m  \u001b[90m"
+            "format": " {#90}  {#31}  {#32}  {#33}  {#34}  {#35}  {#36}  {#37}  {#38}  {#39}       {#38}  {#37}  {#36}  {#35}  {#34}  {#33}  {#32}  {#31}  {#90}"
        }
    ]
 }
@@ -1,10 +1,13 @@
 {
-    "$schema": "file:///C:/msys64/home/zhang/fastfetch/doc/json_schema.json",
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
    "logo": {
        "type": "small"
    },
    "display": {
-        "separator": "\u001b[31m->   "
+        "separator": "->   ",
+        "color": {
+            "separator": "red"
+        }
    },
    "modules": [
        {
@@ -0,0 +1,115 @@
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "type": "none"
+    },
+    "display": {
+        "separator": "->   ",
+        "color": {
+            "separator": "1" // Bold
+        },
+        "constants": [
+            "───────────────────────────"
+        ],
+        "key": {
+            "type": "both",
+            "paddingLeft": 4
+        }
+    },
+    "modules": [
+        {
+            "type": "title",
+            "format": "                             {user-name-colored}{at-symbol-colored}{host-name-colored}"
+        },
+        "break",
+        {
+            "type": "custom",
+            "format": "┌{$1} {#1}System Information{#} {$1}┐"
+        },
+        "break",
+        {
+            "key": "OS           ",
+            "keyColor": "red",
+            "type": "os"
+        },
+        {
+            "key": "Machine      ",
+            "keyColor": "green",
+            "type": "host"
+        },
+        {
+            "key": "Kernel       ",
+            "keyColor": "magenta",
+            "type": "kernel"
+        },
+        {
+            "key": "Uptime       ",
+            "keyColor": "red",
+            "type": "uptime"
+        },
+        {
+            "key": "Resolution   ",
+            "keyColor": "yellow",
+            "type": "display",
+            "compactType": "original-with-refresh-rate"
+        },
+        {
+            "key": "WM           ",
+            "keyColor": "blue",
+            "type": "wm"
+        },
+        {
+            "key": "DE           ",
+            "keyColor": "green",
+            "type": "de"
+        },
+        {
+            "key": "Shell        ",
+            "keyColor": "cyan",
+            "type": "shell"
+        },
+        {
+            "key": "Terminal     ",
+            "keyColor": "red",
+            "type": "terminal"
+        },
+        {
+            "key": "CPU          ",
+            "keyColor": "yellow",
+            "type": "cpu"
+        },
+        {
+            "key": "GPU          ",
+            "keyColor": "blue",
+            "type": "gpu"
+        },
+        {
+            "key": "Memory       ",
+            "keyColor": "magenta",
+            "type": "memory"
+        },
+        {
+            "key": "Local IP     ",
+            "keyColor": "red",
+            "type": "localip",
+            "compact": true
+        },
+        {
+            "key": "Public IP    ",
+            "keyColor": "cyan",
+            "type": "publicip",
+            "timeout": 1000
+        },
+        "break",
+        {
+            "type": "custom",
+            "format": "└{$1}────────────────────{$1}┘"
+        },
+        "break",
+        {
+            "type": "colors",
+            "paddingLeft": 34,
+            "symbol": "circle"
+        }
+    ]
+}
@@ -0,0 +1,85 @@
+// Inspired by Catnap
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "type": "small",
+        "padding": {
+            "top": 1
+        }
+    },
+    "display": {
+        "separator": " "
+    },
+    "modules": [
+        {
+            "key": "╭───────────╮",
+            "type": "custom"
+        },
+        {
+            "key": "│ {#31} user    {#keys}│",
+            "type": "title",
+            "format": "{user-name}"
+        },
+        {
+            "key": "│ {#32}󰇅 hname   {#keys}│",
+            "type": "title",
+            "format": "{host-name}"
+        },
+        {
+            "key": "│ {#33}󰅐 uptime  {#keys}│",
+            "type": "uptime"
+        },
+        {
+            "key": "│ {#34}{icon} distro  {#keys}│",
+            "type": "os"
+        },
+        {
+            "key": "│ {#35} kernel  {#keys}│",
+            "type": "kernel"
+        },
+        {
+            "key": "│ {#36}󰇄 desktop {#keys}│",
+            "type": "de"
+        },
+        {
+            "key": "│ {#31} term    {#keys}│",
+            "type": "terminal"
+        },
+        {
+            "key": "│ {#32} shell   {#keys}│",
+            "type": "shell"
+        },
+        {
+            "key": "│ {#33}󰍛 cpu     {#keys}│",
+            "type": "cpu",
+            "showPeCoreCount": true
+        },
+        {
+            "key": "│ {#34}󰉉 disk    {#keys}│",
+            "type": "disk",
+            "folders": "/"
+        },
+        {
+            "key": "│ {#35} memory  {#keys}│",
+            "type": "memory"
+        },
+        {
+            "key": "│ {#36}󰩟 network {#keys}│",
+            "type": "localip",
+            "format": "{ipv4} ({ifname})"
+        },
+        {
+            "key": "├───────────┤",
+            "type": "custom"
+        },
+        {
+            "key": "│ {#39} colors  {#keys}│",
+            "type": "colors",
+            "symbol": "circle"
+        },
+        {
+            "key": "╰───────────╯",
+            "type": "custom"
+        }
+    ]
+}
@@ -0,0 +1,88 @@
+// Inspired by Catnap
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "type": "small"
+    },
+    "display": {
+        "separator": "",
+        "key": {
+            "width": 15
+        }
+    },
+    "modules": [
+        {
+            // draw borders first to make colors of left and right border consistant
+            "key": " user",
+            "type": "title",
+            "format": "{user-name}",
+            "keyColor": "31"
+        },
+        {
+            "key": "󰇅 hname",
+            "type": "title",
+            "format": "{host-name}",
+            "keyColor": "32"
+
+        },
+        {
+            "key": "󰅐 uptime",
+            "type": "uptime",
+            "keyColor": "33"
+        },
+        {
+            "key": "{icon} distro",
+            "type": "os",
+            "keyColor": "34"
+        },
+        {
+            "key": " kernel",
+            "type": "kernel",
+            "keyColor": "35"
+        },
+        {
+            "key": "󰇄 desktop",
+            "type": "de",
+            "keyColor": "36"
+        },
+        {
+            "key": " term",
+            "type": "terminal",
+            "keyColor": "31"
+        },
+        {
+            "key": " shell",
+            "type": "shell",
+            "keyColor": "32"
+        },
+        {
+            "key": "󰍛 cpu",
+            "type": "cpu",
+            "showPeCoreCount": true,
+            "keyColor": "33"
+        },
+        {
+            "key": "󰉉 disk",
+            "type": "disk",
+            "folders": "/",
+            "keyColor": "34"
+        },
+        {
+            "key": " memory",
+            "type": "memory",
+            "keyColor": "35"
+        },
+        {
+            "key": "󰩟 network",
+            "type": "localip",
+            "format": "{ipv4} ({ifname})",
+            "keyColor": "36"
+        },
+        {
+            "key": " colors",
+            "type": "colors",
+            "symbol": "circle",
+            "keyColor": "39"
+        }
+    ]
+}
@@ -0,0 +1,85 @@
+// Inspired by Catnap
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "type": "small",
+        "padding": {
+            "top": 1
+        }
+    },
+    "display": {
+        "separator": " "
+    },
+    "modules": [
+        {
+            "key": "•••••••••••••",
+            "type": "custom"
+        },
+        {
+            "key": "• {#31} user    {#keys}•",
+            "type": "title",
+            "format": "{user-name}"
+        },
+        {
+            "key": "• {#32}󰇅 hname   {#keys}•",
+            "type": "title",
+            "format": "{host-name}"
+        },
+        {
+            "key": "• {#33}󰅐 uptime  {#keys}•",
+            "type": "uptime"
+        },
+        {
+            "key": "• {#34}{icon} distro  {#keys}•",
+            "type": "os"
+        },
+        {
+            "key": "• {#35} kernel  {#keys}•",
+            "type": "kernel"
+        },
+        {
+            "key": "• {#36}󰇄 desktop {#keys}•",
+            "type": "de"
+        },
+        {
+            "key": "• {#31} term    {#keys}•",
+            "type": "terminal"
+        },
+        {
+            "key": "• {#32} shell   {#keys}•",
+            "type": "shell"
+        },
+        {
+            "key": "• {#33}󰍛 cpu     {#keys}•",
+            "type": "cpu",
+            "showPeCoreCount": true
+        },
+        {
+            "key": "• {#34}󰉉 disk    {#keys}•",
+            "type": "disk",
+            "folders": "/"
+        },
+        {
+            "key": "• {#35} memory  {#keys}•",
+            "type": "memory"
+        },
+        {
+            "key": "• {#36}󰩟 network {#keys}•",
+            "type": "localip",
+            "format": "{ipv4} ({ifname})"
+        },
+        {
+            "key": "•••••••••••••",
+            "type": "custom"
+        },
+        {
+            "key": "• {#39} colors  {#keys}•",
+            "type": "colors",
+            "symbol": "circle"
+        },
+        {
+            "key": "•••••••••••••",
+            "type": "custom"
+        }
+    ]
+}
@@ -0,0 +1,85 @@
+// Inspired by Catnap
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "type": "small",
+        "padding": {
+            "top": 1
+        }
+    },
+    "display": {
+        "separator": " "
+    },
+    "modules": [
+        {
+            "key": "╔═══════════╗",
+            "type": "custom"
+        },
+        {
+            "key": "║ {#31} user    {#keys}║",
+            "type": "title",
+            "format": "{user-name}"
+        },
+        {
+            "key": "║ {#32}󰇅 hname   {#keys}║",
+            "type": "title",
+            "format": "{host-name}"
+        },
+        {
+            "key": "║ {#33}󰅐 uptime  {#keys}║",
+            "type": "uptime"
+        },
+        {
+            "key": "║ {#34}{icon} distro  {#keys}║",
+            "type": "os"
+        },
+        {
+            "key": "║ {#35} kernel  {#keys}║",
+            "type": "kernel"
+        },
+        {
+            "key": "║ {#36}󰇄 desktop {#keys}║",
+            "type": "de"
+        },
+        {
+            "key": "║ {#31} term    {#keys}║",
+            "type": "terminal"
+        },
+        {
+            "key": "║ {#32} shell   {#keys}║",
+            "type": "shell"
+        },
+        {
+            "key": "║ {#33}󰍛 cpu     {#keys}║",
+            "type": "cpu",
+            "showPeCoreCount": true
+        },
+        {
+            "key": "║ {#34}󰉉 disk    {#keys}║",
+            "type": "disk",
+            "folders": "/"
+        },
+        {
+            "key": "║ {#35} memory  {#keys}║",
+            "type": "memory"
+        },
+        {
+            "key": "║ {#36}󰩟 network {#keys}║",
+            "type": "localip",
+            "format": "{ipv4} ({ifname})"
+        },
+        {
+            "key": "╠═══════════╣",
+            "type": "custom"
+        },
+        {
+            "key": "║ {#39} colors  {#keys}║",
+            "type": "colors",
+            "symbol": "circle"
+        },
+        {
+            "key": "╚═══════════╝",
+            "type": "custom"
+        }
+    ]
+}
@@ -0,0 +1,87 @@
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "type": "small",
+        "padding": {
+            "top": 1,
+            "right": 2
+        }
+    },
+    "display": {
+        "separator": ">  ",
+        "color": {
+            "separator": "red"
+        },
+        "constants": [
+            "───────────────────────────────────────────────────────────────────────────",
+            "│\u001b[75C│\u001b[75D"
+        ]
+    },
+    "modules": [
+        {
+            "format": "{#1}{#keys}╭{$1}╮\u001b[76D {user-name-colored}{at-symbol-colored}{host-name-colored} 🖥  ",
+            "type": "title"
+        },
+        {
+            "key": "{$2}{#31} kernel   ",
+            "type": "kernel"
+        },
+        {
+            "key": "{$2}{#32}󰅐 uptime   ",
+            "type": "uptime"
+        },
+        {
+            "key": "{$2}{#33}{icon} distro   ",
+            "type": "os"
+        },
+        {
+            "key": "{$2}{#34}󰇄 desktop  ",
+            "type": "de"
+        },
+        {
+            "key": "{$2}{#35} term     ",
+            "type": "terminal"
+        },
+        {
+            "key": "{$2}{#36} shell    ",
+            "type": "shell"
+        },
+        {
+            "key": "{$2}{#35}󰍛 cpu      ",
+            "type": "cpu",
+            "showPeCoreCount": true,
+            "temp": true
+        },
+        {
+            "key": "{$2}{#34}󰍛 gpu      ",
+            "type": "gpu"
+        },
+        {
+            "key": "{$2}{#33}󰉉 disk     ",
+            "type": "disk",
+            "folders": "/"
+        },
+        {
+            "key": "{$2}{#32} memory   ",
+            "type": "memory"
+        },
+        {
+            "key": "{$2}{#31}󰩟 network  ",
+            "type": "localip",
+            "format": "{ipv4} ({ifname})"
+        },
+        {
+            "format": "{#1}{#keys}├{$1}┤",
+            "type": "custom"
+        },
+        {
+            "key": "{$2}{#39} colors   ",
+            "type": "colors",
+            "symbol": "circle"
+        },
+        {
+            "format": "{#1}{#keys}╰{$1}╯",
+            "type": "custom"
+        }
+    ]
+}
@@ -0,0 +1,87 @@
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "type": "small",
+        "padding": {
+            "top": 1,
+            "right": 2
+        }
+    },
+    "display": {
+        "separator": ">  ",
+        "color": {
+            "separator": "red"
+        },
+        "constants": [
+            "═══════════════════════════════════════════════════════════════════════════",
+            "║\u001b[75C║\u001b[75D"
+        ]
+    },
+    "modules": [
+        {
+            "format": "{#1}{#keys}╔{$1}╗\u001b[76D {user-name-colored}{at-symbol-colored}{host-name-colored} 💻 ",
+            "type": "title"
+        },
+        {
+            "key": "{$2}{#31} kernel   ",
+            "type": "kernel"
+        },
+        {
+            "key": "{$2}{#32}󰅐 uptime   ",
+            "type": "uptime"
+        },
+        {
+            "key": "{$2}{#33}{icon} distro   ",
+            "type": "os"
+        },
+        {
+            "key": "{$2}{#34}󰇄 desktop  ",
+            "type": "de"
+        },
+        {
+            "key": "{$2}{#35} term     ",
+            "type": "terminal"
+        },
+        {
+            "key": "{$2}{#36} shell    ",
+            "type": "shell"
+        },
+        {
+            "key": "{$2}{#35}󰍛 cpu      ",
+            "type": "cpu",
+            "showPeCoreCount": true,
+            "temp": true
+        },
+        {
+            "key": "{$2}{#34}󰍛 gpu      ",
+            "type": "gpu"
+        },
+        {
+            "key": "{$2}{#33}󰉉 disk     ",
+            "type": "disk",
+            "folders": "/"
+        },
+        {
+            "key": "{$2}{#32} memory   ",
+            "type": "memory"
+        },
+        {
+            "key": "{$2}{#31}󰩟 network  ",
+            "type": "localip",
+            "format": "{ipv4} ({ifname})"
+        },
+        {
+            "format": "{#1}{#keys}╠{$1}╣",
+            "type": "custom"
+        },
+        {
+            "key": "{$2}{#39} colors   ",
+            "type": "colors",
+            "symbol": "circle"
+        },
+        {
+            "format": "{#1}{#keys}╚{$1}╝",
+            "type": "custom"
+        }
+    ]
+}
@@ -0,0 +1,188 @@
+//   _____ _____ _____ _____ _____ _____ _____ _____ _____
+//  |   __|  _  |   __|_   _|   __|   __|_   _|     |  |  |
+//  |   __|     |__   | | | |   __|   __| | | |   --|     |
+//  |__|  |__|__|_____| |_| |__|  |_____| |_| |_____|__|__|
+//
+//  By CarterLi - https://github.com/CarterLi
+//  Homepage - https://github.com/fastfetch-cli/fastfetch
+//  config.jsonc - ニリ @niri-san
+//  pokemon-colorscripts - https://gitlab.com/phoneybadger/pokemon-colorscripts
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "source": " _____ _____ _____ _____ _____ _____ _____ _____ _____\n|   __|  _  |   __|_   _|   __|   __|_   _|     |  |  |\n|   __|     |__   | | | |   __|   __| | | |   --|     |\n|__|  |__|__|_____| |_| |__|  |_____| |_| |_____|__|__|",
+        "type": "data",
+        "position": "top",
+        "padding": {
+            "right": 2
+        }
+    },
+    "display": {
+        "separator": " - "
+    },
+    "modules": [
+        {
+            "type": "custom", // HardwareInfo
+            "format": "• {#green}SYSTEM INFORMATION"
+        },
+        {
+            "type": "host",
+            "key": "HOST",
+            "format": "{name}{?vendor} ({vendor}){?}",
+            "keyColor": "green"
+        },
+        {
+            "type": "chassis",
+            "key": "COMPUTER TYPE",
+            "keyColor": "green"
+        },
+        {
+            "type": "cpu",
+            "key": "CPU",
+            "keyColor": "green"
+        },
+        {
+            "type": "gpu",
+            "key": "GPU",
+            "keyColor": "green"
+        },
+        {
+            "type": "memory",
+            "key": "MEMORY USED",
+            "keyColor": "green"
+        },
+        {
+            "type": "swap",
+            "key": "SWAP USED",
+            "keyColor": "green"
+        },
+        {
+            "type": "disk",
+            "key": "DISK",
+            "folders": "/",
+            "keyColor": "green"
+        },
+        {
+            "type": "custom", // SoftwareInfo
+            "format": "• {#red}SOFTWARE INFORMATION"
+        },
+        {
+            "type": "os",
+            "key": "DISTRO",
+            "keyColor": "red"
+        },
+        {
+            "type": "disk",
+            "folders": "/", // Use "/System/Volumes/VM" or something else on macOS
+            "format": "{create-time}",
+            "key": "INSTALLED DATE",
+            "keyColor": "red"
+        },
+        {
+            "type": "kernel",
+            "key": "KERNEL",
+            "keyColor": "red"
+        },
+        {
+            "type": "packages",
+            "key": "PACKAGES",
+            "keyColor": "red"
+        },
+        {
+            "type": "uptime",
+            "key": "UPTIME",
+            "keyColor": "red"
+        },
+        {
+            "type": "custom", // DisplayInfo
+            "format": "• {#blue}DISPLAY INFORMATION"
+        },
+        {
+            "type": "de",
+            "key": "DESKTOP ENVIRONMENT",
+            "keyColor": "blue"
+        },
+        {
+            "type": "lm",
+            "key": "LOGIN MANAGER",
+            "format": "{type}",
+            "keyColor": "blue"
+        },
+        {
+            "type": "wm",
+            "key": "WM",
+            "keyColor": "blue"
+        },
+        {
+            "type": "wmtheme",
+            "key": "WM THEME",
+            "keyColor": "blue"
+        },
+        {
+            "type": "monitor",
+            "key": "MONITOR ({name})",
+            "keyColor": "blue"
+        },
+        {
+            "type": "custom", // DesignInfo
+            "format": "• {#yellow}DESIGN INFORMATION"
+        },
+        {
+            "type": "wallpaper",
+            "key": "WALLPAPER",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "theme",
+            "key": "KDE THEME",
+            "format": "{1}",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "icons",
+            "key": "ICON THEME",
+            "format": "{1}",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "font",
+            "key": "FONT",
+            "format": "{?1}{1} [Qt]{?}{/1}Unknown", // Remove "[Qt]" if not using Qt
+            "keyColor": "yellow"
+        },
+        {
+            "type": "terminalfont",
+            "key": "TERMINAL FONT",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "cursor",
+            "key": "CURSOR",
+            "keyColor": "yellow"
+        },
+        {
+            "type": "custom", // OtherInfo
+            "format": "• {#cyan}VARIOUS INFORMATION"
+        },
+        {
+            "type": "media",
+            "key": "NOW PLAYING",
+            "format": "{?artist}{artist} - {?}{title}",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "weather",
+            "key": "WEATHER",
+            "timeout": 1000,
+            "keyColor": "cyan"
+        },
+        {
+            "type": "version",
+            "key": "INFO",
+            "keyColor": "cyan"
+        },
+        "break",
+        "colors",
+        "break"
+    ]
+}
@@ -5,157 +5,79 @@
    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
    // "logo": {
    //     "type": "iterm",
-    //     "source": "/Users/carter/Desktop/apple1.png",
+    //     "source": "~/Desktop/apple1.png",
    //     "width": 28,
    //     "height": 12
    // },
    "display": {
-        "separator": "  "
+        "separator": "  ",
+        "constants": [
+            "─────────────────" // {$1}, used in Custom module
+        ],
+        "key": {
+            "type": "icon",
+            "paddingLeft": 2
+        }
    },
    "modules": [
        {
            "type": "custom", // HardwareStart
-            "format": "┌─────────── \u001b[1mHardware Information\u001b[0m ───────────┐" // `\u001b` is `\033`, or `\e`
-        },
-        {
-            "type": "host",
-            "key": "  "
-        },
-        {
-            "type": "cpu",
-            "key": "  "
-        },
-        {
-            "type": "gpu",
-            "key": "  ﬙"
-        },
-        {
-            "type": "disk",
-            "key": "  "
-        },
-        {
-            "type": "memory",
-            "key": "  󰑭"
-        },
-        {
-            "type": "swap",
-            "key": "  󰓡"
-        },
-        {
-            "type": "display",
-            "key": "  󰍹"
-        },
-        {
-            "type": "brightness",
-            "key": "  󰃞"
-        },
-        {
-            "type": "battery",
-            "key": "  "
-        },
-        {
-            "type": "poweradapter",
-            "key": "  "
-        },
-        {
-            "type": "bluetooth",
-            "key": "  "
-        },
-        {
-            "type": "sound",
-            "key": "  "
-        },
-        {
-            "type": "gamepad",
-            "key": "  "
+            // {#1} is equivalent to `\u001b[1m`. {#} is equivalent to `\u001b[m`
+            "format": "┌{$1} {#1}Hardware Information{#} {$1}┐"
        },
+        "host",
+        "cpu",
+        "gpu",
+        "disk",
+        "memory",
+        "swap",
+        "display",
+        "brightness",
+        "battery",
+        "poweradapter",
+        "bluetooth",
+        "sound",
+        "gamepad",
        {
            "type": "custom", // SoftwareStart
-            "format": "├─────────── \u001b[1mSoftware Information\u001b[0m ───────────┤"
+            "format": "├{$1} {#1}Software Information{#} {$1}┤"
        },
        {
            "type": "title",
-            "key": "  ",
-            "format": "{1}@{2}"
-        },
-        {
-            "type": "os",
-            "key": "  " // Just get your distro's logo off nerdfonts.com
-        },
-        {
-            "type": "kernel",
-            "key": "  ",
-            "format": "{1} {2}"
-        },
-        {
-            "type": "lm",
-            "key": "  󰧨"
-        },
-        {
-            "type": "de",
-            "key": "  "
-        },
-        {
-            "type": "wm",
-            "key": "  "
-        },
-        {
-            "type": "shell",
-            "key": "  "
-        },
-        {
-            "type": "terminal",
-            "key": "  "
-        },
-        {
-            "type": "terminalfont",
-            "key": "  "
-        },
-        {
-            "type": "theme",
-            "key": "  󰉼"
-        },
-        {
-            "type": "icons",
-            "key": "  󰀻"
-        },
-        {
-            "type": "wallpaper",
-            "key": "  󰸉"
-        },
-        {
-            "type": "packages",
-            "key": "  󰏖"
-        },
-        {
-            "type": "uptime",
-            "key": "  󰅐"
-        },
-        {
-            "type": "media",
-            "key": "  󰝚"
+            "keyIcon": "",
+            "key": "Title", // Title module has no key by default, so that icon is not displayed
+            "format": "{user-name}@{host-name}"
        },
+        "os",
+        "kernel",
+        "lm",
+        "de",
+        "wm",
+        "shell",
+        "terminal",
+        "terminalfont",
+        "theme",
+        "icons",
+        "wallpaper",
+        "packages",
+        "uptime",
+        "media",
        {
            "type": "localip",
-            "key": "  󰩟",
            "compact": true
        },
        {
            "type": "publicip",
-            "key": "  󰩠"
+            "timeout": 1000
        },
        {
            "type": "wifi",
-            "key": "  ",
-            "format": "{4}" // ssid
-        },
-        {
-            "type": "locale",
-            "key": "  "
+            "format": "{ssid}"
        },
+        "locale",
        {
            "type": "custom", // InformationEnd
-            "format": "└────────────────────────────────────────────┘"
+            "format": "└{$1}──────────────────────{$1}┘"
        },
        {
            "type": "colors",
@@ -0,0 +1,164 @@
+// Inspired by https://github.com/usgraphics/TR-100
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": null,
+    "display": {
+        "pipe": true,
+        "key": {
+            "width": 16
+        },
+        "separator": "│ ",
+        "percent": {
+            "type": 6
+        },
+        "bar": {
+            "borderLeft": "",
+            "borderRight": "",
+            "charElapsed": "█",
+            "charTotal": "░",
+            "width": 40
+        },
+        "constants": [
+            "\u001b[42C"
+        ]
+    },
+    "modules": [
+        {
+            "type": "custom",
+            "format": "┌┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┐"
+        },
+        {
+            "type": "custom",
+            "format": "├┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┤"
+        },
+        {
+            "type": "version",
+            "key": " ",
+            "format": "│                   FASTFETCH v{version}                   │"
+        },
+        {
+            "type": "custom",
+            "format": "│                 TR-100 MACHINE REPORT                 │"
+        },
+        {
+            "type": "custom",
+            "format": "├────────────┬──────────────────────────────────────────┤"
+        },
+        {
+            "type": "os",
+            "key": "│ OS         │{$1}"
+        },
+        {
+            "type": "kernel",
+            "key": "│ KERNEL     │{$1}"
+        },
+        {
+            "type": "custom",
+            "format": "├────────────┼──────────────────────────────────────────┤"
+        },
+        {
+            "type": "title",
+            "key": "│ HOSTNAME   │{$1}",
+            "format": "{host-name}"
+        },
+        {
+            "type": "localip",
+            "key": "│ CLIENT IP  │{$1}",
+            "format": "{ipv4}"
+        },
+        {
+            "type": "localip",
+            "key": "│ MAC ADDR   │{$1}",
+            "format": "{mac} ({ifname})",
+            "showIPv4": false,
+            "showMac": true
+        },
+        {
+            "type": "dns",
+            "key": "│ DNS        │{$1}",
+            "showType": "ipv4"
+        },
+        {
+            "type": "title",
+            "key": "│ USER       │{$1}",
+            "format": "{user-name}"
+        },
+        {
+            "type": "host",
+            "key": "│ MACHINE    │{$1}",
+            "format": "{name}"
+        },
+        {
+            "type": "custom",
+            "format": "├────────────┼──────────────────────────────────────────┤"
+        },
+        {
+            "type": "cpu",
+            "key": "│ PROCESSOR  │{$1}",
+            "format": "{name}"
+        },
+        {
+            "type": "cpu",
+            "key": "│ CORES      │{$1}",
+            "format": "{cores-physical} PHYSICAL CORES / {cores-logical} THREADS",
+            "showPeCoreCount": false
+        },
+        {
+            "type": "cpu",
+            "key": "│ CPU FREQ   │{$1}",
+            "format": "{freq-max}{/freq-max}{freq-base}{/}"
+        },
+        {
+            "type": "loadavg",
+            "compact": false,
+            "key": "│ LOAD  {duration>2}m  │{$1}" // pad duration to 2 chars
+        },
+        {
+            "type": "custom",
+            "format": "├────────────┼──────────────────────────────────────────┤"
+        },
+        {
+            "type": "memory",
+            "key": "│ MEMORY     │{$1}",
+            "format": "{used} / {total} [{percentage}]"
+        },
+        {
+            "type": "memory",
+            "key": "│ USAGE      │{$1}",
+            "format": ""
+        },
+        {
+            "type": "custom",
+            "format": "├────────────┼──────────────────────────────────────────┤"
+        },
+        {
+            "type": "disk",
+            "key": "│ VOLUME     │{$1}",
+            "format": "{size-used} / {size-total} [{size-percentage}]",
+            "folders": "/"
+        },
+        {
+            "type": "disk",
+            "key": "│ DISK USAGE │{$1}",
+            "format": ""
+        },
+        {
+            "type": "custom",
+            "format": "├────────────┼──────────────────────────────────────────┤"
+        },
+        {
+            "type": "users",
+            "key": "│ LAST LOGIN │{$1}",
+            "format": "{login-time}{?client-ip} ({client-ip})",
+            "myselfOnly": true
+        },
+        {
+            "type": "uptime",
+            "key": "│ UPTIME     │{$1}"
+        },
+        {
+            "type": "custom",
+            "format": "└────────────┴──────────────────────────────────────────┘"
+        }
+    ]
+  }
@@ -0,0 +1,48 @@
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "type": "small"
+    },
+    "display": {
+        "constants": [
+            "██ "
+        ]
+    },
+    "modules": [
+        {
+            "key": "{$1}Distro",
+            "keyColor": "38;5;210",
+            "type": "os"
+        },
+        {
+            "key": "{$1}Kernel",
+            "keyColor": "38;5;84",
+            "type": "kernel"
+        },
+        {
+            "key": "{$1}Shell",
+            "keyColor": "38;5;147",
+            "type": "shell"
+        },
+        {
+            "key": "{$1}Packages",
+            "keyColor": "38;5;200",
+            "type": "packages"
+        },
+        {
+            "key": "{$1}WM",
+            "keyColor": "38;5;44",
+            "type": "wm"
+        },
+        {
+            "key": "{$1}CPU",
+            "keyColor": "38;5;75",
+            "type": "cpu"
+        },
+        {
+            "key": "{$1}Memory",
+            "keyColor": "38;5;123",
+            "type": "memory"
+        }
+    ]
+}
@@ -0,0 +1,113 @@
+// Designed for Arch Linux
+// Modified from: https://github.com/fastfetch-cli/fastfetch/pull/1025#issuecomment-2177566138
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "source": "arch3",
+        "color": {
+            "1": "red",
+            "2": "yellow"
+        }
+    },
+    "display": {
+        "color": {
+            "separator": "blue"
+        },
+        "separator": " | ",
+        "constants": [
+            ">-----------<+>---------------------------------------------<"
+        ]
+    },
+    "modules": [
+        {
+            "type": "kernel",
+            "key": " /\\rch Linux",
+            "keyColor": "magenta"
+        },
+        {
+            "type": "custom",
+            "format": "{$1}",
+            "outputColor": "separator"
+        },
+        {
+            "type": "uptime",
+            "key": "   Uptime   ",
+            "keyColor": "green"
+        },
+        {
+            "type": "shell",
+            "key": "   Shell    ",
+            "keyColor": "green"
+        },
+        {
+            "type": "terminal",
+            "key": "   Terminal ",
+            "keyColor": "green"
+        },
+        {
+            "type": "terminalfont",
+            "key": "   Font     ",
+            "keyColor": "green"
+        },
+        {
+            "type": "packages",
+            "key": "   Packages ",
+            "keyColor": "green"
+        },
+        {
+            "type": "localip",
+            "key": "   Local IP ",
+            "keyColor": "green"
+        },
+        {
+            "type": "custom",
+            "format": "{$1}",
+            "outputColor": "separator"
+        },
+        {
+            "type": "display",
+            "key": "   Display  ",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "cpu",
+            "key": "   CPU      ",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "gpu",
+            "key": "   GPU      ",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "memory",
+            "key": "   RAM      ",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "swap",
+            "key": "   SWAP     ",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "disk",
+            "key": "   Disk     ",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "battery",
+            "key": "   Battery  ",
+            "keyColor": "cyan"
+        },
+        {
+            "type": "custom",
+            "format": "{$1}",
+            "outputColor": "separator"
+        },
+        "break",
+        {
+            "type": "colors",
+            "paddingLeft": 15
+        }
+    ]
+}
@@ -0,0 +1,63 @@
+// designed for presenting Vanilla Linux
+// inspired from imstilllearnin's Vanilla Logo Ultra
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+        "type": "small"
+    },
+    "display": {
+        "color": {
+            "output": "cyan"
+        },
+        "separator": ""
+    },
+    "modules": [
+        {
+            "type": "kernel",
+            "key": "[_Kernel___> ",
+            "keyColor": "blue"
+        },
+        {
+            "type": "packages",
+            "outputColor": "white",
+            "key": " [_Packages_> ",
+            "keyColor": "green"
+        },
+        {
+            "type": "localip",
+            "outputColor": "white",
+            "key": " [_Local_IP_> ",
+            "keyColor": "green"
+        },
+        {
+            "type": "memory",
+            "format": "[{3}] {1} / {2}",
+            "key": " [_RAM______> ",
+            "keyColor": "magenta"
+        },
+        {
+            "type": "swap",
+            "format": "[{3}] {1} / {2}",
+            "key": " [_SWAP_____> ",
+            "keyColor": "magenta"
+        },
+        {
+            "type": "disk",
+            "format": "[{3}] {1} / {2} {9}",
+            "key": " [_Disk_____> ",
+            "keyColor": "magenta"
+        },
+        {
+            "type": "battery",
+            "format": "[{4}] {5}",
+            "key": " [_Battery__> ",
+            "keyColor": "magenta"
+        },
+        "break",
+        {
+            "type": "colors",
+            "paddingLeft": 9,
+            "symbol": "circle"
+        }
+    ]
+}
@@ -2,9 +2,13 @@

 {
    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
-    "logo": "debian_small",
+    "logo": {
+        "type": "small"
+    },
    "display": {
-        "binaryPrefix": "si"
+        "size": {
+            "binaryPrefix": "si"
+        }
    },
    "modules": [
        "vulkan",
@@ -3,13 +3,15 @@
 {
    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
    "logo": {
-        "source": "arch_small",
+        "type": "small",
        "padding": {
            "right": 1
        }
    },
    "display": {
-        "binaryPrefix": "si",
+        "size": {
+            "binaryPrefix": "si"
+        },
        "color": "blue",
        "separator": "  "
    },
@@ -4,18 +4,16 @@
    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
    "logo": null,
    "display": {
-        "color": "reset_magenta"
+        "color": "magenta"
    },
    "modules": [
        {
            "type": "theme",
-            "key": "T",
-            "format": "{7}"
+            "key": "T"
        },
        {
            "type": "icons",
-            "key": "I",
-            "format": "{5}"
+            "key": "I"
        },
        {
            "type": "font",
@@ -3,29 +3,23 @@

 {
    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
-    // "logo": {
-    //     "type": "iterm",
-    //     "source": "/Users/carter/Desktop/apple1.png",
-    //     "width": 28,
-    //     "height": 12
-    // },
    "display": {
        "separator": " "
    },
    "modules": [
        {
            "type": "host",
-            "key": "╭─",
+            "key": "╭─󰌢",
            "keyColor": "green"
        },
        {
            "type": "cpu",
-            "key": "├─",
+            "key": "├─󰻠",
            "keyColor": "green"
        },
        {
            "type": "gpu",
-            "key": "├─﬙",
+            "key": "├─󰍛",
            "keyColor": "green"
        },
        {
@@ -125,23 +119,22 @@
            "key": "╰─󰸉",
            "keyColor": "yellow"
        },
-
        "break",
+
        {
            "type": "title",
            "key": "╭─",
-            "format": "{1}@{2}",
+            "format": "{user-name}@{host-name}",
            "keyColor": "blue"
        },
        {
            "type": "os",
-            "key": "├─", // Just get your distro's logo off nerdfonts.com
+            "key": "├─{icon}", // Just get your distro's logo off nerdfonts.com
            "keyColor": "blue"
        },
        {
            "type": "kernel",
            "key": "├─",
-            "format": "{1} {2}",
            "keyColor": "blue"
        },
        {
@@ -168,12 +161,13 @@
        {
            "type": "publicip",
            "key": "├─󰩠",
-            "keyColor": "blue"
+            "keyColor": "blue",
+            "timeout": 1000
        },
        {
            "type": "wifi",
            "key": "├─",
-            "format": "{4}", // ssid
+            "format": "{ssid}",
            "keyColor": "blue"
        },
        {
@@ -22,9 +22,8 @@
        },
        {
            "type": "os",
-            "key": "├", // Just get your distro's logo off nerdfonts.com
-            "keyColor": "yellow",
-            "format": "{6}{?6} {?}{10} {8}"
+            "key": "├{icon}", // Just get your distro's logo off nerdfonts.com
+            "keyColor": "yellow"
        },
        {
            "type": "kernel",
@@ -77,17 +76,17 @@
        "break",
        {
            "type": "host",
-            "key": " PC",
+            "key": "󰌢 PC",
            "keyColor": "green"
        },
        {
            "type": "cpu",
-            "key": "├",
+            "key": "├󰻠",
            "keyColor": "green"
        },
        {
            "type": "gpu",
-            "key": "├﬙",
+            "key": "├󰍛",
            "keyColor": "green"
        },
        {
@@ -106,13 +105,13 @@
            "keyColor": "green"
        },
        {
-            "type": "uptime",
-            "key": "├󰅐",
+            "type": "display",
+            "key": "├󰍹",
            "keyColor": "green"
        },
        {
-            "type": "display",
-            "key": "└󰍹",
+            "type": "uptime",
+            "key": "└󰅐",
            "keyColor": "green"
        },

@@ -11,6 +11,9 @@
        "size": {
            "ndigits": 0,
            "maxPrefix": "MB"
+        },
+        "key": {
+            "type": "icon"
        }
    },
    "modules": [
@@ -22,31 +25,17 @@
                "host": "blue"
            }
        },
+        "os",
+        "kernel",
+        "memory",
+        "packages",
+        "uptime",
        {
-            "type": "os",
-            "key": "",
-            "format": "{2} {8}"
-        },
-        {
-            "type": "kernel",
-            "key": ""
-        },
-        {
-            "type": "memory",
-            "key": ""
-        },
-        {
-            "type": "packages",
-            "key": ""
-        },
-        {
-            "type": "uptime",
-            "key": ""
-        },
-        {
-            "type": "custom",
-            "key": "",
-            "format": "\u001b[31m███\u001b[32m███\u001b[33m███\u001b[34m███\u001b[35m███\u001b[36m███"
+            "type": "colors",
+            "key": "Colors", // For printing icon
+            "block": {
+                "range": [1, 6]
+            }
        }
    ]
 }
@@ -4,11 +4,16 @@
        "type": "small"
    },
    "display": {
-        "keyWidth": 11,
+        "key": {
+            "width": 11
+        },
        "bar": {
            "charElapsed": "=",
            "charTotal": "-",
            "width": 13
+        },
+        "percent": {
+            "type": 2
        }
    },
    "modules": [
@@ -16,11 +21,14 @@
        "separator",
        "memory",
        "swap",
-        "disk",
+        {
+            "type": "disk",
+            "folders": "/"
+        },
        "battery",
        {
            "type": "colors",
-            "paddingLeft": 11,
+            "paddingLeft": 10,
            "symbol": "circle"
        }
    ]
@@ -1,25 +0,0 @@
-{
-    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
-    "logo": {
-        "type": "builtin",
-        "source": "arch"
-    },
-    "modules": [
-        "host",
-        "display",
-        "cpu",
-        "gpu",
-        {
-            "type": "memory",
-            "format": "{?2}{2}{?}"
-        },
-        {
-            "type": "disk",
-            "format": "{?2}{2}{?}"
-        },
-        {
-            "type": "battery",
-            "format": "{?1}{1} {?}{?2}{2} {?}{?3}({3}){?}"
-        }
-    ]
-}
@@ -1,17 +1,20 @@
 {
    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "display": {
+        "size": {
+            "maxPrefix": "MB",
+            "ndigits": 0
+        }
+    },
    "modules": [
        "title",
        "separator",
+        "os",
+        "host",
        {
-            "type": "os",
-            "format": "{3} {12}"
+            "type": "kernel",
+            "format": "{release}"
        },
-        {
-            "type": "host",
-            "format": "{/2}{-}{/}{2}{?3} {3}{?}"
-        },
-        "kernel",
        "uptime",
        "packages",
        "shell",
@@ -23,15 +26,12 @@
        "de",
        "wm",
        "wmtheme",
-        {
-            "type": "theme",
-            "format": "{?1}{1}{?3} {3}{?} [Plasma], {?}{7}"
-        },
+        "theme",
        "icons",
        "terminal",
        {
            "type": "terminalfont",
-            "format": "{/2}{-}{/}{2}{?3} {3}{?}"
+            "format": "{/name}{-}{/}{name}{?size} {size}{?}"
        },
        "cpu",
        {
@@ -40,7 +40,7 @@
        },
        {
            "type": "memory",
-            "format": "{/1}{-}{/}{/2}{-}{/}{} / {}"
+            "format": "{} / {}"
        },
        "break",
        "colors"
@@ -12,15 +12,12 @@
        "uptime",
        {
            "type": "battery",
-            "format": "{/4}{-}{/}{4}%{?5} [{5}]{?}"
+            "format": "{/4}{-}{/}{4}{?5} [{5}]{?}"
        },
        "break",
        "packages",
        "shell",
-        {
-            "type": "display",
-            "key": "Display"
-        },
+        "display",
        "terminal",
        "break",
        "cpu",
@@ -0,0 +1,37 @@
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "modules": [
+        "title",
+        "os",
+        "kernel",
+        "uptime",
+        {
+            "type": "packages",
+            "format": "{all}"
+        },
+        "shell",
+        {
+            "type": "display",
+            "key": "Resolution",
+            "compactType": "original"
+        },
+        "de",
+        "wm",
+        "wmtheme",
+        {
+            "type": "terminalfont",
+            "key": "font"
+        },
+        {
+            "type": "disk",
+            "folders": "/",
+            "key": "Disk"
+        },
+        "cpu",
+        "gpu",
+        {
+            "type": "memory",
+            "key": "RAM"
+        }
+    ]
+}
@@ -1,17 +0,0 @@
-{
-    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
-    "modules": [
-        "os",
-        "kernel",
-        "shell",
-        "de",
-        "wm",
-        "wmtheme",
-        "theme",
-        "icons",
-        "font",
-        "cursor",
-        "terminal",
-        "terminalfont"
-    ]
-}
@@ -1,27 +0,0 @@
-Intel Software License Agreement
-10.07.21 
-
-Use and Redistribution. You may use and redistribute Intel’s Control API software and the header files for the Intel® Graphics Control Library (collectively, the “Software”), solely for use on Intel platforms, provided the following conditions are met:
-* Redistributions must reproduce the above copyright notice and the following terms of use in the Software and in the documentation and/or other materials provided with the distribution.
-* Neither the name of Intel nor the names of its suppliers may be used to endorse or promote products derived from this Software without specific prior written permission.
-* No reverse engineering, decompilation, or disassembly of Software provided to you in binary form is permitted.
-
-Third Party Software. The Software may contain Third Party Software. “Third Party Software” is third party software, open source software or other Intel software listed in the “third-party-software.txt” or other similarly named text file that is included with the Software. Third Party Software, even if included with the distribution of the Software, may be governed by separate license terms, including without limitation, third party license terms, open source software notices and terms, and/or other Intel software license terms. These separate license terms solely govern your use of the Third Party Software.
-
-Ownership. Title to the Software and all copies remain with Intel or its suppliers. 
-
-DISCLAIMER. THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT ARE DISCLAIMED. THIS SOFTWARE IS NOT INTENDED FOR USE IN SYSTEMS OR APPLICATIONS WHERE FAILURE OF THE SOFTWARE MAY CAUSE PERSONAL INJURY OR DEATH AND YOU AGREE THAT YOU ARE FULLY RESPONSIBLE FOR ANY CLAIMS, COSTS, DAMAGES, EXPENSES, AND ATTORNEYS’ FEES ARISING OUT OF ANY SUCH USE, EVEN IF ANY CLAIM ALLEGES THAT INTEL WAS NEGLIGENT REGARDING THE DESIGN OR MANUFACTURE OF THE SOFTWARE.
-
-LIMITATION OF LIABILITY; INDEMNITY. IN NO EVENT WILL INTEL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. YOU AGREE TO INDEMNIFY, DEFEND, AND HOLD INTEL HARMLESS AGAINST ANY CLAIMS, DAMAGES, AND EXPENSES RESULTING FROM YOUR USE OR UNAUTHORIZED USE OF THE SOFTWARE.
-
-No support. Intel may make changes to the Software, at any time without notice, and is not obligated to support, update or provide training for the Software.
-
-Termination. Your right to use the Software is terminated immediately in the event of your breach of this agreement.
-
-Feedback. Should you provide Intel with comments, modifications, corrections, enhancements or other input (“Feedback”) related to the Software Intel will be free to use, disclose, reproduce, license or otherwise distribute or exploit the Feedback in its sole discretion without any obligations or restrictions of any kind, including without limitation, intellectual property rights or licensing obligations.
-
-Compliance with laws. You agree to comply with all applicable laws and regulations governing your use, transfer, import or export (or prohibition thereof) of the Software.
-
-Governing law. All disputes will be governed by the laws of the United States of America and the State of Delaware without reference to conflict of law principles and subject to the exclusive jurisdiction of the state or federal courts sitting in the State of Delaware, and each party agrees that it submits to the personal jurisdiction and venue of those courts and waives any objections. The United Nations Convention on Contracts for the International Sale of Goods (1980) is specifically excluded and will not apply to the Software.
-
-Severability. The parties intend that if a court holds that any provision of this agreement is invalid or unenforceable under applicable law, the court will modify the provision to the minimum extent necessary to make it valid and enforceable or sever and delete the provision from this agreement. Any change to or deletion of a provision of this agreement under this Section will not affect the validity or enforceability of the remainder of this agreement, which will continue in full force and effect.
@@ -1,6 +0,0 @@
-{
-    "home": "https://github.com/intel/drivers.gpu.control-library",
-    "license": "./LICENSE",
-    "version": "e1776b7be2ceead1296204371447b27860d25a66",
-    "author": "Intel Corporation"
-}
@@ -1,6 +1,6 @@
 {
    "home": "https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c",
-    "license": "Embed in source",
+    "license": "MIT compatible (embed in source)",
    "version": "2007-05-26 (Unicode 5.0)",
    "author": "Markus Kuhn",
    "modified": "CarterLi"
@@ -1,6 +0,0 @@
-{
-    "home": "https://github.com/NVIDIA/nvidia-settings/blob/main/src/nvml.h",
-    "license": "Embed in source",
-    "version": "545.23.06",
-    "author": "NVIDIA Corporation"
-}
@@ -1,6 +1,6 @@
 {
    "home": "https://github.com/ibireme/yyjson",
    "license": "MIT ( embed in source )",
-    "version": "0.8.0",
+    "version": "0.10.0",
    "author": "ibireme"
 }
@@ -1407,6 +1407,7 @@ bool yyjson_mut_doc_set_val_pool_size(yyjson_mut_doc *doc, size_t count) {
 void yyjson_mut_doc_free(yyjson_mut_doc *doc) {
    if (doc) {
        yyjson_alc alc = doc->alc;
+        memset(&doc->alc, 0, sizeof(alc));
        unsafe_yyjson_str_pool_release(&doc->str_pool, &alc);
        unsafe_yyjson_val_pool_release(&doc->val_pool, &alc);
        alc.free(alc.ctx, doc);
@@ -1830,6 +1831,42 @@ bool unsafe_yyjson_mut_equals(yyjson_mut_val *lhs, yyjson_mut_val *rhs) {
    }
 }

+bool yyjson_locate_pos(const char *str, size_t len, size_t pos,
+                       size_t *line, size_t *col, size_t *chr) {
+    usize line_sum = 0, line_pos = 0, chr_sum = 0;
+    const u8 *cur = (const u8 *)str;
+    const u8 *end = cur + pos;
+    
+    if (!str || pos > len) {
+        if (line) *line = 0;
+        if (col) *col = 0;
+        if (chr) *chr = 0;
+        return false;
+    }
+    
+    while (cur < end) {
+        u8 c = *cur;
+        chr_sum += 1;
+        if (likely(c < 0x80)) {         /* 0xxxxxxx (0x00-0x7F) ASCII */
+            if (c == '\n') {
+                line_sum += 1;
+                line_pos = chr_sum;
+            }
+            cur += 1;
+        }
+        else if (c < 0xC0) cur += 1;    /* 10xxxxxx (0x80-0xBF) Invalid */
+        else if (c < 0xE0) cur += 2;    /* 110xxxxx (0xC0-0xDF) 2-byte UTF-8 */
+        else if (c < 0xF0) cur += 3;    /* 1110xxxx (0xE0-0xEF) 3-byte UTF-8 */
+        else if (c < 0xF8) cur += 4;    /* 11110xxx (0xF0-0xF7) 4-byte UTF-8 */
+        else               cur += 1;    /* 11111xxx (0xF8-0xFF) Invalid */
+    }
+    
+    if (line) *line = line_sum + 1;
+    if (col) *col = chr_sum - line_pos + 1;
+    if (chr) *chr = chr_sum;
+    return true;
+}
+


 #if !YYJSON_DISABLE_UTILS
@@ -4433,7 +4470,7 @@ static_inline bool read_number(u8 **ptr,
    bool sign;
    
    /* read number as raw string if has `YYJSON_READ_NUMBER_AS_RAW` flag */
-    if (unlikely(pre && !has_read_flag(BIGNUM_AS_RAW))) {
+    if (has_read_flag(NUMBER_AS_RAW)) {
        return read_number_raw(ptr, pre, flg, val, msg);
    }
    
@@ -5035,7 +5072,7 @@ static_inline bool read_number(u8 **ptr,
    bool sign;
    
    /* read number as raw string if has `YYJSON_READ_NUMBER_AS_RAW` flag */
-    if (unlikely(pre && !has_read_flag(BIGNUM_AS_RAW))) {
+    if (has_read_flag(NUMBER_AS_RAW)) {
        return read_number_raw(ptr, pre, flg, val, msg);
    }
    
@@ -5743,18 +5780,18 @@ static_noinline yyjson_doc *read_root_single(u8 *hdr,
    }
    if (*cur == 't') {
        if (likely(read_true(&cur, val))) goto doc_end;
-        goto fail_literal;
+        goto fail_literal_true;
    }
    if (*cur == 'f') {
        if (likely(read_false(&cur, val))) goto doc_end;
-        goto fail_literal;
+        goto fail_literal_false;
    }
    if (*cur == 'n') {
        if (likely(read_null(&cur, val))) goto doc_end;
        if (has_read_flag(ALLOW_INF_AND_NAN)) {
            if (read_nan(false, &cur, pre, val)) goto doc_end;
        }
-        goto fail_literal;
+        goto fail_literal_null;
    }
    if (has_read_flag(ALLOW_INF_AND_NAN)) {
        if (read_inf_or_nan(false, &cur, pre, val)) goto doc_end;
@@ -5788,15 +5825,26 @@ fail_string:
 fail_number:
    return_err(cur, INVALID_NUMBER, msg);
 fail_alloc:
-    return_err(cur, MEMORY_ALLOCATION, "memory allocation failed");
-fail_literal:
-    return_err(cur, LITERAL, "invalid literal");
-fail_comment:
-    return_err(cur, INVALID_COMMENT, "unclosed multiline comment");
+    return_err(cur, MEMORY_ALLOCATION, 
+               "memory allocation failed");
+fail_literal_true:
+    return_err(cur, LITERAL, 
+               "invalid literal, expected a valid literal such as 'true'");
+fail_literal_false:
+    return_err(cur, LITERAL, 
+               "invalid literal, expected a valid literal such as 'false'");
+fail_literal_null:
+    return_err(cur, LITERAL, 
+               "invalid literal, expected a valid literal such as 'null'");
 fail_character:
-    return_err(cur, UNEXPECTED_CHARACTER, "unexpected character");
+    return_err(cur, UNEXPECTED_CHARACTER, 
+               "unexpected character, expected a valid root value");
+fail_comment:
+    return_err(cur, INVALID_COMMENT,
+               "unclosed multiline comment");
 fail_garbage:
-    return_err(cur, UNEXPECTED_CONTENT, "unexpected content after document");
+    return_err(cur, UNEXPECTED_CONTENT, 
+               "unexpected content after document");
    
 #undef return_err
 }
@@ -5926,13 +5974,13 @@ arr_val_begin:
        val_incr();
        ctn_len++;
        if (likely(read_true(&cur, val))) goto arr_val_end;
-        goto fail_literal;
+        goto fail_literal_true;
    }
    if (*cur == 'f') {
        val_incr();
        ctn_len++;
        if (likely(read_false(&cur, val))) goto arr_val_end;
-        goto fail_literal;
+        goto fail_literal_false;
    }
    if (*cur == 'n') {
        val_incr();
@@ -5941,7 +5989,7 @@ arr_val_begin:
        if (has_read_flag(ALLOW_INF_AND_NAN)) {
            if (read_nan(false, &cur, pre, val)) goto arr_val_end;
        }
-        goto fail_literal;
+        goto fail_literal_null;
    }
    if (*cur == ']') {
        cur++;
@@ -5959,13 +6007,13 @@ arr_val_begin:
        val_incr();
        ctn_len++;
        if (read_inf_or_nan(false, &cur, pre, val)) goto arr_val_end;
-        goto fail_character;
+        goto fail_character_val;
    }
    if (has_read_flag(ALLOW_COMMENTS)) {
        if (skip_spaces_and_comments(&cur)) goto arr_val_begin;
        if (byte_match_2(cur, "/*")) goto fail_comment;
    }
-    goto fail_character;
+    goto fail_character_val;
    
 arr_val_end:
    if (*cur == ',') {
@@ -5984,7 +6032,7 @@ arr_val_end:
        if (skip_spaces_and_comments(&cur)) goto arr_val_end;
        if (byte_match_2(cur, "/*")) goto fail_comment;
    }
-    goto fail_character;
+    goto fail_character_arr_end;
    
 arr_end:
    /* get parent container */
@@ -6037,7 +6085,7 @@ obj_key_begin:
        if (skip_spaces_and_comments(&cur)) goto obj_key_begin;
        if (byte_match_2(cur, "/*")) goto fail_comment;
    }
-    goto fail_character;
+    goto fail_character_obj_key;
    
 obj_key_end:
    if (*cur == ':') {
@@ -6052,7 +6100,7 @@ obj_key_end:
        if (skip_spaces_and_comments(&cur)) goto obj_key_end;
        if (byte_match_2(cur, "/*")) goto fail_comment;
    }
-    goto fail_character;
+    goto fail_character_obj_sep;
    
 obj_val_begin:
    if (*cur == '"') {
@@ -6079,13 +6127,13 @@ obj_val_begin:
        val++;
        ctn_len++;
        if (likely(read_true(&cur, val))) goto obj_val_end;
-        goto fail_literal;
+        goto fail_literal_true;
    }
    if (*cur == 'f') {
        val++;
        ctn_len++;
        if (likely(read_false(&cur, val))) goto obj_val_end;
-        goto fail_literal;
+        goto fail_literal_false;
    }
    if (*cur == 'n') {
        val++;
@@ -6094,7 +6142,7 @@ obj_val_begin:
        if (has_read_flag(ALLOW_INF_AND_NAN)) {
            if (read_nan(false, &cur, pre, val)) goto obj_val_end;
        }
-        goto fail_literal;
+        goto fail_literal_null;
    }
    if (char_is_space(*cur)) {
        while (char_is_space(*++cur));
@@ -6105,13 +6153,13 @@ obj_val_begin:
        val++;
        ctn_len++;
        if (read_inf_or_nan(false, &cur, pre, val)) goto obj_val_end;
-        goto fail_character;
+        goto fail_character_val;
    }
    if (has_read_flag(ALLOW_COMMENTS)) {
        if (skip_spaces_and_comments(&cur)) goto obj_val_begin;
        if (byte_match_2(cur, "/*")) goto fail_comment;
    }
-    goto fail_character;
+    goto fail_character_val;
    
 obj_val_end:
    if (likely(*cur == ',')) {
@@ -6130,7 +6178,7 @@ obj_val_end:
        if (skip_spaces_and_comments(&cur)) goto obj_val_end;
        if (byte_match_2(cur, "/*")) goto fail_comment;
    }
-    goto fail_character;
+    goto fail_character_obj_end;
    
 obj_end:
    /* pop container */
@@ -6173,17 +6221,41 @@ fail_string:
 fail_number:
    return_err(cur, INVALID_NUMBER, msg);
 fail_alloc:
-    return_err(cur, MEMORY_ALLOCATION, "memory allocation failed");
+    return_err(cur, MEMORY_ALLOCATION, 
+               "memory allocation failed");
 fail_trailing_comma:
-    return_err(cur, JSON_STRUCTURE, "trailing comma is not allowed");
-fail_literal:
-    return_err(cur, LITERAL, "invalid literal");
+    return_err(cur, JSON_STRUCTURE, 
+               "trailing comma is not allowed");
+fail_literal_true:
+    return_err(cur, LITERAL,
+               "invalid literal, expected a valid literal such as 'true'");
+fail_literal_false:
+    return_err(cur, LITERAL,
+               "invalid literal, expected a valid literal such as 'false'");
+fail_literal_null:
+    return_err(cur, LITERAL,
+               "invalid literal, expected a valid literal such as 'null'");
+fail_character_val:
+    return_err(cur, UNEXPECTED_CHARACTER,
+               "unexpected character, expected a valid JSON value");
+fail_character_arr_end:
+    return_err(cur, UNEXPECTED_CHARACTER,
+               "unexpected character, expected a comma or a closing bracket");
+fail_character_obj_key:
+    return_err(cur, UNEXPECTED_CHARACTER,
+               "unexpected character, expected a string for object key");
+fail_character_obj_sep:
+    return_err(cur, UNEXPECTED_CHARACTER,
+               "unexpected character, expected a colon after object key");
+fail_character_obj_end:
+    return_err(cur, UNEXPECTED_CHARACTER,
+               "unexpected character, expected a comma or a closing brace");
 fail_comment:
-    return_err(cur, INVALID_COMMENT, "unclosed multiline comment");
-fail_character:
-    return_err(cur, UNEXPECTED_CHARACTER, "unexpected character");
+    return_err(cur, INVALID_COMMENT,
+               "unclosed multiline comment");
 fail_garbage:
-    return_err(cur, UNEXPECTED_CONTENT, "unexpected content after document");
+    return_err(cur, UNEXPECTED_CONTENT, 
+               "unexpected content after document");
    
 #undef val_incr
 #undef return_err
@@ -6329,13 +6401,13 @@ arr_val_begin:
        val_incr();
        ctn_len++;
        if (likely(read_true(&cur, val))) goto arr_val_end;
-        goto fail_literal;
+        goto fail_literal_true;
    }
    if (*cur == 'f') {
        val_incr();
        ctn_len++;
        if (likely(read_false(&cur, val))) goto arr_val_end;
-        goto fail_literal;
+        goto fail_literal_false;
    }
    if (*cur == 'n') {
        val_incr();
@@ -6344,7 +6416,7 @@ arr_val_begin:
        if (has_read_flag(ALLOW_INF_AND_NAN)) {
            if (read_nan(false, &cur, pre, val)) goto arr_val_end;
        }
-        goto fail_literal;
+        goto fail_literal_null;
    }
    if (*cur == ']') {
        cur++;
@@ -6362,13 +6434,13 @@ arr_val_begin:
        val_incr();
        ctn_len++;
        if (read_inf_or_nan(false, &cur, pre, val)) goto arr_val_end;
-        goto fail_character;
+        goto fail_character_val;
    }
    if (has_read_flag(ALLOW_COMMENTS)) {
        if (skip_spaces_and_comments(&cur)) goto arr_val_begin;
        if (byte_match_2(cur, "/*")) goto fail_comment;
    }
-    goto fail_character;
+    goto fail_character_val;
    
 arr_val_end:
    if (byte_match_2(cur, ",\n")) {
@@ -6391,7 +6463,7 @@ arr_val_end:
        if (skip_spaces_and_comments(&cur)) goto arr_val_end;
        if (byte_match_2(cur, "/*")) goto fail_comment;
    }
-    goto fail_character;
+    goto fail_character_arr_end;
    
 arr_end:
    /* get parent container */
@@ -6457,7 +6529,7 @@ obj_key_begin:
        if (skip_spaces_and_comments(&cur)) goto obj_key_begin;
        if (byte_match_2(cur, "/*")) goto fail_comment;
    }
-    goto fail_character;
+    goto fail_character_obj_key;
    
 obj_key_end:
    if (byte_match_2(cur, ": ")) {
@@ -6476,7 +6548,7 @@ obj_key_end:
        if (skip_spaces_and_comments(&cur)) goto obj_key_end;
        if (byte_match_2(cur, "/*")) goto fail_comment;
    }
-    goto fail_character;
+    goto fail_character_obj_sep;
    
 obj_val_begin:
    if (*cur == '"') {
@@ -6503,13 +6575,13 @@ obj_val_begin:
        val++;
        ctn_len++;
        if (likely(read_true(&cur, val))) goto obj_val_end;
-        goto fail_literal;
+        goto fail_literal_true;
    }
    if (*cur == 'f') {
        val++;
        ctn_len++;
        if (likely(read_false(&cur, val))) goto obj_val_end;
-        goto fail_literal;
+        goto fail_literal_false;
    }
    if (*cur == 'n') {
        val++;
@@ -6518,7 +6590,7 @@ obj_val_begin:
        if (has_read_flag(ALLOW_INF_AND_NAN)) {
            if (read_nan(false, &cur, pre, val)) goto obj_val_end;
        }
-        goto fail_literal;
+        goto fail_literal_null;
    }
    if (char_is_space(*cur)) {
        while (char_is_space(*++cur));
@@ -6529,13 +6601,13 @@ obj_val_begin:
        val++;
        ctn_len++;
        if (read_inf_or_nan(false, &cur, pre, val)) goto obj_val_end;
-        goto fail_character;
+        goto fail_character_val;
    }
    if (has_read_flag(ALLOW_COMMENTS)) {
        if (skip_spaces_and_comments(&cur)) goto obj_val_begin;
        if (byte_match_2(cur, "/*")) goto fail_comment;
    }
-    goto fail_character;
+    goto fail_character_val;
    
 obj_val_end:
    if (byte_match_2(cur, ",\n")) {
@@ -6558,7 +6630,7 @@ obj_val_end:
        if (skip_spaces_and_comments(&cur)) goto obj_val_end;
        if (byte_match_2(cur, "/*")) goto fail_comment;
    }
-    goto fail_character;
+    goto fail_character_obj_end;
    
 obj_end:
    /* pop container */
@@ -6602,17 +6674,41 @@ fail_string:
 fail_number:
    return_err(cur, INVALID_NUMBER, msg);
 fail_alloc:
-    return_err(cur, MEMORY_ALLOCATION, "memory allocation failed");
+    return_err(cur, MEMORY_ALLOCATION,
+               "memory allocation failed");
 fail_trailing_comma:
-    return_err(cur, JSON_STRUCTURE, "trailing comma is not allowed");
-fail_literal:
-    return_err(cur, LITERAL, "invalid literal");
+    return_err(cur, JSON_STRUCTURE,
+               "trailing comma is not allowed");
+fail_literal_true:
+    return_err(cur, LITERAL,
+               "invalid literal, expected a valid literal such as 'true'");
+fail_literal_false:
+    return_err(cur, LITERAL,
+               "invalid literal, expected a valid literal such as 'false'");
+fail_literal_null:
+    return_err(cur, LITERAL,
+               "invalid literal, expected a valid literal such as 'null'");
+fail_character_val:
+    return_err(cur, UNEXPECTED_CHARACTER,
+               "unexpected character, expected a valid JSON value");
+fail_character_arr_end:
+    return_err(cur, UNEXPECTED_CHARACTER,
+               "unexpected character, expected a comma or a closing bracket");
+fail_character_obj_key:
+    return_err(cur, UNEXPECTED_CHARACTER,
+               "unexpected character, expected a string for object key");
+fail_character_obj_sep:
+    return_err(cur, UNEXPECTED_CHARACTER,
+               "unexpected character, expected a colon after object key");
+fail_character_obj_end:
+    return_err(cur, UNEXPECTED_CHARACTER,
+               "unexpected character, expected a comma or a closing brace");
 fail_comment:
-    return_err(cur, INVALID_COMMENT, "unclosed multiline comment");
-fail_character:
-    return_err(cur, UNEXPECTED_CHARACTER, "unexpected character");
+    return_err(cur, INVALID_COMMENT,
+               "unclosed multiline comment");
 fail_garbage:
-    return_err(cur, UNEXPECTED_CONTENT, "unexpected content after document");
+    return_err(cur, UNEXPECTED_CONTENT,
+               "unexpected content after document");
    
 #undef val_incr
 #undef return_err
@@ -7834,7 +7930,7 @@ static const u8 esc_single_char_table[512] = {

 /** Returns the encode table with options. */
 static_inline const char_enc_type *get_enc_table_with_flag(
-    yyjson_read_flag flg) {
+    yyjson_write_flag flg) {
    if (has_write_flag(ESCAPE_UNICODE)) {
        if (has_write_flag(ESCAPE_SLASHES)) {
            return enc_table_esc_slash;
@@ -8309,13 +8405,15 @@ static_inline u8 *yyjson_write_single(yyjson_val *val,
    bool cpy = (enc_table == enc_table_cpy);
    bool esc = has_write_flag(ESCAPE_UNICODE) != 0;
    bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0;
+    bool newline = has_write_flag(NEWLINE_AT_END) != 0;
+    const usize end_len = 2; /* '\n' and '\0' */
    
    switch (unsafe_yyjson_get_type(val)) {
        case YYJSON_TYPE_RAW:
            str_len = unsafe_yyjson_get_len(val);
            str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
            check_str_len(str_len);
-            incr_len(str_len + 1);
+            incr_len(str_len + end_len);
            cur = write_raw(cur, str_ptr, str_len);
            break;
            
@@ -8323,7 +8421,7 @@ static_inline u8 *yyjson_write_single(yyjson_val *val,
            str_len = unsafe_yyjson_get_len(val);
            str_ptr = (const u8 *)unsafe_yyjson_get_str(val);
            check_str_len(str_len);
-            incr_len(str_len * 6 + 4);
+            incr_len(str_len * 6 + 2 + end_len);
            if (likely(cpy) && unsafe_yyjson_get_subtype(val)) {
                cur = write_string_noesc(cur, str_ptr, str_len);
            } else {
@@ -8333,7 +8431,7 @@ static_inline u8 *yyjson_write_single(yyjson_val *val,
            break;
            
        case YYJSON_TYPE_NUM:
-            incr_len(32);
+            incr_len(32 + end_len);
            cur = write_number(cur, val, flg);
            if (unlikely(!cur)) goto fail_num;
            break;
@@ -8349,13 +8447,13 @@ static_inline u8 *yyjson_write_single(yyjson_val *val,
            break;
            
        case YYJSON_TYPE_ARR:
-            incr_len(4);
+            incr_len(2 + end_len);
            byte_copy_2(cur, "[]");
            cur += 2;
            break;
            
        case YYJSON_TYPE_OBJ:
-            incr_len(4);
+            incr_len(2 + end_len);
            byte_copy_2(cur, "{}");
            cur += 2;
            break;
@@ -8364,6 +8462,7 @@ static_inline u8 *yyjson_write_single(yyjson_val *val,
            goto fail_type;
    }
    
+    if (newline) *cur++ = '\n';
    *cur = '\0';
    *dat_len = (usize)(cur - hdr);
    memset(err, 0, sizeof(yyjson_write_err));
@@ -8436,6 +8535,7 @@ static_inline u8 *yyjson_write_minify(const yyjson_val *root,
    bool cpy = (enc_table == enc_table_cpy);
    bool esc = has_write_flag(ESCAPE_UNICODE) != 0;
    bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0;
+    bool newline = has_write_flag(NEWLINE_AT_END) != 0;
    
    alc_len = root->uni.ofs / sizeof(yyjson_val);
    alc_len = alc_len * YYJSON_WRITER_ESTIMATED_MINIFY_RATIO + 64;
@@ -8542,6 +8642,11 @@ ctn_end:
    }
    
 doc_end:
+    if (newline) {
+        incr_len(2);
+        *(cur - 1) = '\n';
+        cur++;
+    }
    *--cur = '\0';
    *dat_len = (usize)(cur - hdr);
    memset(err, 0, sizeof(yyjson_write_err));
@@ -8615,6 +8720,7 @@ static_inline u8 *yyjson_write_pretty(const yyjson_val *root,
    bool esc = has_write_flag(ESCAPE_UNICODE) != 0;
    bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0;
    usize spaces = has_write_flag(PRETTY_TWO_SPACES) ? 2 : 4;
+    bool newline = has_write_flag(NEWLINE_AT_END) != 0;
    
    alc_len = root->uni.ofs / sizeof(yyjson_val);
    alc_len = alc_len * YYJSON_WRITER_ESTIMATED_PRETTY_RATIO + 64;
@@ -8745,6 +8851,10 @@ ctn_end:
    }
    
 doc_end:
+    if (newline) {
+        incr_len(2);
+        *cur++ = '\n';
+    }
    *cur = '\0';
    *dat_len = (usize)(cur - hdr);
    memset(err, 0, sizeof(yyjson_write_err));
@@ -8977,6 +9087,7 @@ static_inline u8 *yyjson_mut_write_minify(const yyjson_mut_val *root,
    bool cpy = (enc_table == enc_table_cpy);
    bool esc = has_write_flag(ESCAPE_UNICODE) != 0;
    bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0;
+    bool newline = has_write_flag(NEWLINE_AT_END) != 0;
    
    alc_len = estimated_val_num * YYJSON_WRITER_ESTIMATED_MINIFY_RATIO + 64;
    alc_len = size_align_up(alc_len, sizeof(yyjson_mut_write_ctx));
@@ -9087,6 +9198,11 @@ ctn_end:
    }
    
 doc_end:
+    if (newline) {
+        incr_len(2);
+        *(cur - 1) = '\n';
+        cur++;
+    }
    *--cur = '\0';
    *dat_len = (usize)(cur - hdr);
    err->code = YYJSON_WRITE_SUCCESS;
@@ -9162,6 +9278,7 @@ static_inline u8 *yyjson_mut_write_pretty(const yyjson_mut_val *root,
    bool esc = has_write_flag(ESCAPE_UNICODE) != 0;
    bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0;
    usize spaces = has_write_flag(PRETTY_TWO_SPACES) ? 2 : 4;
+    bool newline = has_write_flag(NEWLINE_AT_END) != 0;
    
    alc_len = estimated_val_num * YYJSON_WRITER_ESTIMATED_PRETTY_RATIO + 64;
    alc_len = size_align_up(alc_len, sizeof(yyjson_mut_write_ctx));
@@ -9296,6 +9413,10 @@ ctn_end:
    }
    
 doc_end:
+    if (newline) {
+        incr_len(2);
+        *cur++ = '\n';
+    }
    *cur = '\0';
    *dat_len = (usize)(cur - hdr);
    err->code = YYJSON_WRITE_SUCCESS;
@@ -527,16 +527,16 @@ extern "C" {
 #define YYJSON_VERSION_MAJOR  0

 /** The minor version of yyjson. */
-#define YYJSON_VERSION_MINOR  8
+#define YYJSON_VERSION_MINOR  10

 /** The patch version of yyjson. */
 #define YYJSON_VERSION_PATCH  0

 /** The version of yyjson in hex: `(major << 16) | (minor << 8) | (patch)`. */
-#define YYJSON_VERSION_HEX    0x000800
+#define YYJSON_VERSION_HEX    0x000A00

 /** The version string of yyjson. */
-#define YYJSON_VERSION_STRING "0.8.0"
+#define YYJSON_VERSION_STRING "0.10.0"

 /** The version of yyjson in hex, same as `YYJSON_VERSION_HEX`. */
 yyjson_api uint32_t yyjson_version(void);
@@ -738,7 +738,7 @@ typedef uint32_t yyjson_read_flag;
    - Report error if double number is infinity.
    - Report error if string contains invalid UTF-8 character or BOM.
    - Report error on trailing commas, comments, inf and nan literals. */
-static const yyjson_read_flag YYJSON_READ_NOFLAG                = 0 << 0;
+static const yyjson_read_flag YYJSON_READ_NOFLAG                = 0;

 /** Read the input data in-situ.
    This option allows the reader to modify and use input data to store string
@@ -841,6 +841,24 @@ typedef struct yyjson_read_err {
    size_t pos;
 } yyjson_read_err;

+/**
+ Locate the line and column number for a byte position in a string.
+ This can be used to get better description for error position.
+ 
+ @param str The input string.
+ @param len The byte length of the input string.
+ @param pos The byte position within the input string.
+ @param line A pointer to receive the line number, starting from 1.
+ @param col  A pointer to receive the column number, starting from 1.
+ @param chr  A pointer to receive the character index, starting from 0.
+ @return true on success, false if `str` is NULL or `pos` is out of bounds.
+ @note Line/column/character are calculated based on Unicode characters for
+    compatibility with text editors. For multi-byte UTF-8 characters,
+    the returned value may not directly correspond to the byte position.
+ */
+yyjson_api bool yyjson_locate_pos(const char *str, size_t len, size_t pos,
+                                  size_t *line, size_t *col, size_t *chr);
+


 /**
@@ -1067,7 +1085,7 @@ typedef uint32_t yyjson_write_flag;
    - Report error on inf or nan number.
    - Report error on invalid UTF-8 string.
    - Do not escape unicode or slash. */
-static const yyjson_write_flag YYJSON_WRITE_NOFLAG                  = 0 << 0;
+static const yyjson_write_flag YYJSON_WRITE_NOFLAG                  = 0;

 /** Write JSON pretty with 4 space indent. */
 static const yyjson_write_flag YYJSON_WRITE_PRETTY                  = 1 << 0;
@@ -1096,6 +1114,10 @@ static const yyjson_write_flag YYJSON_WRITE_ALLOW_INVALID_UNICODE   = 1 << 5;
    This flag will override `YYJSON_WRITE_PRETTY` flag. */
 static const yyjson_write_flag YYJSON_WRITE_PRETTY_TWO_SPACES       = 1 << 6;

+/** Adds a newline character `\n` at the end of the JSON.
+    This can be helpful for text editors or NDJSON. */
+static const yyjson_write_flag YYJSON_WRITE_NEWLINE_AT_END          = 1 << 7;
+


 /** Result code for JSON writer */
@@ -3695,7 +3717,7 @@ yyjson_api_inline bool yyjson_mut_obj_add_strcpy(yyjson_mut_doc *doc,
    The `len` should be the length of the `val`, in bytes.
    This function allows duplicated key in one object.
    
-    @warning The key/value strings are not copied, you should keep these strings
+    @warning The key strings are not copied, you should keep these strings
        unmodified for the lifetime of this JSON document. */
 yyjson_api_inline bool yyjson_mut_obj_add_strncpy(yyjson_mut_doc *doc,
                                                  yyjson_mut_val *obj,
@@ -4829,6 +4851,7 @@ yyjson_api_inline size_t yyjson_doc_get_val_count(yyjson_doc *doc) {
 yyjson_api_inline void yyjson_doc_free(yyjson_doc *doc) {
    if (doc) {
        yyjson_alc alc = doc->alc;
+        memset(&doc->alc, 0, sizeof(alc));
        if (doc->str_pool) alc.free(alc.ctx, doc->str_pool);
        alc.free(alc.ctx, doc);
    }
@@ -5668,6 +5691,7 @@ yyjson_api_inline yyjson_mut_val *yyjson_mut_bool(yyjson_mut_doc *doc,
    if (yyjson_likely(doc)) {
        yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1);
        if (yyjson_likely(val)) {
+            _val = !!_val;
            val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)_val << 3);
            return val;
        }
@@ -5920,7 +5944,8 @@ yyjson_api_inline yyjson_mut_val *yyjson_mut_arr(yyjson_mut_doc *doc) {
 yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_bool(
    yyjson_mut_doc *doc, const bool *vals, size_t count) {
    yyjson_mut_arr_with_func({
-        val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)vals[i] << 3);
+        bool _val = !!vals[i];
+        val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)_val << 3);
    });
 }

@@ -6872,6 +6897,7 @@ yyjson_api_inline bool yyjson_mut_obj_add_bool(yyjson_mut_doc *doc,
                                               const char *_key,
                                               bool _val) {
    yyjson_mut_obj_add_func({
+        _val = !!_val;
        val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)(_val) << 3);
    });
 }
@@ -7730,33 +7756,39 @@ yyjson_api_inline bool yyjson_ptr_get_bool(
 }

 /**
- Set provided `value` if the JSON Pointer (RFC 6901) exists and is type uint.
- Returns true if value at `ptr` exists and is the correct type, otherwise false.
+ Set provided `value` if the JSON Pointer (RFC 6901) exists and is an integer
+ that fits in `uint64_t`. Returns true if successful, otherwise false.
 */
 yyjson_api_inline bool yyjson_ptr_get_uint(
    yyjson_val *root, const char *ptr, uint64_t *value) {
    yyjson_val *val = yyjson_ptr_get(root, ptr);
-    if (value && yyjson_is_uint(val)) {
-        *value = unsafe_yyjson_get_uint(val);
-        return true;
-    } else {
-        return false;
+    if (value && val) {
+        uint64_t ret = val->uni.u64;
+        if (unsafe_yyjson_is_uint(val) ||
+            (unsafe_yyjson_is_sint(val) && !(ret >> 63))) {
+            *value = ret;
+            return true;
+        }
    }
+    return false;
 }

 /**
- Set provided `value` if the JSON Pointer (RFC 6901) exists and is type sint.
- Returns true if value at `ptr` exists and is the correct type, otherwise false.
+ Set provided `value` if the JSON Pointer (RFC 6901) exists and is an integer
+ that fits in `int64_t`. Returns true if successful, otherwise false.
 */
 yyjson_api_inline bool yyjson_ptr_get_sint(
    yyjson_val *root, const char *ptr, int64_t *value) {
    yyjson_val *val = yyjson_ptr_get(root, ptr);
-    if (value && yyjson_is_sint(val)) {
-        *value = unsafe_yyjson_get_sint(val);
-        return true;
-    } else {
-        return false;
+    if (value && val) {
+        int64_t ret = val->uni.i64;
+        if (unsafe_yyjson_is_sint(val) ||
+            (unsafe_yyjson_is_uint(val) && ret >= 0)) {
+            *value = ret;
+            return true;
+        }
    }
+    return false;
 }

 /**
@@ -1,4 +1,5 @@
 #include "commandoption.h"
+#include "common/color.h"
 #include "common/printing.h"
 #include "common/time.h"
 #include "common/jsonconfig.h"
@@ -11,7 +12,7 @@

 bool ffParseModuleOptions(const char* key, const char* value)
 {
-    if (!ffStrStartsWith(key, "--") || !isalpha(key[2])) return false;
+    if (!ffStrStartsWith(key, "--") || !ffCharIsEnglishAlphabet(key[2])) return false;

    for (FFModuleBaseInfo** modules = ffModuleInfos[toupper(key[2]) - 'A']; *modules; ++modules)
    {
@@ -79,30 +80,11 @@ static void genJsonResult(FFModuleBaseInfo* baseInfo, yyjson_mut_doc* doc)

 static void parseStructureCommand(
    const char* line,
-    FFlist* customValues,
    void (*fn)(FFModuleBaseInfo *baseInfo, yyjson_mut_doc* jsonDoc),
    yyjson_mut_doc* jsonDoc
 )
 {
-    // handle `--set` and `--set-keyless`
-    FF_LIST_FOR_EACH(FFCustomValue, customValue, *customValues)
-    {
-        if (ffStrbufEqualS(&customValue->key, line))
-        {
-            __attribute__((__cleanup__(ffDestroyCustomOptions))) FFCustomOptions options;
-            ffInitCustomOptions(&options);
-            if (customValue->printKey)
-                ffStrbufAppend(&options.moduleArgs.key, &customValue->key);
-            ffStrbufAppend(&options.moduleArgs.outputFormat, &customValue->value);
-            if (__builtin_expect(jsonDoc != NULL, false))
-                fn((FFModuleBaseInfo*) &options, jsonDoc);
-            else
-                ffPrintCustom(&options);
-            return;
-        }
-    }
-
-    if(isalpha(line[0]))
+    if(ffCharIsEnglishAlphabet(line[0]))
    {
        for (FFModuleBaseInfo** modules = ffModuleInfos[toupper(line[0]) - 'A']; *modules; ++modules)
        {
@@ -118,41 +100,41 @@ static void parseStructureCommand(
        }
    }

-    ffPrintErrorString(line, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "<no implementation provided>");
+    ffPrintError(line, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "<no implementation provided>");
 }

 void ffPrintCommandOption(FFdata* data, yyjson_mut_doc* jsonDoc)
 {
    //Parse the structure and call the modules
+    int32_t thres = instance.config.display.stat;
    uint32_t startIndex = 0;
    while (startIndex < data->structure.length)
    {
        uint32_t colonIndex = ffStrbufNextIndexC(&data->structure, startIndex, ':');
        data->structure.chars[colonIndex] = '\0';

-        uint64_t ms = 0;
-        if(instance.config.display.stat)
+        double ms = 0;
+        if(thres >= 0)
            ms = ffTimeGetTick();

-        parseStructureCommand(data->structure.chars + startIndex, &data->customValues, genJsonResult, jsonDoc);
+        parseStructureCommand(data->structure.chars + startIndex, genJsonResult, jsonDoc);

-        if(instance.config.display.stat)
+        if(thres >= 0)
        {
            ms = ffTimeGetTick() - ms;

            if (jsonDoc)
            {
                yyjson_mut_val* moduleJson = yyjson_mut_arr_get_last(jsonDoc->root);
-                yyjson_mut_obj_add_uint(jsonDoc, moduleJson, "stat", ms);
+                yyjson_mut_obj_add_real(jsonDoc, moduleJson, "stat", ms);
            }
            else
            {
-                char str[32];
-                int len = snprintf(str, sizeof str, "%" PRIu64 "ms", ms);
-                if(instance.config.display.pipe)
-                    puts(str);
-                else
-                    printf("\033[s\033[1A\033[9999999C\033[%dD%s\033[u", len, str); // Save; Up 1; Right 9999999; Left <len>; Print <str>; Load
+                char str[64];
+                int len = snprintf(str, sizeof str, "%.3fms", ms);
+                if (thres > 0)
+                    snprintf(str, sizeof str, "\e[%sm%.3fms\e[m", (ms <= thres ? FF_COLOR_FG_GREEN : ms <= 2 * thres ? FF_COLOR_FG_YELLOW : FF_COLOR_FG_RED), ms);
+                printf("\e[s\e[1A\e[9999999C\e[%dD%s\e[u", len, str); // Save; Up 1; Right 9999999; Left <len>; Print <str>; Load
            }
        }

@@ -177,7 +159,7 @@ void ffMigrateCommandOptionToJsonc(FFdata* data, yyjson_mut_doc* jsonDoc)
        uint32_t colonIndex = ffStrbufNextIndexC(&data->structure, startIndex, ':');
        data->structure.chars[colonIndex] = '\0';

-        parseStructureCommand(data->structure.chars + startIndex, &data->customValues, genJsonConfig, jsonDoc);
+        parseStructureCommand(data->structure.chars + startIndex, genJsonConfig, jsonDoc);

        startIndex = colonIndex + 1;
    }
@@ -2,18 +2,10 @@

 #include "fastfetch.h"

-typedef struct FFCustomValue
-{
-    bool printKey;
-    FFstrbuf key;
-    FFstrbuf value;
-} FFCustomValue;
-
 // Things only needed by fastfetch
 typedef struct FFdata
 {
    FFstrbuf structure;
-    FFlist customValues; // List of FFCustomValue
    bool configLoaded;
 } FFdata;

@@ -10,9 +10,8 @@ static bool loadLibSymbols(FFDBusLibrary* lib)
    FF_LIBRARY_LOAD(dbus, &instance.config.library.libDBus, false, "libdbus-1" FF_LIBRARY_EXTENSION, 4);
    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_bus_get, false)
    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_new_method_call, false)
+    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_append_args, false)
    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_iter_init, false)
-    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_iter_init_append, false)
-    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_iter_append_basic, false)
    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_iter_get_arg_type, false)
    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_iter_get_basic, false)
    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_iter_recurse, false)
@@ -20,10 +19,6 @@ static bool loadLibSymbols(FFDBusLibrary* lib)
    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_iter_next, false)
    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_unref, false)
    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_connection_send_with_reply_and_block, false)
-    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_connection_flush, false)
-    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_pending_call_block, false)
-    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_pending_call_steal_reply, false)
-    FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_pending_call_unref, false)
    dbus = NULL; // don't auto dlclose
    return true;
 }
@@ -56,11 +51,11 @@ const char* ffDBusLoadData(DBusBusType busType, FFDBusData* data)
    return NULL;
 }

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

-    if(argType == DBUS_TYPE_STRING)
+    if(argType == DBUS_TYPE_STRING || argType == DBUS_TYPE_OBJECT_PATH)
    {
        const char* value = NULL;
        dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
@@ -72,6 +67,14 @@ bool ffDBusGetValue(FFDBusData* dbus, DBusMessageIter* iter, FFstrbuf* result)
        return true;
    }

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

@@ -79,7 +82,7 @@ bool ffDBusGetValue(FFDBusData* dbus, DBusMessageIter* iter, FFstrbuf* result)
    dbus->lib->ffdbus_message_iter_recurse(iter, &subIter);

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

    //At this point we have an array

@@ -87,13 +90,16 @@ bool ffDBusGetValue(FFDBusData* dbus, DBusMessageIter* iter, FFstrbuf* result)

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

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

    if(foundAValue)
@@ -122,11 +128,27 @@ bool ffDBusGetBool(FFDBusData* dbus, DBusMessageIter* iter, bool* result)
    return ffDBusGetBool(dbus, &subIter, result);
 }

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

    if(argType == DBUS_TYPE_BYTE)
+    {
+        uint8_t value = 0;
+        dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
+        *result = value;
+        return true;
+    }
+
+    if(argType == DBUS_TYPE_UINT16)
+    {
+        uint16_t value = 0;
+        dbus->lib->ffdbus_message_iter_get_basic(iter, &value);
+        *result = value;
+        return true;
+    }
+
+    if(argType == DBUS_TYPE_UINT32)
    {
        dbus->lib->ffdbus_message_iter_get_basic(iter, result);
        return true;
@@ -137,15 +159,18 @@ bool ffDBusGetByte(FFDBusData* dbus, DBusMessageIter* iter, uint8_t* result)

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

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

+    if (arg)
+        dbus->lib->ffdbus_message_append_args(message, DBUS_TYPE_STRING, &arg, DBUS_TYPE_INVALID);
+
    DBusMessage* reply = dbus->lib->ffdbus_connection_send_with_reply_and_block(dbus->connection, message, FF_DBUS_TIMEOUT_MILLISECONDS, NULL);

    dbus->lib->ffdbus_message_unref(message);
@@ -159,20 +184,10 @@ DBusMessage* ffDBusGetProperty(FFDBusData* dbus, const char* busName, const char
    if(message == NULL)
        return NULL;

-    DBusMessageIter requestIterator;
-    dbus->lib->ffdbus_message_iter_init_append(message, &requestIterator);
-
-    if(!dbus->lib->ffdbus_message_iter_append_basic(&requestIterator, DBUS_TYPE_STRING, &interface))
-    {
-        dbus->lib->ffdbus_message_unref(message);
-        return NULL;
-    }
-
-    if(!dbus->lib->ffdbus_message_iter_append_basic(&requestIterator, DBUS_TYPE_STRING, &property))
-    {
-        dbus->lib->ffdbus_message_unref(message);
-        return NULL;
-    }
+    dbus->lib->ffdbus_message_append_args(message,
+        DBUS_TYPE_STRING, &interface,
+        DBUS_TYPE_STRING, &property,
+        DBUS_TYPE_INVALID);

    DBusMessage* reply = dbus->lib->ffdbus_connection_send_with_reply_and_block(dbus->connection, message, FF_DBUS_TIMEOUT_MILLISECONDS, NULL);

@@ -181,22 +196,44 @@ DBusMessage* ffDBusGetProperty(FFDBusData* dbus, const char* busName, const char
    return reply;
 }

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

    DBusMessageIter rootIterator;
    if(!dbus->lib->ffdbus_message_iter_init(reply, &rootIterator))
    {
        dbus->lib->ffdbus_message_unref(reply);
-        return;
+        return false;
    }

-    ffDBusGetValue(dbus, &rootIterator, result);
+    bool ret = ffDBusGetString(dbus, &rootIterator, result);

    dbus->lib->ffdbus_message_unref(reply);
+
+    return ret;
+}
+
+bool ffDBusGetPropertyUint(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property, uint32_t* result)
+{
+    DBusMessage* reply = ffDBusGetProperty(dbus, busName, objectPath, interface, property);
+    if(reply == NULL)
+        return false;
+
+    DBusMessageIter rootIterator;
+    if(!dbus->lib->ffdbus_message_iter_init(reply, &rootIterator))
+    {
+        dbus->lib->ffdbus_message_unref(reply);
+        return false;
+    }
+
+    bool ret = ffDBusGetUint(dbus, &rootIterator, result);
+
+    dbus->lib->ffdbus_message_unref(reply);
+
+    return ret;
 }

 #endif //FF_HAVE_DBUS
@@ -6,23 +6,14 @@
 #include "util/FFstrbuf.h"
 #include "common/library.h"

-#define FF_DBUS_TIMEOUT_MILLISECONDS 35
-
-#define FF_DBUS_ITER_CONTINUE(dbus, iterator) \
-    { \
-        if(!(dbus)->lib->ffdbus_message_iter_has_next(iterator)) \
-            break; \
-        (dbus)->lib->ffdbus_message_iter_next(iterator); \
-        continue; \
-    }
+#define FF_DBUS_TIMEOUT_MILLISECONDS 100

 typedef struct FFDBusLibrary
 {
    FF_LIBRARY_SYMBOL(dbus_bus_get)
    FF_LIBRARY_SYMBOL(dbus_message_new_method_call)
+    FF_LIBRARY_SYMBOL(dbus_message_append_args)
    FF_LIBRARY_SYMBOL(dbus_message_iter_init)
-    FF_LIBRARY_SYMBOL(dbus_message_iter_init_append)
-    FF_LIBRARY_SYMBOL(dbus_message_iter_append_basic)
    FF_LIBRARY_SYMBOL(dbus_message_iter_get_arg_type)
    FF_LIBRARY_SYMBOL(dbus_message_iter_get_basic)
    FF_LIBRARY_SYMBOL(dbus_message_iter_recurse)
@@ -30,10 +21,6 @@ typedef struct FFDBusLibrary
    FF_LIBRARY_SYMBOL(dbus_message_iter_next)
    FF_LIBRARY_SYMBOL(dbus_message_unref)
    FF_LIBRARY_SYMBOL(dbus_connection_send_with_reply_and_block)
-    FF_LIBRARY_SYMBOL(dbus_connection_flush)
-    FF_LIBRARY_SYMBOL(dbus_pending_call_block)
-    FF_LIBRARY_SYMBOL(dbus_pending_call_steal_reply)
-    FF_LIBRARY_SYMBOL(dbus_pending_call_unref)
 } FFDBusLibrary;

 typedef struct FFDBusData
@@ -43,11 +30,12 @@ typedef struct FFDBusData
 } FFDBusData;

 const char* ffDBusLoadData(DBusBusType busType, FFDBusData* data); //Returns an error message or NULL on success
-bool ffDBusGetValue(FFDBusData* dbus, DBusMessageIter* iter, FFstrbuf* result);
+bool ffDBusGetString(FFDBusData* dbus, DBusMessageIter* iter, FFstrbuf* result);
 bool ffDBusGetBool(FFDBusData* dbus, DBusMessageIter* iter, bool* result);
-bool ffDBusGetByte(FFDBusData* dbus, DBusMessageIter* iter, uint8_t* result);
-DBusMessage* ffDBusGetMethodReply(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* method);
+bool ffDBusGetUint(FFDBusData* dbus, DBusMessageIter* iter, uint32_t* result);
+DBusMessage* ffDBusGetMethodReply(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* method, const char* arg);
 DBusMessage* ffDBusGetProperty(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property);
-void ffDBusGetPropertyString(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property, FFstrbuf* result);
+bool ffDBusGetPropertyString(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property, FFstrbuf* result);
+bool ffDBusGetPropertyUint(FFDBusData* dbus, const char* busName, const char* objectPath, const char* interface, const char* property, uint32_t* result);

 #endif // FF_HAVE_DBUS
@@ -2,6 +2,7 @@
 #include "common/font.h"

 #include <string.h>
+#include <ctype.h>

 void ffFontInit(FFfont* font)
 {
@@ -66,59 +67,33 @@ void ffFontInitQt(FFfont* font, const char* data)
    //See https://doc.qt.io/qt-5/qfont.html#toString

    //Family
-    while(*data != ',' && *data != '\0')
-    {
-        ffStrbufAppendC(&font->name, *data);
-        ++data;
-    }
-    if(*data != '\0')
-        ++data;
+    data = ffStrbufAppendSUntilC(&font->name, data, ',');
    ffStrbufTrim(&font->name, ' ');
+    if (!data) goto exit;
+    data++;

    //Size
-    while(*data != ',' && *data != '\0')
-    {
-        ffStrbufAppendC(&font->size, *data);
-        ++data;
-    }
-    if(*data != '\0')
-        ++data;
+    data = ffStrbufAppendSUntilC(&font->size, data, ',');
    ffStrbufTrim(&font->size, ' ');
+    if (!data) goto exit;
+    data++;

-    #define FF_FONT_QT_SKIP_VALUE \
-        while(*data != ',' && *data != '\0') \
-            ++data; \
-        if(*data != '\0') \
-             ++data;
-
-    FF_FONT_QT_SKIP_VALUE //Pixel size
-    FF_FONT_QT_SKIP_VALUE //Style hint
-    FF_FONT_QT_SKIP_VALUE //Font weight
-    FF_FONT_QT_SKIP_VALUE //Font style
-    FF_FONT_QT_SKIP_VALUE //Underline
-    FF_FONT_QT_SKIP_VALUE //Strike out
-    FF_FONT_QT_SKIP_VALUE //Fixed pitch
-    FF_FONT_QT_SKIP_VALUE //Always 0
-
-    #undef FF_FONT_QT_SKIP_VALUE
-
-    while(*data != '\0')
+    //Style
+    data = strrchr(data, ',');
+    if (!data) goto exit;
+    data++;
+    if (isalpha(*data))
    {
-        while(*data == ' ')
-            ++data;
-
-        if(*data == '\0')
-            break;
-
-        FFstrbuf* style = ffListAdd(&font->styles);
-        ffStrbufInit(style);
-        while(*data != ' ' && *data != '\0')
+        do
        {
-            ffStrbufAppendC(style, *data);
-            ++data;
-        }
+            FFstrbuf* style = ffListAdd(&font->styles);
+            ffStrbufInit(style);
+            data = ffStrbufAppendSUntilC(style, data, ' ');
+            if (data) data++;
+        } while (data);
    }

+exit:
    fontInitPretty(font);
 }

@@ -52,14 +52,33 @@ void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg)
 * @param placeholderValue the string to parse
 * @return uint32_t the parsed value
 */
-static inline uint32_t getArgumentIndex(const FFstrbuf* placeholderValue)
+static uint32_t getArgumentIndex(const char* placeholderValue, uint32_t numArgs, const FFformatarg* arguments)
 {
-    uint32_t result = UINT32_MAX;
+    char firstChar = placeholderValue[0];
+    if (firstChar == '\0')
+        return 0; // use arg counter

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

-    return result == 0 ? UINT32_MAX : result;
+    return UINT32_MAX;
 }

 static inline void appendInvalidPlaceholder(FFstrbuf* buffer, const char* start, const FFstrbuf* placeholderValue, uint32_t index, uint32_t formatStringLength)
@@ -71,16 +90,6 @@ static inline void appendInvalidPlaceholder(FFstrbuf* buffer, const char* start,
        ffStrbufAppendC(buffer, '}');
 }

-static inline void appendEmptyPlaceholder(FFstrbuf* buffer, const char* placeholder, uint32_t* argCounter, uint32_t numArgs, const FFformatarg* arguments)
-{
-    if(*argCounter >= numArgs)
-        ffStrbufAppendS(buffer, placeholder);
-    else
-        ffFormatAppendFormatArg(buffer, arguments + *argCounter);
-
-    (*argCounter)++;
-}
-
 static inline bool formatArgSet(const FFformatarg* arg)
 {
    return arg->value != NULL && (
@@ -101,7 +110,8 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n

    uint32_t numOpenIfs = 0;
    uint32_t numOpenNotIfs = 0;
-    uint32_t numOpenColors = 0;
+
+    FF_STRBUF_AUTO_DESTROY placeholderValue = ffStrbufCreate();

    for(uint32_t i = 0; i < formatstr->length; ++i)
    {
@@ -112,13 +122,6 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
            continue;
        }

-        // if we have an { at the end handle it as {}
-        if(i == formatstr->length - 1)
-        {
-            appendEmptyPlaceholder(buffer, "{", &argCounter, numArgs, arguments);
-            continue;
-        }
-
        // jump to next char, the start of the placeholder value
        ++i;

@@ -129,74 +132,70 @@ void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t n
            continue;
        }

-        // placeholder is {}
-        if(formatstr->chars[i] == '}')
+        ffStrbufClear(&placeholderValue);
+
        {
-            appendEmptyPlaceholder(buffer, "{}", &argCounter, numArgs, arguments);
-            continue;
+            uint32_t iEnd = ffStrbufNextIndexC(formatstr, i, '}');
+            ffStrbufAppendNS(&placeholderValue, iEnd - i, &formatstr->chars[i]);
+            i = iEnd;
        }

-        FF_STRBUF_AUTO_DESTROY placeholderValue = ffStrbufCreate();
+        char firstChar = placeholderValue.chars[0];

-        while(i < formatstr->length && formatstr->chars[i] != '}')
-            ffStrbufAppendC(&placeholderValue, formatstr->chars[i++]);
-
-         // test if for stop, if so break the loop
-        if(placeholderValue.length == 1 && placeholderValue.chars[0] == '-')
-            break;
-
-        // test for end of an if, if so do nothing
-        if(placeholderValue.length == 1 && placeholderValue.chars[0] == '?')
+        if (placeholderValue.length == 1)
        {
-            if(numOpenIfs == 0)
-                appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
-            else
-                --numOpenIfs;
+            // test if for stop, if so break the loop
+            if (firstChar == '-')
+                break;

-            continue;
-        }
-
-        // test for end of a not if, if so do nothing
-        if(placeholderValue.length == 1 && placeholderValue.chars[0] == '/')
-        {
-            if(numOpenNotIfs == 0)
-                appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
-            else
-                --numOpenNotIfs;
-
-            continue;
-        }
-
-        // test for end of a color, if so do nothing
-        if(placeholderValue.length == 1 && placeholderValue.chars[0] == '#')
-        {
-            if(numOpenColors == 0)
-                appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
-            else
+            // test for end of an if, if so do nothing
+            if (firstChar == '?')
            {
-                ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
-                --numOpenColors;
+                if(numOpenIfs == 0)
+                    appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
+                else
+                    --numOpenIfs;
+
+                continue;
            }

-            continue;
+            // test for end of a not if, if so do nothing
+            if (firstChar == '/')
+            {
+                if(numOpenNotIfs == 0)
+                    appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
+                else
+                    --numOpenNotIfs;
+
+                continue;
+            }
+
+            // test for end of a color, if so do nothing
+            if (firstChar == '#')
+            {
+                if (!instance.config.display.pipe)
+                    ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
+
+                continue;
+            }
        }

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

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

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

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

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

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

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

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

        //test for color, if so evaluate it
-        if(placeholderValue.chars[0] == '#')
+        if (firstChar == '#')
        {
-            ++numOpenColors;
-            ffStrbufSubstrAfter(&placeholderValue, 0);
-            ffStrbufAppendS(buffer, "\033[");
-            ffStrbufAppend(buffer, &placeholderValue);
-            ffStrbufAppendC(buffer, 'm');
+            if (!instance.config.display.pipe)
+            {
+                ffStrbufAppendS(buffer, "\e[");
+                ffOptionParseColorNoClear(placeholderValue.chars + 1, buffer);
+                ffStrbufAppendC(buffer, 'm');
+            }
            continue;
        }

-        uint32_t index = getArgumentIndex(&placeholderValue);
+        //test for constant, if so evaluate it
+        if (firstChar == '$')
+        {
+            char* pend = NULL;
+            int32_t indexSigned = (int32_t) strtol(placeholderValue.chars + 1, &pend, 10);
+            uint32_t index = (uint32_t) indexSigned;
+            bool backward = indexSigned < 0;
+
+            if (indexSigned == 0 || *pend != '\0' || instance.config.display.constants.length < index)
+            {
+                appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
+                continue;
+            }
+
+            FFstrbuf* item = FF_LIST_GET(FFstrbuf, instance.config.display.constants, backward
+                ? instance.config.display.constants.length - index
+                : index - 1);
+            ffStrbufAppend(buffer, item);
+            continue;
+        }
+
+        int32_t truncLength = 0;
+        char align = '\0';
+        char* pSep = memchr(placeholderValue.chars, ':', placeholderValue.length);
+        if (pSep)
+            align = ':';
+        else
+        {
+            pSep = memchr(placeholderValue.chars, '<', placeholderValue.length);
+            if (pSep)
+                align = '<';
+            else
+            {
+                pSep = memchr(placeholderValue.chars, '>', placeholderValue.length);
+                if (pSep)
+                    align = '>';
+            }
+        }
+
+        if (pSep)
+        {
+            char* pEnd = NULL;
+            truncLength = (int32_t) strtol(pSep + 1, &pEnd, 10);
+            if (*pEnd != '\0')
+            {
+                appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
+                continue;
+            }
+            *pSep = '\0';
+        }
+
+        uint32_t index = getArgumentIndex(placeholderValue.chars, numArgs, arguments);

        // test for invalid index
-        if(index > numArgs)
+        if (index == 0)
+            index = ++argCounter;
+
+        if (index > numArgs)
        {
+            if (pSep) *pSep = align;
            appendInvalidPlaceholder(buffer, "{", &placeholderValue, i, formatstr->length);
            continue;
        }

-        ffFormatAppendFormatArg(buffer, &arguments[index - 1]);
+        bool ellipsis = false;
+        if (truncLength < 0)
+        {
+            ellipsis = true;
+            truncLength = -truncLength;
+        }
+
+        if (!align)
+            ffFormatAppendFormatArg(buffer, &arguments[index - 1]);
+        else
+        {
+            ffStrbufClear(&placeholderValue);
+            ffFormatAppendFormatArg(&placeholderValue, &arguments[index - 1]);
+            if (placeholderValue.length == (uint32_t) truncLength)
+                ffStrbufAppend(buffer, &placeholderValue);
+            else if (placeholderValue.length > (uint32_t) truncLength)
+            {
+                if (align == ':')
+                {
+                    ffStrbufSubstrBefore(&placeholderValue, (uint32_t) truncLength);
+                    ffStrbufTrimRightSpace(&placeholderValue);
+                }
+                else
+                    ffStrbufSubstrBefore(&placeholderValue, (uint32_t) (!ellipsis? truncLength : truncLength - 1));
+                ffStrbufAppend(buffer, &placeholderValue);
+
+                if (ellipsis)
+                    ffStrbufAppendS(buffer, "…");
+            }
+            else if (align == ':')
+                ffStrbufAppend(buffer, &placeholderValue);
+            else
+            {
+                if (align == '<')
+                {
+                    ffStrbufAppend(buffer, &placeholderValue);
+                    ffStrbufAppendNC(buffer, (uint32_t) truncLength - placeholderValue.length, ' ');
+                }
+                else
+                {
+                    ffStrbufAppendNC(buffer, (uint32_t) truncLength - placeholderValue.length, ' ');
+                    ffStrbufAppend(buffer, &placeholderValue);
+                }
+            }
+        }
    }

-    ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
+    if (!instance.config.display.pipe)
+        ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
 }
@@ -1,5 +1,7 @@
 #pragma once

+#include "util/FFstrbuf.h"
+
 typedef enum FFformatargtype
 {
    FF_FORMAT_ARG_TYPE_NULL = 0,
@@ -20,7 +22,12 @@ typedef struct FFformatarg
 {
    FFformatargtype type;
    const void* value;
+    const char* name; // argument name, must start with an alphabet
 } FFformatarg;

 void ffFormatAppendFormatArg(FFstrbuf* buffer, const FFformatarg* formatarg);
 void ffParseFormatString(FFstrbuf* buffer, const FFstrbuf* formatstr, uint32_t numArgs, const FFformatarg* arguments);
+#define FF_PARSE_FORMAT_STRING_CHECKED(buffer, formatstr, numArgs, arguments) do {\
+    static_assert(sizeof(arguments) / sizeof(*(arguments)) == (numArgs), "Invalid number of format arguments");\
+    ffParseFormatString((buffer), (formatstr), (numArgs), (arguments));\
+} while (0)
@@ -2,6 +2,7 @@
 #include "common/parsing.h"
 #include "common/thread.h"
 #include "detection/displayserver/displayserver.h"
+#include "detection/terminaltheme/terminaltheme.h"
 #include "util/textModifier.h"
 #include "logo/logo.h"

@@ -22,10 +23,18 @@ static void initState(FFstate* state)
    state->logoWidth = 0;
    state->logoHeight = 0;
    state->keysHeight = 0;
+    state->terminalLightTheme = false;

    ffPlatformInit(&state->platform);
    state->configDoc = NULL;
    state->resultDoc = NULL;
+
+    {
+        // don't enable bright color if the terminal is in light mode
+        FFTerminalThemeResult result;
+        if (ffDetectTerminalTheme(&result, true /* forceEnv for performance */) && !result.bg.dark)
+            state->terminalLightTheme = true;
+    }
 }

 static void defaultConfig(void)
@@ -43,8 +52,8 @@ void ffInitInstance(void)
        //https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/setlocale-wsetlocale?source=recommendations&view=msvc-170#utf-8-support
        setlocale(LC_ALL, ".UTF8");
    #else
-        // used for mbsrtowcs in Module `separator`
-        setlocale(LC_ALL, "");
+        // Never use `setlocale(LC_ALL, "")`
+        setlocale(LC_TIME, "");
    #endif

    initState(&instance.state);
@@ -160,98 +169,98 @@ void ffDestroyInstance(void)
 void ffListFeatures(void)
 {
    fputs(
-        #ifdef FF_HAVE_THREADS
+        #if FF_HAVE_THREADS
            "threads\n"
        #endif
-        #ifdef FF_HAVE_VULKAN
+        #if FF_HAVE_VULKAN
            "vulkan\n"
        #endif
-        #ifdef FF_HAVE_WAYLAND
+        #if FF_HAVE_WAYLAND
            "wayland\n"
        #endif
-        #ifdef FF_HAVE_XCB_RANDR
+        #if FF_HAVE_XCB_RANDR
            "xcb-randr\n"
        #endif
-        #ifdef FF_HAVE_XCB
+        #if FF_HAVE_XCB
            "xcb\n"
        #endif
-        #ifdef FF_HAVE_XRANDR
+        #if FF_HAVE_XRANDR
            "xrandr\n"
        #endif
-        #ifdef FF_HAVE_X11
+        #if FF_HAVE_X11
            "x11\n"
        #endif
-        #ifdef FF_HAVE_DRM
+        #if FF_HAVE_DRM
            "drm\n"
        #endif
-        #ifdef FF_HAVE_GIO
+        #if FF_HAVE_GIO
            "gio\n"
        #endif
-        #ifdef FF_HAVE_DCONF
+        #if FF_HAVE_DCONF
            "dconf\n"
        #endif
-        #ifdef FF_HAVE_DBUS
+        #if FF_HAVE_DBUS
            "dbus\n"
        #endif
-        #ifdef FF_HAVE_IMAGEMAGICK7
+        #if FF_HAVE_IMAGEMAGICK7
            "imagemagick7\n"
        #endif
-        #ifdef FF_HAVE_IMAGEMAGICK6
+        #if FF_HAVE_IMAGEMAGICK6
            "imagemagick6\n"
        #endif
-        #ifdef FF_HAVE_CHAFA
+        #if FF_HAVE_CHAFA
            "chafa\n"
        #endif
-        #ifdef FF_HAVE_ZLIB
+        #if FF_HAVE_ZLIB
            "zlib\n"
        #endif
-        #ifdef FF_HAVE_XFCONF
+        #if FF_HAVE_XFCONF
            "xfconf\n"
        #endif
-        #ifdef FF_HAVE_SQLITE3
+        #if FF_HAVE_SQLITE3
            "sqlite3\n"
        #endif
-        #ifdef FF_HAVE_RPM
+        #if FF_HAVE_RPM
            "rpm\n"
        #endif
-        #ifdef FF_HAVE_EGL
+        #if FF_HAVE_EGL
            "egl\n"
        #endif
-        #ifdef FF_HAVE_GLX
+        #if FF_HAVE_GLX
            "glx\n"
        #endif
-        #ifdef FF_HAVE_OSMESA
+        #if FF_HAVE_OSMESA
            "osmesa\n"
        #endif
-        #ifdef FF_HAVE_OPENCL
+        #if FF_HAVE_OPENCL
            "opencl\n"
        #endif
-        #ifdef FF_HAVE_FREETYPE
+        #if FF_HAVE_FREETYPE
            "freetype\n"
        #endif
-        #ifdef FF_HAVE_PULSE
+        #if FF_HAVE_PULSE
            "libpulse\n"
        #endif
-        #ifdef FF_HAVE_LIBNM
-            "libnm\n"
-        #endif
-        #ifdef FF_HAVE_DDCUTIL
+        #if FF_HAVE_DDCUTIL
            "libddcutil\n"
        #endif
-        #if __has_include(<linux/videodev2.h>)
-            "videodev2\n"
+        #if FF_HAVE_ELF
+            "libelf\n"
        #endif
-        #ifdef FF_HAVE_DIRECTX_HEADERS
+        #if FF_HAVE_LIBZFS
+            "libzfs\n"
+        #endif
+        #if FF_HAVE_DIRECTX_HEADERS
            "Directx Headers\n"
        #endif
-        #ifdef FF_USE_PROPRIETARY_GPU_DRIVER_API
-            "Proprietary GPU driver API\n"
-        #endif
-        #ifdef FF_USE_SYSTEM_YYJSON
+        #if FF_USE_SYSTEM_YYJSON
            "System yyjson\n"
        #endif
-        #ifdef FF_USE_PCI_MEMORY
-            "PCI memory\n"
+        #if FF_HAVE_LINUX_VIDEODEV2
+            "linux/videodev2\n"
+        #endif
+        #if FF_HAVE_LINUX_WIRELESS
+            "linux/wireless\n"
        #endif
        ""
    , stdout);
@@ -8,11 +8,13 @@
    #include <handleapi.h>
    #include <io.h>
    typedef HANDLE FFNativeFD;
+    #define FF_INVALID_FD INVALID_HANDLE_VALUE
 #else
    #include <unistd.h>
    #include <dirent.h>
    #include <sys/stat.h>
    typedef int FFNativeFD;
+    #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
@@ -99,17 +101,25 @@ static inline bool ffPathExists(const char* path, FFPathType pathType)

    #else

-    struct stat fileStat;
-    if(stat(path, &fileStat) != 0)
-        return false;
+    if (pathType == FF_PATHTYPE_ANY)
+    {
+        // Zero overhead
+        return access(path, F_OK) == 0;
+    }
+    else
+    {
+        struct stat fileStat;
+        if(stat(path, &fileStat) != 0)
+            return false;

-    unsigned int mode = fileStat.st_mode & S_IFMT;
+        unsigned int mode = fileStat.st_mode & S_IFMT;

-    if(pathType & FF_PATHTYPE_FILE && mode != S_IFDIR)
-        return true;
+        if(pathType & FF_PATHTYPE_FILE && mode != S_IFDIR)
+            return true;

-    if(pathType & FF_PATHTYPE_DIRECTORY && mode == S_IFDIR)
-        return true;
+        if(pathType & FF_PATHTYPE_DIRECTORY && mode == S_IFDIR)
+            return true;
+    }

    #endif

@@ -1,6 +1,6 @@
 #include "io.h"
+#include "fastfetch.h"
 #include "util/stringUtils.h"
-#include "util/unused.h"

 #include <fcntl.h>
 #include <termios.h>
@@ -8,8 +8,10 @@
 #include <dirent.h>
 #include <errno.h>

-#if __has_include(<wordexp.h>)
-#include <wordexp.h>
+#if FF_HAVE_WORDEXP
+    #include <wordexp.h>
+#else
+    #warning "<wordexp.h> not available"
 #endif

 static void createSubfolders(const char* fileName)
@@ -112,7 +114,7 @@ bool ffPathExpandEnv(FF_MAYBE_UNUSED const char* in, FF_MAYBE_UNUSED FFstrbuf* o
 {
    bool result = false;

-    #if __has_include(<wordexp.h>) // https://github.com/termux/termux-packages/pull/7056
+    #if FF_HAVE_WORDEXP // https://github.com/termux/termux-packages/pull/7056

    wordexp_t exp;
    if(wordexp(in, &exp, 0) != 0)
@@ -131,31 +133,39 @@ bool ffPathExpandEnv(FF_MAYBE_UNUSED const char* in, FF_MAYBE_UNUSED FFstrbuf* o
    return result;
 }

+static int ftty = -1;
+static struct termios oldTerm;
+void restoreTerm(void)
+{
+    tcsetattr(ftty, TCSAFLUSH, &oldTerm);
+}
+
 const char* ffGetTerminalResponse(const char* request, const char* format, ...)
 {
-    struct termios oldTerm, newTerm;
-    if(tcgetattr(STDIN_FILENO, &oldTerm) == -1)
-        return "tcgetattr(STDIN_FILENO, &oldTerm) failed";
-
-    newTerm = oldTerm;
-    newTerm.c_lflag &= (tcflag_t) ~(ICANON | ECHO);
-    if(tcsetattr(STDIN_FILENO, TCSANOW, &newTerm) == -1)
-        return "tcsetattr(STDIN_FILENO, TCSANOW, &newTerm)";
-
-    fputs(request, stdout);
-    fflush(stdout);
-
-    //Give the terminal 35ms to respond
-    if(poll(&(struct pollfd) { .fd = STDIN_FILENO, .events = POLLIN }, 1, FF_IO_TERM_RESP_WAIT_MS) <= 0)
+    if (ftty < 0)
    {
-        tcsetattr(STDIN_FILENO, TCSANOW, &oldTerm);
-        return "poll() timeout or failed";
+        ftty = open("/dev/tty", O_RDWR | O_NOCTTY | O_CLOEXEC | O_NONBLOCK);
+        if (ftty < 0)
+            return "open(\"/dev/tty\", O_RDWR | O_NOCTTY | O_CLOEXEC) failed";
+
+        if(tcgetattr(ftty, &oldTerm) == -1)
+            return "tcgetattr(STDIN_FILENO, &oldTerm) failed";
+
+        struct termios newTerm = oldTerm;
+        newTerm.c_lflag &= (tcflag_t) ~(ICANON | ECHO);
+        if(tcsetattr(ftty, TCSAFLUSH, &newTerm) == -1)
+            return "tcsetattr(STDIN_FILENO, TCSAFLUSH, &newTerm)";
+        atexit(restoreTerm);
    }

-    char buffer[512];
-    ssize_t bytesRead = read(STDIN_FILENO, buffer, sizeof(buffer) - 1);
+    ffWriteFDData(ftty, strlen(request), request);

-    tcsetattr(STDIN_FILENO, TCSANOW, &oldTerm);
+    //Give the terminal some time to respond
+    if(poll(&(struct pollfd) { .fd = ftty, .events = POLLIN }, 1, FF_IO_TERM_RESP_WAIT_MS) <= 0)
+        return "poll() timeout or failed";
+
+    char buffer[512];
+    ssize_t bytesRead = read(ftty, buffer, sizeof(buffer) - 1);

    if(bytesRead <= 0)
        return "read(STDIN_FILENO, buffer, sizeof(buffer) - 1) failed";
@@ -201,7 +211,11 @@ bool ffSuppressIO(bool suppress)

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

@@ -218,11 +232,24 @@ void listFilesRecursively(uint32_t baseLength, FFstrbuf* folder, uint8_t indenta

    while((entry = readdir(dir)) != NULL)
    {
-        if(entry->d_type == DT_DIR)
-        {
-            if(ffStrEquals(entry->d_name, ".") || ffStrEquals(entry->d_name, ".."))
-                continue;
+        if(entry->d_name[0] == '.') // skip hidden files
+            continue;

+        bool isDir = false;
+#ifndef __sun
+        if(entry->d_type != DT_UNKNOWN && entry->d_type != DT_LNK)
+            isDir = entry->d_type == DT_DIR;
+        else
+#endif
+        {
+            struct stat stbuf;
+            if (fstatat(dfd, entry->d_name, &stbuf, 0) < 0)
+                isDir = false;
+            else
+                isDir = S_ISDIR(stbuf.st_mode);
+        }
+        if (isDir)
+        {
            ffStrbufAppendS(folder, entry->d_name);
            ffStrbufAppendC(folder, '/');
            listFilesRecursively(baseLength, folder, (uint8_t) (indentation + 1), entry->d_name, pretty);
@@ -1,4 +1,5 @@
 #include "io.h"
+#include "fastfetch.h"
 #include "util/stringUtils.h"

 #include <windows.h>
@@ -113,8 +114,40 @@ bool ffPathExpandEnv(const char* in, FFstrbuf* out)

 bool ffSuppressIO(bool suppress)
 {
-    (void) suppress; //Not implemented.
-    return false;
+    static bool init = false;
+    static HANDLE hOrigOut = INVALID_HANDLE_VALUE;
+    static HANDLE hOrigErr = INVALID_HANDLE_VALUE;
+    static HANDLE hNullFile = INVALID_HANDLE_VALUE;
+    static int fOrigOut = -1;
+    static int fOrigErr = -1;
+    static int fNullFile = -1;
+
+    if (!init)
+    {
+        if(!suppress)
+            return true;
+
+        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);
+
+        init = true;
+    }
+    if (hNullFile == INVALID_HANDLE_VALUE || fNullFile == -1)
+        return false;
+
+    fflush(stdout);
+    fflush(stderr);
+
+    SetStdHandle(STD_OUTPUT_HANDLE, suppress ? hNullFile : hOrigOut);
+    SetStdHandle(STD_ERROR_HANDLE, suppress ? hNullFile : hOrigErr);
+    _dup2(suppress ? fNullFile : fOrigOut, STDOUT_FILENO);
+    _dup2(suppress ? fNullFile : fOrigErr, STDERR_FILENO);
+
+    return true;
 }

 void listFilesRecursively(uint32_t baseLength, FFstrbuf* folder, uint8_t indentation, const char* folderName, bool pretty)
@@ -175,20 +208,35 @@ void ffListFilesRecursively(const char* path, bool pretty)
 const char* ffGetTerminalResponse(const char* request, const char* format, ...)
 {
    HANDLE hInput = GetStdHandle(STD_INPUT_HANDLE);
-    DWORD prev_mode;
-    GetConsoleMode(hInput, &prev_mode);
+    FF_AUTO_CLOSE_FD HANDLE hConin = INVALID_HANDLE_VALUE;
+    DWORD inputMode;
+    if (!GetConsoleMode(hInput, &inputMode))
+    {
+        hConin = CreateFileW(L"CONIN$", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, NULL);
+        hInput = hConin;
+    }
    SetConsoleMode(hInput, 0);

    FlushConsoleInputBuffer(hInput);

-    DWORD bytes = 0;
-    WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), request, (DWORD) strlen(request), &bytes, NULL);
+    {
+        DWORD bytes = 0;
+        HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
+        FF_AUTO_CLOSE_FD HANDLE hConout = INVALID_HANDLE_VALUE;
+        DWORD outputMode;
+        if (!GetConsoleMode(hOutput, &outputMode))
+        {
+            hConout = CreateFileW(L"CONOUT$", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, NULL);
+            hOutput = hConout;
+        }
+        WriteFile(hOutput, request, (DWORD) strlen(request), &bytes, NULL);
+    }

    while (true)
    {
        if (WaitForSingleObjectEx(hInput, FF_IO_TERM_RESP_WAIT_MS, TRUE) != WAIT_OBJECT_0)
        {
-            SetConsoleMode(hInput, prev_mode);
+            SetConsoleMode(hInput, inputMode);
            return "WaitForSingleObject() failed or timeout";
        }

@@ -209,10 +257,10 @@ const char* ffGetTerminalResponse(const char* request, const char* format, ...)
    }

    char buffer[512];
-    bytes = 0;
+    DWORD bytes = 0;
    ReadFile(hInput, buffer, sizeof(buffer) - 1, &bytes, NULL);

-    SetConsoleMode(hInput, prev_mode);
+    SetConsoleMode(hInput, inputMode);

    if(bytes <= 0)
        return "ReadFile() failed";
@@ -1,4 +1,5 @@
 #include "fastfetch.h"
+#include "common/color.h"
 #include "common/jsonconfig.h"
 #include "common/printing.h"
 #include "common/io/io.h"
@@ -22,6 +23,11 @@ bool ffJsonConfigParseModuleArgs(const char* key, yyjson_val* val, FFModuleArgs*
        ffStrbufSetNS(&moduleArgs->outputFormat, (uint32_t) yyjson_get_len(val), yyjson_get_str(val));
        return true;
    }
+    else if(ffStrEqualsIgnCase(key, "outputColor"))
+    {
+        ffOptionParseColor(yyjson_get_str(val), &moduleArgs->outputColor);
+        return true;
+    }
    else if(ffStrEqualsIgnCase(key, "keyColor"))
    {
        ffOptionParseColor(yyjson_get_str(val), &moduleArgs->keyColor);
@@ -32,6 +38,11 @@ bool ffJsonConfigParseModuleArgs(const char* key, yyjson_val* val, FFModuleArgs*
        moduleArgs->keyWidth = (uint32_t) yyjson_get_uint(val);
        return true;
    }
+    else if(ffStrEqualsIgnCase(key, "keyIcon"))
+    {
+        ffStrbufSetS(&moduleArgs->keyIcon, yyjson_get_str(val));
+        return true;
+    }
    return false;
 }

@@ -45,6 +56,8 @@ void ffJsonConfigGenerateModuleArgsConfig(yyjson_mut_doc* doc, yyjson_mut_val* m
        yyjson_mut_obj_add_strbuf(doc, module, "keyColor", &moduleArgs->keyColor);
    if (moduleArgs->keyWidth != defaultModuleArgs->keyWidth)
        yyjson_mut_obj_add_uint(doc, module, "keyWidth", moduleArgs->keyWidth);
+    if (!ffStrbufEqual(&defaultModuleArgs->keyIcon, &moduleArgs->keyIcon))
+        yyjson_mut_obj_add_strbuf(doc, module, "keyIcon", &moduleArgs->keyIcon);
 }

 const char* ffJsonConfigParseEnum(yyjson_val* val, int* result, FFKeyValuePair pairs[])
@@ -94,7 +107,7 @@ static inline void genJsonResult(FFModuleBaseInfo* baseInfo, yyjson_mut_doc* doc

 static bool parseModuleJsonObject(const char* type, yyjson_val* jsonVal, yyjson_mut_doc* jsonDoc)
 {
-    if(!isalpha(type[0])) return false;
+    if(!ffCharIsEnglishAlphabet(type[0])) return false;

    for (FFModuleBaseInfo** modules = ffModuleInfos[toupper(type[0]) - 'A']; *modules; ++modules)
    {
@@ -169,12 +182,13 @@ 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";

+    int32_t thres = instance.config.display.stat;
    yyjson_val* item;
    size_t idx, max;
    yyjson_arr_foreach(modules, idx, max, item)
    {
-        uint64_t ms = 0;
-        if(!prepare && instance.config.display.stat)
+        double ms = 0;
+        if(!prepare && thres >= 0)
            ms = ffTimeGetTick();

        yyjson_val* module = item;
@@ -196,22 +210,21 @@ static const char* printJsonConfig(bool prepare, yyjson_mut_doc* jsonDoc)
        else if(!parseModuleJsonObject(type, module, jsonDoc))
            return "Unknown module type";

-        if(!prepare && instance.config.display.stat)
+        if(!prepare && thres >= 0)
        {
            ms = ffTimeGetTick() - ms;
            if (jsonDoc)
            {
                yyjson_mut_val* moduleJson = yyjson_mut_arr_get_last(jsonDoc->root);
-                yyjson_mut_obj_add_uint(jsonDoc, moduleJson, "stat", ms);
+                yyjson_mut_obj_add_real(jsonDoc, moduleJson, "stat", ms);
            }
            else
            {
-                char str[32];
-                int len = snprintf(str, sizeof str, "%" PRIu64 "ms", ms);
-                if(instance.config.display.pipe)
-                    puts(str);
-                else
-                    printf("\033[s\033[1A\033[9999999C\033[%dD%s\033[u", len, str); // Save; Up 1; Right 9999999; Left <len>; Print <str>; Load
+                char str[64];
+                int len = snprintf(str, sizeof str, "%.3fms", ms);
+                if (thres > 0)
+                    snprintf(str, sizeof str, "\e[%sm%.3fms\e[m", (ms <= thres ? FF_COLOR_FG_GREEN : ms <= 2 * thres ? FF_COLOR_FG_YELLOW : FF_COLOR_FG_RED), ms);
+                printf("\e[s\e[1A\e[9999999C\e[%dD%s\e[u", len, str); // Save; Up 1; Right 9999999; Left <len>; Print <str>; Load
            }
        }

@@ -235,6 +248,6 @@ void ffPrintJsonConfig(bool prepare, yyjson_mut_doc* jsonDoc)
            yyjson_mut_doc_set_root(jsonDoc, obj);
        }
        else
-            ffPrintErrorString("JsonConfig", 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "%s", error);
+            ffPrintError("JsonConfig", 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "%s", error);
    }
 }
@@ -1,10 +1,12 @@
 #include "fastfetch.h"
 #include "common/library.h"

+#ifndef FF_DISABLE_DLOPEN
+
 #include <stdarg.h>

 //Clang doesn't define __SANITIZE_ADDRESS__ but defines __has_feature(address_sanitizer)
-#if defined(__has_feature)
+#if !defined(__SANITIZE_ADDRESS__) && defined(__has_feature)
    #if __has_feature(address_sanitizer)
        #define __SANITIZE_ADDRESS__
    #endif
@@ -77,3 +79,5 @@ void* ffLibraryLoad(const FFstrbuf* userProvidedName, ...)

    return result;
 }
+
+#endif
@@ -3,6 +3,8 @@
 #include "fastfetch.h"
 #include "util/FFcheckmacros.h"

+#ifndef FF_DISABLE_DLOPEN
+
 #if defined(_WIN32)
    #include <libloaderapi.h>
    #define FF_DLOPEN_FLAGS 0
@@ -71,3 +73,45 @@ static inline void ffLibraryUnload(void** handle)
    FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, (varName)->ff ## symbolName, symbolName, returnValue);

 void* ffLibraryLoad(const FFstrbuf* userProvidedName, ...);
+
+#else
+
+#define FF_LIBRARY_EXTENSION ""
+
+#define FF_LIBRARY_SYMBOL(symbolName) \
+    __typeof__(&symbolName) ff ## symbolName;
+
+#define FF_LIBRARY_LOAD(libraryObjectName, userLibraryName, returnValue, ...) \
+    FF_MAYBE_UNUSED void* libraryObjectName = NULL; // Placeholder
+
+#define FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, symbolMapping, symbolName, returnValue) \
+    symbolMapping = (__typeof__(&symbolName)) &symbolName
+
+#define FF_LIBRARY_LOAD_SYMBOL_ADDRESS2(library, symbolMapping, symbolName, alternateName, returnValue) \
+    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);
+
+#define FF_LIBRARY_LOAD_SYMBOL_LAZY(library, symbolName) \
+    FF_MAYBE_UNUSED __typeof__(&symbolName) ff ## symbolName = (__typeof__(&symbolName)) &symbolName;
+
+#define FF_LIBRARY_LOAD_SYMBOL_MESSAGE(library, symbolName) \
+    FF_MAYBE_UNUSED __typeof__(&symbolName) FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, ff ## symbolName, symbolName, "dlsym " #symbolName " failed");
+
+#define FF_LIBRARY_LOAD_SYMBOL_MESSAGE2(library, symbolName, alternateName) \
+    FF_MAYBE_UNUSED __typeof__(&symbolName) FF_LIBRARY_LOAD_SYMBOL_ADDRESS2(library, ff ## symbolName, symbolName, alternateName, "dlsym " #symbolName " failed");
+
+#define FF_LIBRARY_LOAD_SYMBOL_VAR(library, varName, symbolName, returnValue) \
+    FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, (varName).ff ## symbolName, symbolName, returnValue);
+
+#define FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(library, varName, symbolName) \
+    FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, (varName).ff ## symbolName, symbolName, "dlsym " #symbolName " failed");
+
+#define FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE2(library, varName, symbolName, alternateName) \
+    FF_LIBRARY_LOAD_SYMBOL_ADDRESS2(library, (varName).ff ## symbolName, symbolName, alternateName, "dlsym " #symbolName " failed");
+
+#define FF_LIBRARY_LOAD_SYMBOL_PTR(library, varName, symbolName, returnValue) \
+    FF_LIBRARY_LOAD_SYMBOL_ADDRESS(library, (varName)->ff ## symbolName, symbolName, returnValue);
+
+#endif
@@ -8,7 +8,9 @@ static FFModuleBaseInfo* B[] = {
    (void*) &instance.config.modules.battery,
    (void*) &instance.config.modules.bios,
    (void*) &instance.config.modules.bluetooth,
+    (void*) &instance.config.modules.bluetoothRadio,
    (void*) &instance.config.modules.board,
+    (void*) &instance.config.modules.bootmgr,
    (void*) &instance.config.modules.break_,
    (void*) &instance.config.modules.brightness,
    NULL,
@@ -20,6 +22,7 @@ static FFModuleBaseInfo* C[] = {
    (void*) &instance.config.modules.command,
    (void*) &instance.config.modules.colors,
    (void*) &instance.config.modules.cpu,
+    (void*) &instance.config.modules.cpuCache,
    (void*) &instance.config.modules.cpuUsage,
    (void*) &instance.config.modules.cursor,
    (void*) &instance.config.modules.custom,
@@ -32,10 +35,12 @@ static FFModuleBaseInfo* D[] = {
    (void*) &instance.config.modules.display,
    (void*) &instance.config.modules.disk,
    (void*) &instance.config.modules.diskIo,
+    (void*) &instance.config.modules.dns,
    NULL,
 };

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

@@ -57,6 +62,7 @@ static FFModuleBaseInfo* H[] = {

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

@@ -71,6 +77,7 @@ static FFModuleBaseInfo* K[] = {

 static FFModuleBaseInfo* L[] = {
    (void*) &instance.config.modules.lm,
+    (void*) &instance.config.modules.loadavg,
    (void*) &instance.config.modules.locale,
    (void*) &instance.config.modules.localIP,
    NULL,
@@ -98,6 +105,7 @@ static FFModuleBaseInfo* O[] = {
 static FFModuleBaseInfo* P[] = {
    (void*) &instance.config.modules.packages,
    (void*) &instance.config.modules.physicalDisk,
+    (void*) &instance.config.modules.physicalMemory,
    (void*) &instance.config.modules.player,
    (void*) &instance.config.modules.powerAdapter,
    (void*) &instance.config.modules.processes,
@@ -161,6 +169,7 @@ static FFModuleBaseInfo* Y[] = {
 };

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

@@ -18,6 +18,8 @@
 # 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)
 #else
 # error unknown platform
 #endif
@@ -31,9 +33,13 @@ get_rt_address(struct rt_msghdr *rtm, int desired)
    {
        if (rtm->rtm_addrs & (1 << i))
        {
-            if ((1 <<i ) == 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;
@@ -71,7 +77,9 @@ bool ffNetifGetDefaultRouteImpl(char iface[IF_NAMESIZE + 1], uint32_t* ifIndex)
        },
        .dst = {
            .sin_family = AF_INET,
+            #ifndef __sun
            .sin_len = sizeof(rtmsg.dst),
+            #endif
        },
    };

@@ -20,15 +20,10 @@ typedef struct FFNetworkingState {
            FFThreadType thread;
        #endif
    #endif
+
+    uint32_t timeout;
+    bool ipv6;
 } FFNetworkingState;

-bool ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, const char* path, const char* headers);
-bool ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer, uint32_t timeout);
-
-static inline bool ffNetworkingGetHttp(const char* host, const char* path, uint32_t timeout, const char* headers, FFstrbuf* buffer)
-{
-    FFNetworkingState state;
-    if(ffNetworkingSendHttpRequest(&state, host, path, headers))
-        return ffNetworkingRecvHttpResponse(&state, buffer, timeout);
-    return false;
-}
+const char* ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, const char* path, const char* headers);
+const char* ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer);
@@ -5,30 +5,50 @@
 #include <sys/time.h>
 #include <sys/socket.h>
 #include <netdb.h>
+#include <netinet/in.h> // For FreeBSD
+#include <netinet/tcp.h>

-static void connectAndSend(FFNetworkingState* state)
+static const char* connectAndSend(FFNetworkingState* state)
 {
-    struct addrinfo hints = {
-        .ai_family = AF_INET,
-        .ai_socktype = SOCK_STREAM,
-    };
-
+    const char* ret = NULL;
    struct addrinfo* addr;

-    if(getaddrinfo(state->host.chars, "80", &hints, &addr) != 0)
+    if(getaddrinfo(state->host.chars, "80", &(struct addrinfo) {
+        .ai_family = state->ipv6 ? AF_INET6 : AF_INET,
+        .ai_socktype = SOCK_STREAM,
+    }, &addr) != 0)
+    {
+        ret = "getaddrinfo() failed";
        goto error;
+    }

    state->sockfd = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
    if(state->sockfd == -1)
    {
        freeaddrinfo(addr);
+        ret = "socket() failed";
        goto error;
    }

+    if (state->timeout > 0)
+    {
+        FF_MAYBE_UNUSED uint32_t sec = state->timeout / 1000;
+        if (sec == 0) sec = 1;
+
+        #ifdef TCP_CONNECTIONTIMEOUT
+        setsockopt(state->sockfd, IPPROTO_TCP, TCP_CONNECTIONTIMEOUT, &sec, sizeof(sec));
+        #elif defined(TCP_KEEPINIT)
+        setsockopt(state->sockfd, IPPROTO_TCP, TCP_KEEPINIT, &sec, sizeof(sec));
+        #elif defined(TCP_USER_TIMEOUT)
+        setsockopt(state->sockfd, IPPROTO_TCP, TCP_USER_TIMEOUT, &state->timeout, sizeof(state->timeout));
+        #endif
+    }
+
    if(connect(state->sockfd, addr->ai_addr, addr->ai_addrlen) == -1)
    {
        close(state->sockfd);
        freeaddrinfo(addr);
+        ret = "connect() failed";
        goto error;
    }

@@ -37,6 +57,7 @@ static void connectAndSend(FFNetworkingState* state)
    if(send(state->sockfd, state->command.chars, state->command.length, 0) < 0)
    {
        close(state->sockfd);
+        ret = "send() failed";
        goto error;
    }

@@ -48,11 +69,13 @@ error:
 exit:
    ffStrbufDestroy(&state->host);
    ffStrbufDestroy(&state->command);
+
+    return ret;
 }

 FF_THREAD_ENTRY_DECL_WRAPPER(connectAndSend, FFNetworkingState*);

-bool ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, const char* path, const char* headers)
+const char* ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, const char* path, const char* headers)
 {
    ffStrbufInitS(&state->host, host);

@@ -66,22 +89,30 @@ bool ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, con
    ffStrbufAppendS(&state->command, "\r\n");

    #ifdef FF_HAVE_THREADS
+    if (instance.config.general.multithreading)
+    {
        state->thread = ffThreadCreate(connectAndSendThreadMain, state);
-        return !!state->thread;
-    #else
-        connectAndSend(state);
-        return state->sockfd != -1;
+        return state->thread ? NULL : "ffThreadCreate(connectAndSend) failed";
+    }
    #endif
+
+    return connectAndSend(state);
 }

-bool ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer, uint32_t timeout)
+const char* ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer)
 {
+    uint32_t timeout = state->timeout;
+
    #ifdef FF_HAVE_THREADS
+    if (instance.config.general.multithreading)
+    {
        if (!ffThreadJoin(state->thread, timeout))
-            return false;
+            return "ffThreadJoin() failed or timeout";
+    }
    #endif
+
    if(state->sockfd == -1)
-        return false;
+        return "ffNetworkingSendHttpRequest() failed";

    if(timeout > 0)
    {
@@ -91,14 +122,15 @@ bool ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer, ui
        setsockopt(state->sockfd, SOL_SOCKET, SO_RCVTIMEO, &timev, sizeof(timev));
    }

-    ssize_t received = recv(state->sockfd, buffer->chars + buffer->length, ffStrbufGetFree(buffer), 0);
-
-    if(received > 0)
-    {
+    uint32_t recvStart;
+    do {
+        recvStart = buffer->length;
+        ssize_t received = recv(state->sockfd, buffer->chars + buffer->length, ffStrbufGetFree(buffer), 0);
+        if (received <= 0) break;
        buffer->length += (uint32_t) received;
        buffer->chars[buffer->length] = '\0';
-    }
+    } while (ffStrbufGetFree(buffer) > 0 && strstr(buffer->chars + recvStart, "\r\n\r\n") == NULL);

    close(state->sockfd);
-    return ffStrbufStartsWithS(buffer, "HTTP/1.1 200 OK\r\n");
+    return ffStrbufStartsWithS(buffer, "HTTP/1.1 200 OK\r\n") ? NULL : "Invalid response";
 }
@@ -33,48 +33,48 @@ static const char* initWsaData(WSADATA* wsaData)
    return NULL;
 }

-bool ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, const char* path, const char* headers)
+const char* ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, const char* path, const char* headers)
 {
    static WSADATA wsaData;
    if (wsaData.wVersion == 0)
    {
-        if (initWsaData(&wsaData) != NULL)
+        const char* error = initWsaData(&wsaData);
+        if (error != NULL)
        {
            wsaData.wVersion = (WORD) -1;
-            return false;
+            return error;
        }
    }
    else if (wsaData.wVersion == (WORD) -1)
-        return false;
-
-    memset(state, 0, sizeof(*state));
+        return "initWsaData() failed before";

    struct addrinfo* addr;

    if(getaddrinfo(host, "80", &(struct addrinfo) {
-        .ai_family = AF_INET,
+        .ai_family = state->ipv6 ? AF_INET6 : AF_INET,
        .ai_socktype = SOCK_STREAM,
    }, &addr) != 0)
-        return false;
+        return "getaddrinfo() failed";

    state->sockfd = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
    if(state->sockfd == INVALID_SOCKET)
    {
        freeaddrinfo(addr);
-        return false;
+        return "socket() failed";
    }

    {
        //ConnectEx requires the socket to be initially bound
-        struct sockaddr_in addr = {
+        if(bind(state->sockfd, (SOCKADDR *) &(struct sockaddr_in) {
            .sin_family = AF_INET,
            .sin_addr.s_addr = INADDR_ANY,
            .sin_port = 0,
-        };
-        if(bind(state->sockfd, (SOCKADDR *)&addr, sizeof(addr)) != 0)
+        }, sizeof(struct sockaddr_in)) != 0)
        {
-            printf("bind %d\n", WSAGetLastError());
-            return false;
+            closesocket(state->sockfd);
+            freeaddrinfo(addr);
+            state->sockfd = INVALID_SOCKET;
+            return "bind() failed";
        }
    }

@@ -93,35 +93,52 @@ bool ffNetworkingSendHttpRequest(FFNetworkingState* state, const char* host, con
    if(!result && WSAGetLastError() != WSA_IO_PENDING)
    {
        closesocket(state->sockfd);
-        return false;
+        freeaddrinfo(addr);
+        state->sockfd = INVALID_SOCKET;
+        return "ConnectEx() failed";
    }

-    return true;
+    return NULL;
 }

-bool ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer, uint32_t timeout)
+const char* ffNetworkingRecvHttpResponse(FFNetworkingState* state, FFstrbuf* buffer)
 {
+    if (state->sockfd == INVALID_SOCKET)
+        return "ffNetworkingSendHttpRequest() failed";
+
+    uint32_t timeout = state->timeout;
+    if (timeout > 0)
+    {
+        if (WaitForSingleObject((HANDLE) state->sockfd, timeout) != WAIT_OBJECT_0)
+        {
+            CancelIo((HANDLE) state->sockfd);
+            closesocket(state->sockfd);
+            return "WaitForSingleObject(state->sockfd) failed or timeout";
+        }
+    }
+
    DWORD transfer, flags;
    if (!WSAGetOverlappedResult(state->sockfd, &state->overlapped, &transfer, TRUE, &flags))
    {
        closesocket(state->sockfd);
-        return false;
+        return "WSAGetOverlappedResult() failed";
    }

    if(timeout > 0)
    {
        //https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-setsockopt
-        setsockopt(state->sockfd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeout, sizeof(timeout));
+        setsockopt(state->sockfd, SOL_SOCKET, SO_RCVTIMEO, (const char*) &timeout, sizeof(timeout));
    }

-    ssize_t received = recv(state->sockfd, buffer->chars + buffer->length, (int)ffStrbufGetFree(buffer), 0);
-
-    if(received > 0)
-    {
-        buffer->length += (uint32_t) received;
+    uint32_t recvStart;
+    do {
+        recvStart = buffer->length;
+        ssize_t received = recv(state->sockfd, buffer->chars + buffer->length, (int) ffStrbufGetFree(buffer), 0);
+        if (received <= 0) break;
+        buffer->length = recvStart + (uint32_t) received;
        buffer->chars[buffer->length] = '\0';
-    }
+    } while (ffStrbufGetFree(buffer) > 0 && strstr(buffer->chars + recvStart, "\r\n\r\n") == NULL);

    closesocket(state->sockfd);
-    return ffStrbufStartsWithS(buffer, "HTTP/1.1 200 OK\r\n");
+    return ffStrbufStartsWithS(buffer, "HTTP/1.1 200 OK\r\n") ? NULL : "Invalid response";
 }
@@ -1,3 +1,4 @@
+#include "fastfetch.h"
 #include "common/option.h"
 #include "common/color.h"
 #include "util/stringUtils.h"
@@ -39,20 +40,39 @@ bool ffOptionParseModuleArgs(const char* argumentKey, const char* subKey, const
        ffOptionParseString(argumentKey, value, &result->outputFormat);
        return true;
    }
-    else if(ffStrEqualsIgnCase(subKey, "key-color"))
+    else if(ffStrEqualsIgnCase(subKey, "output-color"))
    {
        if(value == NULL)
        {
            fprintf(stderr, "Error: usage: %s <str>\n", argumentKey);
            exit(477);
        }
-        ffOptionParseColor(value, &result->keyColor);
+        ffOptionParseColor(value, &result->outputColor);
        return true;
    }
-    else if(ffStrEqualsIgnCase(subKey, "key-width"))
+    else if(ffStrStartsWithIgnCase(subKey, "key-"))
    {
-        result->keyWidth = ffOptionParseUInt32(argumentKey, value);
-        return true;
+        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;
 }
@@ -135,57 +155,67 @@ bool ffOptionParseBoolean(const char* str)
    );
 }

-void ffOptionParseColor(const char* value, FFstrbuf* buffer)
+void ffOptionParseColorNoClear(const char* value, FFstrbuf* buffer)
 {
-    ffStrbufClear(buffer);
+    // If value is already an ANSI escape code, use it
+    if (value[0] == '\e' && value[1] == '[')
+    {
+        ffStrbufAppendS(buffer, value + 2);
+        ffStrbufTrimRight(buffer, 'm');
+        return;
+    }
+
    ffStrbufEnsureFree(buffer, 63);

    while(*value != '\0')
    {
        #define FF_APPEND_COLOR_CODE_COND(prefix, code) \
-            if(ffStrStartsWithIgnCase(value, #prefix)) { ffStrbufAppendS(buffer, code); value += strlen(#prefix); }
+            if(ffStrStartsWithIgnCase(value, #prefix)) { ffStrbufAppendS(buffer, code); value += strlen(#prefix); continue; }
+        #define FF_APPEND_COLOR_PROP_COND(prefix, prop) \
+            if(ffStrStartsWithIgnCase(value, #prefix)) { if (instance.config.display.prop.length) ffStrbufAppend(buffer, &instance.config.display.prop); else ffStrbufAppendS(buffer, FF_COLOR_FG_DEFAULT); value += strlen(#prefix); continue; }

-        FF_APPEND_COLOR_CODE_COND(reset_, FF_COLOR_MODE_RESET)
-        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(black, FF_COLOR_FG_BLACK)
-        else FF_APPEND_COLOR_CODE_COND(red, FF_COLOR_FG_RED)
-        else FF_APPEND_COLOR_CODE_COND(green, FF_COLOR_FG_GREEN)
-        else FF_APPEND_COLOR_CODE_COND(yellow, FF_COLOR_FG_YELLOW)
-        else FF_APPEND_COLOR_CODE_COND(blue, FF_COLOR_FG_BLUE)
-        else FF_APPEND_COLOR_CODE_COND(magenta, FF_COLOR_FG_MAGENTA)
-        else FF_APPEND_COLOR_CODE_COND(cyan, FF_COLOR_FG_CYAN)
-        else FF_APPEND_COLOR_CODE_COND(white, FF_COLOR_FG_WHITE)
-        else FF_APPEND_COLOR_CODE_COND(default, FF_COLOR_FG_DEFAULT)
-        else FF_APPEND_COLOR_CODE_COND(light_black, FF_COLOR_FG_LIGHT_BLACK)
-        else FF_APPEND_COLOR_CODE_COND(light_red, FF_COLOR_FG_LIGHT_RED)
-        else FF_APPEND_COLOR_CODE_COND(light_green, FF_COLOR_FG_LIGHT_GREEN)
-        else FF_APPEND_COLOR_CODE_COND(light_yellow, FF_COLOR_FG_LIGHT_YELLOW)
-        else FF_APPEND_COLOR_CODE_COND(light_blue, FF_COLOR_FG_LIGHT_BLUE)
-        else FF_APPEND_COLOR_CODE_COND(light_magenta, FF_COLOR_FG_LIGHT_MAGENTA)
-        else FF_APPEND_COLOR_CODE_COND(light_cyan, FF_COLOR_FG_LIGHT_CYAN)
-        else FF_APPEND_COLOR_CODE_COND(light_white, FF_COLOR_FG_LIGHT_WHITE)
-        else
+        if (ffCharIsEnglishAlphabet(value[0]))
        {
-            ffStrbufAppendC(buffer, *value);
-            ++value;
+            FF_APPEND_COLOR_CODE_COND(reset_, FF_COLOR_MODE_RESET)
+            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)
+            else FF_APPEND_COLOR_CODE_COND(underline_, FF_COLOR_MODE_UNDERLINE)
+            else FF_APPEND_COLOR_CODE_COND(blink_, FF_COLOR_MODE_BLINK)
+            else FF_APPEND_COLOR_CODE_COND(inverse_, FF_COLOR_MODE_INVERSE)
+            else FF_APPEND_COLOR_CODE_COND(hidden_, FF_COLOR_MODE_HIDDEN)
+            else FF_APPEND_COLOR_CODE_COND(strike_, FF_COLOR_MODE_STRIKETHROUGH)
+            else FF_APPEND_COLOR_CODE_COND(black, FF_COLOR_FG_BLACK)
+            else FF_APPEND_COLOR_CODE_COND(red, FF_COLOR_FG_RED)
+            else FF_APPEND_COLOR_CODE_COND(green, FF_COLOR_FG_GREEN)
+            else FF_APPEND_COLOR_CODE_COND(yellow, FF_COLOR_FG_YELLOW)
+            else FF_APPEND_COLOR_CODE_COND(blue, FF_COLOR_FG_BLUE)
+            else FF_APPEND_COLOR_CODE_COND(magenta, FF_COLOR_FG_MAGENTA)
+            else FF_APPEND_COLOR_CODE_COND(cyan, FF_COLOR_FG_CYAN)
+            else FF_APPEND_COLOR_CODE_COND(white, FF_COLOR_FG_WHITE)
+            else FF_APPEND_COLOR_CODE_COND(default, FF_COLOR_FG_DEFAULT)
+            else FF_APPEND_COLOR_CODE_COND(light_black, FF_COLOR_FG_LIGHT_BLACK)
+            else FF_APPEND_COLOR_CODE_COND(light_red, FF_COLOR_FG_LIGHT_RED)
+            else FF_APPEND_COLOR_CODE_COND(light_green, FF_COLOR_FG_LIGHT_GREEN)
+            else FF_APPEND_COLOR_CODE_COND(light_yellow, FF_COLOR_FG_LIGHT_YELLOW)
+            else FF_APPEND_COLOR_CODE_COND(light_blue, FF_COLOR_FG_LIGHT_BLUE)
+            else FF_APPEND_COLOR_CODE_COND(light_magenta, FF_COLOR_FG_LIGHT_MAGENTA)
+            else FF_APPEND_COLOR_CODE_COND(light_cyan, FF_COLOR_FG_LIGHT_CYAN)
+            else FF_APPEND_COLOR_CODE_COND(light_white, FF_COLOR_FG_LIGHT_WHITE)
+            else FF_APPEND_COLOR_PROP_COND(keys, colorKeys)
+            else FF_APPEND_COLOR_PROP_COND(title, colorTitle)
+            else FF_APPEND_COLOR_PROP_COND(output, colorOutput)
+            else FF_APPEND_COLOR_PROP_COND(separator, colorSeparator)
+            else
+            {
+                fprintf(stderr, "Error: invalid color code found: %s\n", value);
+                exit(479);
+            }
        }
+        ffStrbufAppendC(buffer, *value);
+        ++value;

        #undef FF_APPEND_COLOR_CODE_COND
+        #undef FF_APPEND_COLOR_PROP_COND
    }
 }
-
-void ffOptionInitModuleArg(FFModuleArgs* args)
-{
-    ffStrbufInit(&args->key);
-    ffStrbufInit(&args->keyColor);
-    ffStrbufInit(&args->outputFormat);
-    args->keyWidth = 0;
-}
-
-void ffOptionDestroyModuleArg(FFModuleArgs* args)
-{
-    ffStrbufDestroy(&args->key);
-    ffStrbufDestroy(&args->keyColor);
-    ffStrbufDestroy(&args->outputFormat);
-}
@@ -45,11 +45,21 @@ static inline void ffOptionInitModuleBaseInfo(
    baseInfo->generateJsonConfig = (__typeof__(baseInfo->generateJsonConfig)) generateJsonConfig;
 }

+typedef enum FFModuleKeyType
+{
+    FF_MODULE_KEY_TYPE_NONE = 0,
+    FF_MODULE_KEY_TYPE_STRING = 1 << 0,
+    FF_MODULE_KEY_TYPE_ICON = 1 << 1,
+    FF_MODULE_KEY_TYPE_BOTH = FF_MODULE_KEY_TYPE_STRING | FF_MODULE_KEY_TYPE_ICON,
+} FFModuleKeyType;
+
 typedef struct FFModuleArgs
 {
    FFstrbuf key;
    FFstrbuf keyColor;
+    FFstrbuf keyIcon;
    FFstrbuf outputFormat;
+    FFstrbuf outputColor;
    uint32_t keyWidth;
 } FFModuleArgs;

@@ -66,6 +76,28 @@ FF_C_NODISCARD uint32_t ffOptionParseUInt32(const char* argumentKey, const char*
 FF_C_NODISCARD int32_t ffOptionParseInt32(const char* argumentKey, const char* value);
 FF_C_NODISCARD int ffOptionParseEnum(const char* argumentKey, const char* requestedKey, FFKeyValuePair pairs[]);
 FF_C_NODISCARD bool ffOptionParseBoolean(const char* str);
-void ffOptionParseColor(const char* value, FFstrbuf* buffer);
-void ffOptionInitModuleArg(FFModuleArgs* args);
-void ffOptionDestroyModuleArg(FFModuleArgs* args);
+void ffOptionParseColorNoClear(const char* value, FFstrbuf* buffer);
+static inline void ffOptionParseColor(const char* value, FFstrbuf* buffer)
+{
+    ffStrbufClear(buffer);
+    ffOptionParseColorNoClear(value, buffer);
+}
+
+static inline void ffOptionInitModuleArg(FFModuleArgs* args, const char* icon)
+{
+    ffStrbufInit(&args->key);
+    ffStrbufInit(&args->keyColor);
+    ffStrbufInitStatic(&args->keyIcon, icon);
+    ffStrbufInit(&args->outputFormat);
+    ffStrbufInit(&args->outputColor);
+    args->keyWidth = 0;
+}
+
+static inline void ffOptionDestroyModuleArg(FFModuleArgs* args)
+{
+    ffStrbufDestroy(&args->key);
+    ffStrbufDestroy(&args->keyColor);
+    ffStrbufDestroy(&args->keyIcon);
+    ffStrbufDestroy(&args->outputFormat);
+    ffStrbufDestroy(&args->outputColor);
+}
@@ -79,15 +79,15 @@ static void parseSize(FFstrbuf* result, uint64_t bytes, uint32_t base, const cha

 void ffParseSize(uint64_t bytes, FFstrbuf* result)
 {
-    switch (instance.config.display.binaryPrefixType)
+    switch (instance.config.display.sizeBinaryPrefix)
    {
-        case FF_BINARY_PREFIX_TYPE_IEC:
+        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_BINARY_PREFIX_TYPE_SI:
+        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_BINARY_PREFIX_TYPE_JEDEC:
+        case FF_SIZE_BINARY_PREFIX_TYPE_JEDEC:
            parseSize(result, bytes, 1024, (const char*[]) {"B", "KB", "MB", "GB", "TB", NULL});
            break;
        default:
@@ -96,23 +96,37 @@ void ffParseSize(uint64_t bytes, FFstrbuf* result)
    }
 }

+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)
 {
    if(gtk2->length > 0 && gtk3->length > 0 && gtk4->length > 0)
    {
-        if((ffStrbufIgnCaseComp(gtk2, gtk3) == 0) && (ffStrbufIgnCaseComp(gtk2, gtk4) == 0))
+        if((ffStrbufIgnCaseEqual(gtk2, gtk3)) && (ffStrbufIgnCaseEqual(gtk2, gtk4)))
        {
            ffStrbufAppend(buffer, gtk4);
            ffStrbufAppendS(buffer, " [GTK2/3/4]");
        }
-        else if(ffStrbufIgnCaseComp(gtk2, gtk3) == 0)
+        else if(ffStrbufIgnCaseEqual(gtk2, gtk3))
        {
            ffStrbufAppend(buffer, gtk3);
            ffStrbufAppendS(buffer, " [GTK2/3], ");
            ffStrbufAppend(buffer, gtk4);
            ffStrbufAppendS(buffer, " [GTK4]");
        }
-        else if(ffStrbufIgnCaseComp(gtk3, gtk4) == 0)
+        else if(ffStrbufIgnCaseEqual(gtk3, gtk4))
        {
            ffStrbufAppend(buffer, gtk2);
            ffStrbufAppendS(buffer, " [GTK2], ");
@@ -131,7 +145,7 @@ void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, co
    }
    else if(gtk2->length > 0 && gtk3->length > 0)
    {
-        if(ffStrbufIgnCaseComp(gtk2, gtk3) == 0)
+        if(ffStrbufIgnCaseEqual(gtk2, gtk3))
        {
            ffStrbufAppend(buffer, gtk3);
            ffStrbufAppendS(buffer, " [GTK2/3]");
@@ -146,7 +160,7 @@ void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, co
    }
    else if(gtk3->length > 0 && gtk4->length > 0)
    {
-        if(ffStrbufIgnCaseComp(gtk3, gtk4) == 0)
+        if(ffStrbufIgnCaseEqual(gtk3, gtk4))
        {
            ffStrbufAppend(buffer, gtk4);
            ffStrbufAppendS(buffer, " [GTK3/4]");
@@ -26,3 +26,4 @@ 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);
@@ -6,7 +6,15 @@
 #include "util/textModifier.h"
 #include "util/stringUtils.h"

-void ffPercentAppendBar(FFstrbuf* buffer, double percent, FFColorRangeConfig config)
+static void appendOutputColor(FFstrbuf* buffer, const FFModuleArgs* module)
+{
+    if (module->outputColor.length)
+        ffStrbufAppendF(buffer, "\e[%sm", module->outputColor.chars);
+    else if (instance.config.display.colorOutput.length)
+        ffStrbufAppendF(buffer, "\e[%sm", instance.config.display.colorOutput.chars);
+}
+
+void ffPercentAppendBar(FFstrbuf* buffer, double percent, FFColorRangeConfig config, const FFModuleArgs* module)
 {
    uint8_t green = config.green, yellow = config.yellow;
    assert(green <= 100 && yellow <= 100);
@@ -16,12 +24,11 @@ void ffPercentAppendBar(FFstrbuf* buffer, double percent, FFColorRangeConfig con
    uint32_t blocksPercent = (uint32_t) (percent / 100.0 * options->barWidth + 0.5);
    assert(blocksPercent <= options->barWidth);

-    if(options->barBorder)
+    if(options->barBorderLeft.length)
    {
        if(!options->pipe)
-            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m[ ");
-        else
-            ffStrbufAppendS(buffer, "[ ");
+            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m");
+        ffStrbufAppend(buffer, &options->barBorderLeft);
    }

    if (percent != percent)
@@ -42,14 +49,34 @@ void ffPercentAppendBar(FFstrbuf* buffer, double percent, FFColorRangeConfig con
        {
            if(!options->pipe)
            {
-                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 (options->percentType & FF_PERCENTAGE_TYPE_BAR_MONOCHROME_BIT)
+                {
+                    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));
+                }
            }
            ffStrbufAppend(buffer, &options->barCharElapsed);
        }
@@ -63,19 +90,21 @@ void ffPercentAppendBar(FFstrbuf* buffer, double percent, FFColorRangeConfig con
        }
    }

-    if(options->barBorder)
+    if(options->barBorderRight.length)
    {
        if(!options->pipe)
-            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m ]");
-        else
-            ffStrbufAppendS(buffer, " ]");
+            ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m");
+        ffStrbufAppend(buffer, &options->barBorderRight);
    }

    if(!options->pipe)
+    {
        ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
+        appendOutputColor(buffer, module);
+    }
 }

-void ffPercentAppendNum(FFstrbuf* buffer, double percent, FFColorRangeConfig config, bool parentheses)
+void ffPercentAppendNum(FFstrbuf* buffer, double percent, FFColorRangeConfig config, bool parentheses, const FFModuleArgs* module)
 {
    uint8_t green = config.green, yellow = config.yellow;
    assert(green <= 100 && yellow <= 100);
@@ -120,6 +149,7 @@ void ffPercentAppendNum(FFstrbuf* buffer, double percent, FFColorRangeConfig con
    if (colored && !options->pipe)
    {
        ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
+        appendOutputColor(buffer, module);
    }

    if (parentheses)
@@ -2,13 +2,15 @@

 #include "util/FFstrbuf.h"
 #include "common/parsing.h"
+#include "common/option.h"

-enum
+enum FFPercentageTypeFlags
 {
    FF_PERCENTAGE_TYPE_NUM_BIT = 1 << 0,
    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,
 };

 // if (green <= yellow)
@@ -21,8 +23,8 @@ enum
 // [yellow, green): print yellow
 // [0, yellow): print red

-void ffPercentAppendBar(FFstrbuf* buffer, double percent, FFColorRangeConfig config);
-void ffPercentAppendNum(FFstrbuf* buffer, double percent, FFColorRangeConfig config, bool parentheses);
+void ffPercentAppendBar(FFstrbuf* buffer, double percent, FFColorRangeConfig config, const FFModuleArgs* module);
+void ffPercentAppendNum(FFstrbuf* buffer, double percent, FFColorRangeConfig config, bool parentheses, const FFModuleArgs* module);

 typedef struct yyjson_val yyjson_val;
 typedef struct yyjson_mut_doc yyjson_mut_doc;
@@ -11,56 +11,83 @@ void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFModu
        return;

    //This is used as a magic value for hiding keys
-    if(moduleArgs && ffStrbufEqualS(&moduleArgs->key, " "))
-        return;
+    if (!(moduleArgs && ffStrbufEqualS(&moduleArgs->key, " ")) && instance.config.display.keyType != FF_MODULE_KEY_TYPE_NONE)
+    {
+        ffPrintCharTimes(' ', instance.config.display.keyPaddingLeft);
+
+        if(!instance.config.display.pipe)
+        {
+            fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
+            if (instance.config.display.brightColor)
+                fputs(FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
+
+            if(moduleArgs && !(printType & FF_PRINT_TYPE_NO_CUSTOM_KEY_COLOR) && moduleArgs->keyColor.length > 0)
+                ffPrintColor(&moduleArgs->keyColor);
+            else
+                ffPrintColor(&instance.config.display.colorKeys);
+        }
+
+        bool hasIcon = false;
+        if (instance.config.display.keyType & FF_MODULE_KEY_TYPE_ICON && moduleArgs && moduleArgs->keyIcon.length > 0)
+        {
+            ffStrbufWriteTo(&moduleArgs->keyIcon, stdout);
+            hasIcon = true;
+        }
+
+        if (instance.config.display.keyType & FF_MODULE_KEY_TYPE_STRING)
+        {
+            if(hasIcon)
+                putchar(' ');
+
+            //NULL check is required for modules with custom keys, e.g. disk with the folder path
+            if((printType & FF_PRINT_TYPE_NO_CUSTOM_KEY) || !moduleArgs || moduleArgs->key.length == 0)
+            {
+                fputs(moduleName, stdout);
+
+                if(moduleIndex > 0)
+                    printf(" %hhu", moduleIndex);
+            }
+            else
+            {
+                FF_STRBUF_AUTO_DESTROY key = ffStrbufCreate();
+                FF_PARSE_FORMAT_STRING_CHECKED(&key, &moduleArgs->key, 2, ((FFformatarg[]){
+                    {FF_FORMAT_ARG_TYPE_UINT8, &moduleIndex, "index"},
+                    {FF_FORMAT_ARG_TYPE_STRBUF, &moduleArgs->keyIcon, "icon"},
+                }));
+                ffStrbufWriteTo(&key, stdout);
+            }
+        }
+
+        if(!instance.config.display.pipe)
+        {
+            fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
+            ffPrintColor(&instance.config.display.colorSeparator);
+        }
+
+        ffStrbufWriteTo(&instance.config.display.keyValueSeparator, stdout);
+
+        if(!instance.config.display.pipe && instance.config.display.colorSeparator.length)
+            fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
+
+        if (!(printType & FF_PRINT_TYPE_NO_CUSTOM_KEY_WIDTH))
+        {
+            uint32_t keyWidth = moduleArgs && moduleArgs->keyWidth > 0 ? moduleArgs->keyWidth : instance.config.display.keyWidth;
+            if (keyWidth > 0)
+                printf("\e[%uG", (unsigned) (keyWidth + instance.state.logoWidth));
+        }
+    }

    if(!instance.config.display.pipe)
    {
        fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
-        if (instance.config.display.brightColor)
-            fputs(FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
-
-        if(moduleArgs && !(printType & FF_PRINT_TYPE_NO_CUSTOM_KEY_COLOR) && moduleArgs->keyColor.length > 0)
-            ffPrintColor(&moduleArgs->keyColor);
-        else
-            ffPrintColor(&instance.config.display.colorKeys);
-    }
-
-    //NULL check is required for modules with custom keys, e.g. disk with the folder path
-    if((printType & FF_PRINT_TYPE_NO_CUSTOM_KEY) || !moduleArgs || moduleArgs->key.length == 0)
-    {
-        fputs(moduleName, stdout);
-
-        if(moduleIndex > 0)
-            printf(" %hhu", moduleIndex);
-    }
-    else
-    {
-        FF_STRBUF_AUTO_DESTROY key = ffStrbufCreate();
-        ffParseFormatString(&key, &moduleArgs->key, 1, (FFformatarg[]){
-            {FF_FORMAT_ARG_TYPE_UINT8, &moduleIndex}
-        });
-        ffStrbufWriteTo(&key, stdout);
-    }
-
-    if(!instance.config.display.pipe)
-        fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
-
-    ffStrbufWriteTo(&instance.config.display.keyValueSeparator, stdout);
-
-    if(!instance.config.display.pipe)
-        fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
-
-
-    if (!instance.config.display.pipe && !(printType & FF_PRINT_TYPE_NO_CUSTOM_KEY_WIDTH))
-    {
-        uint32_t keyWidth = moduleArgs && moduleArgs->keyWidth > 0 ? moduleArgs->keyWidth : instance.config.display.keyWidth;
-        if (keyWidth > 0)
-            printf("\e[%uG", (unsigned) (keyWidth + instance.state.logoWidth));
+        if (moduleArgs && moduleArgs->outputColor.length)
+            ffPrintColor(&moduleArgs->outputColor);
+        else if (instance.config.display.colorOutput.length)
+            ffPrintColor(&instance.config.display.colorOutput);
    }
 }

-void ffPrintFormatString(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, uint32_t numArgs, const FFformatarg* arguments)
+void ffPrintFormat(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, uint32_t numArgs, const FFformatarg* arguments)
 {
    FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
    if (moduleArgs)
@@ -68,11 +95,8 @@ void ffPrintFormatString(const char* moduleName, uint8_t moduleIndex, const FFMo
    else
        ffStrbufAppendS(&buffer, "unknown");

-    if(buffer.length > 0)
-    {
-        ffPrintLogoAndKey(moduleName, moduleIndex, moduleArgs, printType);
-        ffStrbufPutTo(&buffer, stdout);
-    }
+    ffPrintLogoAndKey(moduleName, moduleIndex, moduleArgs, printType);
+    ffStrbufPutTo(&buffer, stdout);
 }

 static void printError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, const char* message, va_list arguments)
@@ -93,7 +117,7 @@ static void printError(const char* moduleName, uint8_t moduleIndex, const FFModu
    putchar('\n');
 }

-void ffPrintErrorString(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, const char* message, ...)
+void ffPrintError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, const char* message, ...)
 {
    va_list arguments;
    va_start(arguments, message);
@@ -101,14 +125,6 @@ void ffPrintErrorString(const char* moduleName, uint8_t moduleIndex, const FFMod
    va_end(arguments);
 }

-void ffPrintError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...)
-{
-    va_list arguments;
-    va_start(arguments, message);
-    printError(moduleName, moduleIndex, moduleArgs, FF_PRINT_TYPE_DEFAULT, 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.
@@ -5,21 +5,24 @@

 typedef enum FFPrintType {
    FF_PRINT_TYPE_DEFAULT = 0,
-    FF_PRINT_TYPE_NO_CUSTOM_KEY = 1 << 0,
+    FF_PRINT_TYPE_NO_CUSTOM_KEY = 1 << 0, // key has been formatted outside
    FF_PRINT_TYPE_NO_CUSTOM_KEY_COLOR = 1 << 1,
    FF_PRINT_TYPE_NO_CUSTOM_KEY_WIDTH = 1 << 2,
    FF_PRINT_TYPE_NO_CUSTOM_OUTPUT_FORMAT = 1 << 3, // reserved
 } FFPrintType;

 void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType);
-void ffPrintFormatString(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, uint32_t numArgs, const FFformatarg* arguments);
-static inline void ffPrintFormat(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* arguments)
-{
-    ffPrintFormatString(moduleName, moduleIndex, moduleArgs, FF_PRINT_TYPE_DEFAULT, numArgs, arguments);
-}
-FF_C_PRINTF(5, 6) void ffPrintErrorString(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, const char* message, ...);
-FF_C_PRINTF(4, 5) void ffPrintError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...);
+void ffPrintFormat(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, uint32_t numArgs, const FFformatarg* arguments);
+#define FF_PRINT_FORMAT_CHECKED(moduleName, moduleIndex, moduleArgs, printType, numArgs, arguments) do {\
+    static_assert(sizeof(arguments) / sizeof(*(arguments)) == (numArgs), "Invalid number of format arguments");\
+    ffPrintFormat((moduleName), (moduleIndex), (moduleArgs), (printType), (numArgs), (arguments));\
+} while (0)
+FF_C_PRINTF(5, 6) void ffPrintError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, const char* message, ...);
 void ffPrintColor(const FFstrbuf* colorValue);
 void ffPrintCharTimes(char c, uint32_t times);

 void ffPrintModuleFormatHelp(const char* name, const char* def, uint32_t numArgs, const char* args[]);
+#define FF_PRINT_MODULE_FORMAT_HELP_CHECKED(moduleName, def, numArgs, args) do {\
+    static_assert(sizeof(args) / sizeof(*(args)) == (numArgs), "Invalid number of format arguments");\
+    ffPrintModuleFormatHelp((moduleName), (def), (numArgs), (args));\
+} while (0)
@@ -2,16 +2,15 @@

 #include "util/FFstrbuf.h"

+#include <sys/types.h>
+
 const char* ffProcessAppendOutput(FFstrbuf* buffer, char* const argv[], bool useStdErr);

 static inline const char* ffProcessAppendStdOut(FFstrbuf* buffer, char* const argv[])
 {
    const char* error = ffProcessAppendOutput(buffer, argv, false);
    if (!error)
-    {
-        ffStrbufTrimRight(buffer, '\n');
-        ffStrbufTrimRight(buffer, ' ');
-    }
+        ffStrbufTrimRightSpace(buffer);
    return error;
 }

@@ -19,9 +18,13 @@ static inline const char* ffProcessAppendStdErr(FFstrbuf* buffer, char* const ar
 {
    const char* error = ffProcessAppendOutput(buffer, argv, true);
    if (!error)
-    {
-        ffStrbufTrimRight(buffer, '\n');
-        ffStrbufTrimRight(buffer, ' ');
-    }
+        ffStrbufTrimRightSpace(buffer);
    return error;
 }
+
+#ifdef _WIN32
+bool ffProcessGetInfoWindows(uint32_t pid, uint32_t* ppid, FFstrbuf* pname, FFstrbuf* exe, const char** exeName, FFstrbuf* exePath, bool* gui);
+#else
+void ffProcessGetInfoLinux(pid_t pid, FFstrbuf* processName, FFstrbuf* exe, const char** exeName, FFstrbuf* exePath);
+const char* ffProcessGetBasicInfoLinux(pid_t pid, FFstrbuf* name, pid_t* ppid, int32_t* tty);
+#endif
@@ -2,6 +2,8 @@
 #include "common/processing.h"
 #include "common/io/io.h"
 #include "common/time.h"
+#include "util/stringUtils.h"
+#include "util/mallocHelper.h"

 #include <stdlib.h>
 #include <unistd.h>
@@ -11,6 +13,17 @@
 #include <errno.h>
 #include <sys/wait.h>

+#if defined(__FreeBSD__) || defined(__APPLE__)
+    #include <sys/types.h>
+    #include <sys/user.h>
+    #include <sys/sysctl.h>
+#endif
+#if defined(__APPLE__)
+    #include <libproc.h>
+#elif defined(__sun)
+    #include <procfs.h>
+#endif
+
 enum { FF_PIPE_BUFSIZ = 8192 };

 static inline int ffPipe2(int *fds, int flags)
@@ -68,7 +81,7 @@ const char* ffProcessAppendOutput(FFstrbuf* buffer, char* const argv[], bool use
            {
                kill(childPid, SIGTERM);
                waitpid(childPid, NULL, 0);
-                return "poll(&pollfd, 1, timeout) timeout";
+                return "poll(&pollfd, 1, timeout) timeout (try increasing --processing-timeout)";
            }
            else if (pollfd.revents & POLLERR)
            {
@@ -101,3 +114,270 @@ const char* ffProcessAppendOutput(FFstrbuf* buffer, char* const argv[], bool use

    return "read(childPipeFd, str, FF_PIPE_BUFSIZ) failed";
 }
+
+void ffProcessGetInfoLinux(pid_t pid, FFstrbuf* processName, FFstrbuf* exe, const char** exeName, FFstrbuf* exePath)
+{
+    assert(processName->length > 0);
+    ffStrbufClear(exe);
+
+    #ifdef __linux__
+
+    char filePath[64];
+    snprintf(filePath, sizeof(filePath), "/proc/%d/cmdline", (int)pid);
+
+    if(ffReadFileBuffer(filePath, exe))
+    {
+        ffStrbufRecalculateLength(exe); //Trim the arguments
+        ffStrbufTrimRightSpace(exe);
+        ffStrbufTrimLeft(exe, '-'); //Login shells start with a dash
+    }
+
+    if (exePath)
+    {
+        snprintf(filePath, sizeof(filePath), "/proc/%d/exe", (int)pid);
+        ffStrbufEnsureFixedLengthFree(exePath, PATH_MAX);
+        ssize_t length = readlink(filePath, exePath->chars, exePath->allocated - 1);
+        if (length > 0) // doesn't contain trailing NUL
+        {
+            exePath->chars[length] = '\0';
+            exePath->length = (uint32_t) length;
+        }
+    }
+
+    #elif defined(__APPLE__)
+
+    size_t len = 0;
+    int mibs[] = { CTL_KERN, KERN_PROCARGS2, pid };
+    if (sysctl(mibs, sizeof(mibs) / sizeof(*mibs), NULL, &len, NULL, 0) == 0)
+    {// try get arg0
+        #ifndef MAC_OS_X_VERSION_10_15
+        //don't know why if don't let len longer, proArgs2 and len will change during the following sysctl() in old MacOS version.
+        len++;
+        #endif
+        FF_AUTO_FREE char* const procArgs2 = malloc(len);
+        if (sysctl(mibs, sizeof(mibs) / sizeof(*mibs), procArgs2, &len, NULL, 0) == 0)
+        {
+            // https://gist.github.com/nonowarn/770696#file-getargv-c-L46
+            uint32_t argc = *(uint32_t*) procArgs2;
+            const char* realExePath = procArgs2 + sizeof(argc);
+
+            const char* arg0 = memchr(realExePath, '\0', len - (size_t) (realExePath - procArgs2));
+            if (exePath)
+                ffStrbufSetNS(exePath, (uint32_t) (arg0 - realExePath), realExePath);
+
+            do arg0++; while (*arg0 == '\0');
+            assert(arg0 < procArgs2 + len);
+
+            if (argc > 1)
+            {
+                // #977
+                const char* p = strrchr(arg0, '/');
+                if (p)
+                    p++;
+                else
+                    p = arg0;
+                if (ffStrStartsWithIgnCase(p, "python")) // /opt/homebrew/Cellar/python@3.12/3.12.3/Frameworks/Python.framework/Versions/3.12/Resources/Python.app/Contents/MacOS/Python /Users/carter/.local/bin/xonsh
+                    arg0 = p + strlen(p) + 1;
+            }
+
+            if (*arg0 == '-') arg0++; // Login shells
+
+            ffStrbufSetS(exe, arg0);
+        }
+    }
+    else
+    {
+        ffStrbufEnsureFixedLengthFree(exe, PATH_MAX);
+        int length = proc_pidpath(pid, exe->chars, exe->allocated);
+        if (length > 0)
+        {
+            exe->length = (uint32_t) length;
+            if (exePath)
+                ffStrbufSet(exePath, exe);
+        }
+    }
+
+    #elif defined(__FreeBSD__)
+
+    size_t size = ARG_MAX;
+    FF_AUTO_FREE char* args = malloc(size);
+
+    static_assert(ARG_MAX > PATH_MAX, "");
+
+    if(exePath && sysctl(
+        (int[]){CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, pid}, 4,
+        args, &size,
+        NULL, 0
+    ) == 0)
+        ffStrbufSetNS(exePath, (uint32_t) (size - 1), args);
+
+    size = ARG_MAX;
+    if(sysctl(
+        (int[]){CTL_KERN, KERN_PROC, KERN_PROC_ARGS, pid}, 4,
+        args, &size,
+        NULL, 0
+    ) == 0)
+    {
+        char* arg0 = args;
+        size_t arg0Len = strlen(args);
+        if (size > arg0Len + 1)
+        {
+            char* p = (char*) memrchr(args, '/', arg0Len);
+            if (p)
+                p++;
+            else
+                p = arg0;
+            if (ffStrStartsWith(p, "python")) // /usr/local/bin/python3.9 /home/carter/.local/bin/xonsh
+            {
+                arg0 += arg0Len + 1;
+            }
+        }
+        if (arg0[0] == '-') arg0++;
+        ffStrbufSetS(exe, arg0);
+    }
+
+    #elif defined(__sun)
+
+    char filePath[PATH_MAX];
+    snprintf(filePath, sizeof(filePath), "/proc/%d/psinfo", (int) pid);
+    psinfo_t proc;
+    if (ffReadFileData(filePath, sizeof(proc), &proc) == sizeof(proc))
+    {
+        ffStrbufSetS(exe, proc.pr_psargs);
+        ffStrbufSubstrBeforeFirstC(exe, ' ');
+    }
+
+    if (exePath)
+    {
+        snprintf(filePath, sizeof(filePath), "/proc/%d/path/a.out", (int) pid);
+        ffStrbufEnsureFixedLengthFree(exePath, PATH_MAX);
+        ssize_t length = readlink(filePath, exePath->chars, exePath->allocated - 1);
+        if (length > 0) // doesn't contain trailing NUL
+        {
+            exePath->chars[length] = '\0';
+            exePath->length = (uint32_t) length;
+        }
+    }
+
+    #endif
+
+    if(exe->length == 0)
+        ffStrbufSet(exe, processName);
+
+    assert(exe->length > 0);
+    uint32_t lastSlashIndex = ffStrbufLastIndexC(exe, '/');
+    if(lastSlashIndex < exe->length)
+        *exeName = exe->chars + lastSlashIndex + 1;
+}
+
+const char* ffProcessGetBasicInfoLinux(pid_t pid, FFstrbuf* name, pid_t* ppid, int32_t* tty)
+{
+    if (pid <= 0)
+        return "Invalid pid";
+
+    #ifdef __linux__
+
+    char procFilePath[64];
+    if (ppid)
+    {
+        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';
+
+        *ppid = 0;
+        static_assert(sizeof(*ppid) == sizeof(int), "");
+
+        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";
+
+        ffStrbufRecalculateLength(name);
+        if (tty)
+            *tty = tty_ & 0xFF;
+    }
+    else
+    {
+        snprintf(procFilePath, sizeof(procFilePath), "/proc/%d/comm", (int)pid);
+        ssize_t nRead = ffReadFileBuffer(procFilePath, name);
+        if(nRead <= 0)
+            return "ffReadFileBuffer(/proc/pid/comm, name) failed";
+        ffStrbufTrimRightSpace(name);
+    }
+
+    #elif defined(__APPLE__)
+
+    struct kinfo_proc proc;
+    size_t size = sizeof(proc);
+    if(sysctl(
+        (int[]){CTL_KERN, KERN_PROC, KERN_PROC_PID, pid}, 4,
+        &proc, &size,
+        NULL, 0
+    ))
+        return "sysctl(KERN_PROC_PID) failed";
+
+    ffStrbufSetS(name, proc.kp_proc.p_comm); //trancated to 16 chars
+    if (ppid)
+        *ppid = (pid_t)proc.kp_eproc.e_ppid;
+    if (tty)
+    {
+        *tty = ((proc.kp_eproc.e_tdev >> 24) & 0xFF) == 0x10
+            ? proc.kp_eproc.e_tdev & 0xFFFFFF
+            : -1;
+    }
+
+    #elif defined(__FreeBSD__)
+
+    struct kinfo_proc proc;
+    size_t size = sizeof(proc);
+    if(sysctl(
+        (int[]){CTL_KERN, KERN_PROC, KERN_PROC_PID, pid}, 4,
+        &proc, &size,
+        NULL, 0
+    ))
+        return "sysctl(KERN_PROC_PID) failed";
+
+    ffStrbufSetS(name, proc.ki_comm);
+    if (ppid)
+        *ppid = (pid_t)proc.ki_ppid;
+    if (tty)
+    {
+        if (proc.ki_tdev != NODEV && proc.ki_flag & P_CONTROLT)
+        {
+            const char* ttyName = devname(proc.ki_tdev, S_IFCHR);
+            if (ffStrStartsWith(ttyName, "pts/"))
+                *tty = (int32_t) strtol(ttyName + strlen("pts/"), NULL, 10);
+            else
+                *tty = -1;
+        }
+        else
+            *tty = -1;
+    }
+
+    #elif defined(__sun)
+    char path[128];
+    snprintf(path, sizeof(path), "/proc/%d/psinfo", (int) pid);
+    psinfo_t proc;
+    if (ffReadFileData(path, sizeof(proc), &proc) != sizeof(proc))
+        return "ffReadFileData(psinfo) failed";
+
+    ffStrbufSetS(name, proc.pr_fname);
+    if (ppid)
+        *ppid = proc.pr_ppid;
+    if (tty)
+        *tty = (int) proc.pr_ttydev;
+
+    #else
+
+    return "Unsupported platform";
+
+    #endif
+
+    return NULL;
+}
@@ -3,6 +3,8 @@
 #include "common/io/io.h"

 #include <Windows.h>
+#include <ntstatus.h>
+#include <winternl.h>

 enum { FF_PIPE_BUFSIZ = 8192 };

@@ -96,7 +98,7 @@ const char* ffProcessAppendOutput(FFstrbuf* buffer, char* const argv[], bool use
                {
                    CancelIo(hChildPipeRead);
                    TerminateProcess(hProcess, 1);
-                    return "WaitForSingleObject(hChildPipeRead) failed or timeout";
+                    return "WaitForSingleObject(hChildPipeRead) failed or timeout (try increasing --processing-timeout)";
                }

                if (!GetOverlappedResult(hChildPipeRead, &overlapped, &nRead, FALSE))
@@ -124,3 +126,46 @@ const char* ffProcessAppendOutput(FFstrbuf* buffer, char* const argv[], bool use

    return NULL;
 }
+
+bool ffProcessGetInfoWindows(uint32_t pid, uint32_t* ppid, FFstrbuf* pname, FFstrbuf* exe, const char** exeName, FFstrbuf* exePath, bool* gui)
+{
+    FF_AUTO_CLOSE_FD HANDLE hProcess = pid == 0
+        ? GetCurrentProcess()
+        : OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pid);
+
+    if (gui)
+        *gui = GetGuiResources(hProcess, GR_GDIOBJECTS) > 0;
+
+    if(ppid)
+    {
+        PROCESS_BASIC_INFORMATION info = {};
+        ULONG size;
+        if(NT_SUCCESS(NtQueryInformationProcess(hProcess, ProcessBasicInformation, &info, sizeof(info), &size)))
+        {
+            assert(size == sizeof(info));
+            *ppid = (uint32_t)info.InheritedFromUniqueProcessId;
+        }
+        else
+            return false;
+    }
+    if(exe)
+    {
+        DWORD bufSize = exe->allocated;
+        if(QueryFullProcessImageNameA(hProcess, 0, exe->chars, &bufSize))
+        {
+            // We use full path here
+            // Querying command line of remote processes in Windows requires either WMI or ReadProcessMemory
+            exe->length = bufSize;
+            if (exePath) ffStrbufSet(exePath, exe);
+        }
+        else
+            return false;
+    }
+    if(pname && exeName)
+    {
+        *exeName = exe->chars + ffStrbufLastIndexC(exe, '\\') + 1;
+        ffStrbufSetS(pname, *exeName);
+    }
+
+    return true;
+}
@@ -1,12 +1,15 @@
 #include "fastfetch.h"
 #include "common/properties.h"
+#include "common/io/io.h"
+#include "util/mallocHelper.h"

 #include <stdlib.h>
+#include <ctype.h>
 #ifdef _WIN32
    #include "util/windows/getline.h"
 #endif

-static bool parsePropLinePointer(const char** line, const char* start, FFstrbuf* buffer)
+bool ffParsePropLinePointer(const char** line, const char* start, FFstrbuf* buffer)
 {
    if(**line == '\0')
        return false;
@@ -30,7 +33,7 @@ static bool parsePropLinePointer(const char** line, const char* start, FFstrbuf*
        }

        //Line doesn't match start, skip it
-        if(**line != *start || **line == '\0')
+        if(tolower(**line) != tolower(*start) || **line == '\0')
            return false;

        //Line and start match, continue testing
@@ -67,14 +70,9 @@ static bool parsePropLinePointer(const char** line, const char* start, FFstrbuf*
    return true;
 }

-bool ffParsePropLine(const char* line, const char* start, FFstrbuf* buffer)
-{
-    return parsePropLinePointer(&line, start, buffer);
-}
-
 bool ffParsePropLines(const char* lines, const char* start, FFstrbuf* buffer)
 {
-    while(!parsePropLinePointer(&lines, start, buffer))
+    while(!ffParsePropLinePointer(&lines, start, buffer))
    {
        while(*lines != '\0' && *lines != '\n')
            ++lines;
@@ -95,50 +93,44 @@ bool ffParsePropLines(const char* lines, const char* start, FFstrbuf* buffer)

 bool ffParsePropFileValues(const char* filename, uint32_t numQueries, FFpropquery* queries)
 {
-    FILE* file = fopen(filename, "r");
-    if(file == NULL)
+    FF_AUTO_CLOSE_FILE FILE* file = fopen(filename, "r");
+    if (file == NULL)
        return false;

-    bool valueStorage[4];
-    bool* unsetValues;
+    bool valueStorage[32];
+    bool* unsetValues = valueStorage;

-    if(numQueries > sizeof(valueStorage) / sizeof(valueStorage[0]))
+    if (numQueries > sizeof(valueStorage) / sizeof(valueStorage[0]))
        unsetValues = malloc(sizeof(bool) * numQueries);
-    else
-        unsetValues = valueStorage;

    bool allSet = true;
-    for(uint32_t i = 0; i < numQueries; i++)
+    for (uint32_t i = 0; i < numQueries; i++)
    {
-        if((unsetValues[i] = queries[i].buffer->length == 0))
+        unsetValues[i] = queries[i].buffer->length == 0;
+        if (unsetValues[i])
            allSet = false;
    }

-    if(allSet)
-        goto done;
-
-    char* line = NULL;
-    size_t len = 0;
-
-    while (getline(&line, &len, file) != -1)
+    if (!allSet)
    {
-        for(uint32_t i = 0; i < numQueries; i++)
-        {
-            if(!unsetValues[i])
-                continue;
+        FF_AUTO_FREE char* line = NULL;
+        size_t len = 0;

-            uint32_t currentLength = queries[i].buffer->length;
-            queries[i].buffer->length = 0;
-            if(!ffParsePropLine(line, queries[i].start, queries[i].buffer))
-                queries[i].buffer->length = currentLength;
+        while (getline(&line, &len, file) != -1)
+        {
+            for(uint32_t i = 0; i < numQueries; i++)
+            {
+                if(!unsetValues[i])
+                    continue;
+
+                uint32_t currentLength = queries[i].buffer->length;
+                queries[i].buffer->length = 0;
+                if(!ffParsePropLine(line, queries[i].start, queries[i].buffer))
+                    queries[i].buffer->length = currentLength;
+            }
        }
    }

-    if(line != NULL)
-        free(line);
-
-done:
-    fclose(file);
    if(unsetValues != valueStorage)
        free(unsetValues);
    return true;
@@ -154,16 +146,13 @@ bool ffParsePropFileListValues(const FFlist* list, const char* relativeFile, uin
 {
    bool foundAFile = false;

-    FF_STRBUF_AUTO_DESTROY baseDir = ffStrbufCreateA(64);
-
    FF_LIST_FOR_EACH(FFstrbuf, dirPrefix, *list)
    {
-        //We need to copy the dir each time, because it used by multiple threads, so we can't directly write to it.
-        ffStrbufSet(&baseDir, dirPrefix);
-        ffStrbufAppendS(&baseDir, relativeFile);
-
-        if(ffParsePropFileValues(baseDir.chars, numQueries, queries))
+        const uint32_t dirPrefixLength = dirPrefix->length;
+        ffStrbufAppendS(dirPrefix, relativeFile);
+        if(ffParsePropFileValues(dirPrefix->chars, numQueries, queries))
            foundAFile = true;
+        ffStrbufSubstrBefore(dirPrefix, dirPrefixLength);

        bool allSet = true;
        for(uint32_t k = 0; k < numQueries; k++)
@@ -8,12 +8,18 @@ typedef struct FFpropquery
    FFstrbuf* buffer;
 } FFpropquery;

-bool ffParsePropLine(const char* line, const char* start, FFstrbuf* buffer);
 bool ffParsePropLines(const char* lines, const char* start, FFstrbuf* buffer);
 bool ffParsePropFileValues(const char* filename, uint32_t numQueries, FFpropquery* queries);
 bool ffParsePropFileHomeValues(const char* relativeFile, uint32_t numQueries, FFpropquery* queries);
 bool ffParsePropFileListValues(const FFlist* list, const char* relativeFile, uint32_t numQueries, FFpropquery* queries);

+bool ffParsePropLinePointer(const char** line, const char* start, FFstrbuf* buffer);
+
+static inline bool ffParsePropLine(const char* line, const char* start, FFstrbuf* buffer)
+{
+    return ffParsePropLinePointer(&line, start, buffer);
+}
+
 static inline bool ffParsePropFile(const char* filename, const char* start, FFstrbuf* buffer)
 {
    return ffParsePropFileValues(filename, 1, (FFpropquery[]){{start, buffer}});
@@ -6,45 +6,6 @@

 #include <string.h>

-typedef enum FFInitState
-{
-    FF_INITSTATE_UNINITIALIZED = 0,
-    FF_INITSTATE_SUCCESSFUL = 1,
-    FF_INITSTATE_FAILED = 2
-} FFInitState;
-
-#define FF_LIBRARY_DATA_LOAD_INIT(dataObject, userLibraryName, ...) \
-    static dataObject data; \
-    static FFInitState initState = FF_INITSTATE_UNINITIALIZED; \
-    if(initState != FF_INITSTATE_UNINITIALIZED) {\
-        return initState == FF_INITSTATE_SUCCESSFUL ? &data : NULL; \
-    } \
-    initState = FF_INITSTATE_SUCCESSFUL; \
-    void* libraryHandle = ffLibraryLoad(&userLibraryName, __VA_ARGS__, NULL); \
-    if(libraryHandle == NULL) { \
-        initState = FF_INITSTATE_FAILED; \
-        return NULL; \
-    } \
-
-#define FF_LIBRARY_DATA_LOAD_SYMBOL(symbolName) \
-    data.ff ## symbolName = dlsym(libraryHandle, #symbolName); \
-    if(data.ff ## symbolName == NULL) { \
-        dlclose(libraryHandle); \
-        initState = FF_INITSTATE_FAILED; \
-        return NULL; \
-    }
-
-#define FF_LIBRARY_DATA_LOAD_RETURN \
-    initState = FF_INITSTATE_SUCCESSFUL; \
-    return &data;
-
-#define FF_LIBRARY_DATA_LOAD_ERROR \
-    { \
-        dlclose(libraryHandle); \
-        initState = FF_INITSTATE_FAILED; \
-        return NULL; \
-    }
-
 #ifdef FF_HAVE_GIO
 #include <gio/gio.h>

@@ -88,32 +49,39 @@ typedef struct GSettingsData
    FF_LIBRARY_SYMBOL(g_settings_schema_source_get_default)
    GSettingsSchemaSource* schemaSource;
    GVariantGetters variantGetters;
+
+    bool inited;
 } GSettingsData;

 static const GSettingsData* getGSettingsData(void)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(GSettingsData, instance.config.library.libGIO, "libgio-2.0" FF_LIBRARY_EXTENSION, 1);
+    static GSettingsData data;

-    FF_LIBRARY_DATA_LOAD_SYMBOL(g_settings_schema_source_lookup)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(g_settings_schema_has_key)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(g_settings_new_full)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(g_settings_get_value)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(g_settings_get_user_value)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(g_settings_get_default_value)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(g_settings_schema_source_get_default)
+    if (!data.inited)
+    {
+        data.inited = true;
+        FF_LIBRARY_LOAD(libgsettings, &instance.config.library.libGIO, NULL, "libgio-2.0" FF_LIBRARY_EXTENSION, 1);
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data, g_settings_schema_source_lookup, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data, g_settings_schema_has_key, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data, g_settings_new_full, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data, g_settings_get_value, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data, g_settings_get_user_value, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data, g_settings_get_default_value, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data, g_settings_schema_source_get_default, NULL)

-    #define data data.variantGetters
-    FF_LIBRARY_DATA_LOAD_SYMBOL(g_variant_dup_string)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(g_variant_get_boolean)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(g_variant_get_int32)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(g_variant_unref);
-    #undef data
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data.variantGetters, g_variant_dup_string, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data.variantGetters, g_variant_get_boolean, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data.variantGetters, g_variant_get_int32, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libgsettings, data.variantGetters, g_variant_unref, NULL);

-    data.schemaSource = data.ffg_settings_schema_source_get_default();
-    if(data.schemaSource == NULL)
-        FF_LIBRARY_DATA_LOAD_ERROR
+        data.schemaSource = data.ffg_settings_schema_source_get_default();
+        if (data.schemaSource)
+            libgsettings = NULL;
+    }
+    if(!data.schemaSource)
+        return NULL;

-    FF_LIBRARY_DATA_LOAD_RETURN
+    return &data;
 }

 FFvariant ffSettingsGetGSettings(const char* schemaName, const char* path, const char* key, FFvarianttype type)
@@ -161,27 +129,34 @@ typedef struct DConfData
    FF_LIBRARY_SYMBOL(dconf_client_new)
    GVariantGetters variantGetters;
    DConfClient* client;
+
+    bool inited;
 } DConfData;

 static const DConfData* getDConfData(void)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(DConfData, instance.config.library.libDConf, "libdconf" FF_LIBRARY_EXTENSION, 2);
+    static DConfData data;

-    FF_LIBRARY_DATA_LOAD_SYMBOL(dconf_client_read_full)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(dconf_client_new)
+    if (!data.inited)
+    {
+        data.inited = true;

-    #define data data.variantGetters
-    FF_LIBRARY_DATA_LOAD_SYMBOL(g_variant_dup_string)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(g_variant_get_boolean)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(g_variant_get_int32)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(g_variant_unref)
-    #undef data
+        FF_LIBRARY_LOAD(libdconf, &instance.config.library.libDConf, NULL, "libdconf" FF_LIBRARY_EXTENSION, 2);
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libdconf, data, dconf_client_read_full, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libdconf, data, dconf_client_new, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libdconf, data.variantGetters, g_variant_dup_string, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libdconf, data.variantGetters, g_variant_get_boolean, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libdconf, data.variantGetters, g_variant_get_int32, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libdconf, data.variantGetters, g_variant_unref, NULL)

-    data.client = data.ffdconf_client_new();
-    if(data.client == NULL)
-        FF_LIBRARY_DATA_LOAD_ERROR
+        data.client = data.ffdconf_client_new();
+        if (data.client)
+            libdconf = NULL;
+    }
+    if(!data.client)
+        return NULL;

-    FF_LIBRARY_DATA_LOAD_RETURN
+    return &data;
 }

 FFvariant ffSettingsGetDConf(const char* key, FFvarianttype type)
@@ -232,23 +207,35 @@ typedef struct XFConfData
    FF_LIBRARY_SYMBOL(xfconf_channel_get_bool)
    FF_LIBRARY_SYMBOL(xfconf_channel_get_int)
    FF_LIBRARY_SYMBOL(xfconf_init)
+
+    bool inited;
 } XFConfData;

 static const XFConfData* getXFConfData(void)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(XFConfData, instance.config.library.libXFConf, "libxfconf-0" FF_LIBRARY_EXTENSION, 4);
+    static XFConfData data;

-    FF_LIBRARY_DATA_LOAD_SYMBOL(xfconf_channel_get)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(xfconf_channel_has_property)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(xfconf_channel_get_string)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(xfconf_channel_get_bool)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(xfconf_channel_get_int)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(xfconf_init)
+    if (!data.inited)
+    {
+        data.inited = true;
+        FF_LIBRARY_LOAD(libxfconf, &instance.config.library.libXFConf, NULL, "libxfconf-0" FF_LIBRARY_EXTENSION, 4);

-    if(data.ffxfconf_init(NULL) == false)
-        FF_LIBRARY_DATA_LOAD_ERROR
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libxfconf, data, xfconf_channel_get, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libxfconf, data, xfconf_channel_has_property, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libxfconf, data, xfconf_channel_get_string, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libxfconf, data, xfconf_channel_get_bool, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libxfconf, data, xfconf_channel_get_int, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libxfconf, data, xfconf_init, NULL)
+        if(!data.ffxfconf_init(NULL))
+            data.ffxfconf_init = NULL;
+        else
+            libxfconf = NULL;
+    }

-    FF_LIBRARY_DATA_LOAD_RETURN
+    if(!data.ffxfconf_init)
+        return NULL;
+
+    return &data;
 }

 FFvariant ffSettingsGetXFConf(const char* channelName, const char* propertyName, FFvarianttype type)
@@ -294,22 +281,33 @@ typedef struct SQLiteData
    FF_LIBRARY_SYMBOL(sqlite3_column_text)
    FF_LIBRARY_SYMBOL(sqlite3_finalize)
    FF_LIBRARY_SYMBOL(sqlite3_close)
+
+    bool inited;
 } SQLiteData;

 static const SQLiteData* getSQLiteData(void)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(SQLiteData, instance.config.library.libSQLite3, "libsqlite3" FF_LIBRARY_EXTENSION, 1);
+    static SQLiteData data;

-    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_open_v2)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_prepare_v2)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_step)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_data_count)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_column_int)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_column_text)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_finalize)
-    FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_close)
+    if (!data.inited)
+    {
+        data.inited = true;
+        FF_LIBRARY_LOAD(libsqlite, &instance.config.library.libSQLite3, NULL, "libsqlite3" FF_LIBRARY_EXTENSION, 1);
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libsqlite, data, sqlite3_open_v2, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libsqlite, data, sqlite3_prepare_v2, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libsqlite, data, sqlite3_step, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libsqlite, data, sqlite3_data_count, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libsqlite, data, sqlite3_column_int, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libsqlite, data, sqlite3_column_text, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libsqlite, data, sqlite3_finalize, NULL)
+        FF_LIBRARY_LOAD_SYMBOL_VAR(libsqlite, data, sqlite3_close, NULL)
+        libsqlite = NULL;
+    }

-    FF_LIBRARY_DATA_LOAD_RETURN
+    if (!data.ffsqlite3_close)
+        return NULL;
+
+    return &data;
 }

 int ffSettingsGetSQLite3Int(const char* dbPath, const char* query)
@@ -3,7 +3,7 @@
 #include "util/textModifier.h"
 #include "util/stringUtils.h"

-void ffTempsAppendNum(double celsius, FFstrbuf* buffer, FFColorRangeConfig config)
+void ffTempsAppendNum(double celsius, FFstrbuf* buffer, FFColorRangeConfig config, const FFModuleArgs* module)
 {
    if (celsius != celsius) // ignores NaN
        return;
@@ -37,7 +37,7 @@ void ffTempsAppendNum(double celsius, FFstrbuf* buffer, FFColorRangeConfig confi
        }
    }

-    switch (options->temperatureUnit)
+    switch (options->tempUnit)
    {
        case FF_TEMPERATURE_UNIT_CELSIUS:
            ffStrbufAppendF(buffer, "%.*f°C", options->tempNdigits, celsius);
@@ -51,7 +51,13 @@ void ffTempsAppendNum(double celsius, FFstrbuf* buffer, FFColorRangeConfig confi
    }

    if (!options->pipe)
+    {
        ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
+        if (module->outputColor.length)
+            ffStrbufAppendF(buffer, "\e[%sm", module->outputColor.chars);
+        else if (instance.config.display.colorOutput.length)
+            ffStrbufAppendF(buffer, "\e[%sm", instance.config.display.colorOutput.chars);
+    }
 }

 bool ffTempsParseCommandOptions(const char* key, const char* subkey, const char* value, bool* useTemp, FFColorRangeConfig* config)
--- a/Show More
+++ b/Show More